Header	Type	Required	Description
Authorization	string	Required	JWT Token for authentication
Content-Type	string	Required	application/json

Parameter	Type	Required	Description
claim_ref_no	string	Required	Unique claim reference number
Client Name	string	Required	Partner / Client company name
Client Email	string	Required	Partner email address
Name	string	Required	Customer name
CustomerMobile	string	Required	10-digit mobile number
CustomerEmail	string	Required	Customer email address
Engagement_Type	string	Required	Service type: "Home", "Pickup", or "Walk-in"
AddressLine1	string	Required	Primary address line
City	string	Required	City name (alphabets only)
State	string	Required	State name (alphabets only)
Pincode	string	Required	6-digit postal code
AssetType	string	Required	Device category (e.g., "Mobile", "Laptop")
Make	string	Required	Device brand name
Model	string	Required	Device model
IMEINo	string	Required	IMEI or Serial Number
Issue	string	Required	Problem description

Status Code	Error Type	Description	Solution
400	Bad Request	Missing required fields	Ensure all required fields are included
400	Validation Error	Invalid City/State format	Use alphabets only for City and State
400	Validation Error	Invalid Pincode format	Provide 6-digit pincode
400	Validation Error	Invalid Mobile format	Provide 10-digit mobile number
409	Conflict	Duplicate claim reference number	Use a unique claim_ref_no
500	Server Error	Internal server error	Retry request or contact support

Parameter	Type	Required	Description
Client Email	string	Required	Partner/Client email address for notifications
Client Name	string	Required	Partner/Client company name
customFile	file	Required	Excel file (.xlsx) containing claim orders

Column Name	Required	Format	Example
claim_ref_no	Required	Unique text	CLM10001
Name	Required	Text	Rahul Kumar
CustomerMobile	Required	10 digits	9876543210
CustomerEmail	Required	Valid email	rahul@gmail.com
Engagement_Type	Required	Home/Pickup/Walk-in	Home
AddressLine1	Required	Text	No 12, MG Road
City	Required	Alphabets only	Chennai
State	Required	Alphabets only	Tamil Nadu
Pincode	Required	6 digits	600001
AssetType	Required	Text	Mobile
Make	Required	Text	Samsung
Model	Required	Text	Galaxy S23
IMEINo	Required	15 digits	123456789012345
Issue	Required	Text	Screen damage

Field	Type	Description
Success	string	"True" for successful processing
Status_code	integer	HTTP status code (200)
Message	string	Summary message with count
Uploaded_Orders_Count	integer	Number of successfully uploaded orders
Duplicate_Orders_Count	integer	Number of duplicate orders found
Duplicate_Reference_IDs	array	List of duplicate claim reference numbers

Status Code	Error Type	Description	Solution
400	Missing Email	Email is required	Provide Client Email parameter
400	Missing Client Name	Client name is required	Provide Client Name parameter
400	Missing File	File upload is required	Include customFile in request
400	Limit Exceeded	The number of orders cannot exceed 1000	Split into multiple uploads
401	Unauthorized	Invalid or missing API key	Verify X-API-Key header
500	Server Error	An error occurred during processing	Check file format or contact support

Download Excel Template API

Download the Excel template file for bulk claim order uploads. This template includes pre-defined column headers and sample data to help you format your bulk upload files correctly.

GET https://api.bigfix.in/api/warrantify/sample-template/

Authentication

This endpoint requires proper authentication to download the template file.

Header	Type	Required	Description
X-API-Key	string	Required	Your API authentication key

Request Parameters

This is a simple GET request with no additional parameters required.

Template Structure

The downloaded Excel template contains the following pre-defined columns:

Column Name	Data Type	Format	Sample Value
claim_ref_no	string	Unique text	CLM10001
Name	string	Text	Rahul Kumar
CustomerMobile	string	10 digits	9876543210
CustomerEmail	string	Valid email	rahul@gmail.com
Engagement_Type	string	Home/Pickup/Walk-in	Home
AddressLine1	string	Text	No 12, MG Road
City	string	Alphabets only	Chennai
State	string	Alphabets only	Tamil Nadu
Pincode	string	6 digits	600001
AssetType	string	Text	Mobile
Make	string	Text	Samsung
Model	string	Text	Galaxy S23
IMEINo	string	15 digits	123456789012345
Issue	string	Text	Screen damage

Success Response

On successful request, the API returns an Excel file download:

Response Type	Content-Type	Filename
File Download	application/vnd.openxmlformats-officedocument.spreadsheetml.sheet	template.xlsx

Error Responses

The API may return the following error codes:

Status Code	Error Type	Description	Solution
401	Unauthorized	Invalid or missing API key	Verify X-API-Key header
404	Not Found	Template file not found on server	Contact support team
500	Server Error	Error serving the template file	Retry request or contact support

How to Use the Template

Step-by-Step Guide:

Download the template using this API endpoint
Open the file in Microsoft Excel or compatible software
Review the sample data row to understand the format
Delete the sample data row(s)
Add your actual claim order data (up to 1000 rows)
Ensure all required fields are filled correctly
Save the file as .xlsx format
Upload using the Bulk Claim Order Upload API

Best Practices

Tips for Success:

Do not modify or delete the column headers
Keep the column order exactly as provided
Use the sample data as a reference for formatting
Validate data before saving the file
Maintain the .xlsx file format (don't convert to .xls or .csv)
Keep file size under 10MB for optimal upload performance

Important Notes:

Column headers are case-sensitive and must match exactly
Empty rows will be skipped during upload
Maximum 1000 orders per file upload
Invalid data formats will cause upload errors

Code Examples

Download Template

curl --location 'https://api.bigfix.in/api/warrantify/sample-template/' \
                                --header 'X-API-Key: YOUR_API_KEY' \
                                --output template.xlsx

Response Headers

HTTP/1.1 200 OK
                                Content-Type: application/vnd.openxmlformats-officedocument.spreadsheetml.sheet
                                Content-Disposition: attachment; filename="template.xlsx"
                                Content-Length: 8542

Error Response (404)

File not found.

Download Template

const axios = require('axios');
                                const fs = require('fs');

                                const downloadTemplate = async () => {
                                try {
                                    const response = await axios.get(
                                    'https://api.bigfix.in/api/warrantify/sample-template/',
                                    {
                                        headers: {
                                        'X-API-Key': 'YOUR_API_KEY'
                                        },
                                        responseType: 'arraybuffer'
                                    }
                                    );

                                    // Save the file
                                    fs.writeFileSync('template.xlsx', response.data);
                                    console.log('✅ Template downloaded successfully!');
                                    
                                    return true;
                                } catch (error) {
                                    console.error('❌ Download failed:', error.message);
                                    return false;
                                }
                                };

                                // Execute download
                                downloadTemplate();

With Progress Indicator

const axios = require('axios');
                                const fs = require('fs');

                                const downloadTemplate = async (outputPath = 'template.xlsx') => {
                                console.log('📥 Downloading template...');
                                
                                try {
                                    const response = await axios.get(
                                    'https://api.bigfix.in/api/warrantify/sample-template/',
                                    {
                                        headers: {
                                        'X-API-Key': 'YOUR_API_KEY'
                                        },
                                        responseType: 'arraybuffer',
                                        onDownloadProgress: (progressEvent) => {
                                        const percentCompleted = Math.round(
                                            (progressEvent.loaded * 100) / progressEvent.total
                                        );
                                        console.log(`Progress: ${percentCompleted}%`);
                                        }
                                    }
                                    );

                                    fs.writeFileSync(outputPath, response.data);
                                    console.log(`✅ Template saved to: ${outputPath}`);
                                    
                                    return {
                                    success: true,
                                    path: outputPath,
                                    size: response.data.length
                                    };
                                } catch (error) {
                                    console.error('❌ Error:', error.response?.data || error.message);
                                    return { success: false, error: error.message };
                                }
                                };

                                downloadTemplate('./claim_template.xlsx');

Download Template

                                import requests

                                url = "https://api.bigfix.in/api/warrantify/sample-template/"

                                headers = {
                                    'X-API-Key': 'YOUR_API_KEY'
                                }

                                response = requests.get(url, headers=headers)

                                if response.status_code == 200:
                                    # Save the file
                                    with open('template.xlsx', 'wb') as f:
                                        f.write(response.content)
                                    print("✅ Template downloaded successfully!")
                                else:
                                    print(f"❌ Error {response.status_code}: {response.text}")

With Error Handling

import requests
                                import os

                                def download_claim_template(output_path='template.xlsx'):
                                    """Download the Excel template for bulk claim uploads"""
                                    
                                    url = "https://api.bigfix.in/api/warrantify/sample-template/"
                                    
                                    headers = {
                                        'X-API-Key': 'YOUR_API_KEY'
                                    }
                                    
                                    try:
                                        print("📥 Downloading template...")
                                        
                                        response = requests.get(url, headers=headers, timeout=30)
                                        
                                        if response.status_code == 200:
                                            # Check content type
                                            content_type = response.headers.get('Content-Type', '')
                                            expected_type = 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
                                            
                                            if expected_type not in content_type:
                                                print(f"⚠️  Warning: Unexpected content type: {content_type}")
                                            
                                            # Save file
                                            with open(output_path, 'wb') as f:
                                                f.write(response.content)
                                            
                                            file_size = os.path.getsize(output_path)
                                            print(f"✅ Template downloaded successfully!")
                                            print(f"📄 File: {output_path}")
                                            print(f"📊 Size: {file_size:,} bytes")
                                            
                                            return True
                                            
                                        elif response.status_code == 404:
                                            print("❌ Template file not found on server")
                                            return False
                                            
                                        elif response.status_code == 401:
                                            print("❌ Unauthorized: Check your API key")
                                            return False
                                            
                                        else:
                                            print(f"❌ Error {response.status_code}: {response.text}")
                                            return False
                                            
                                    except requests.exceptions.Timeout:
                                        print("❌ Request timed out")
                                        return False
                                        
                                    except requests.exceptions.RequestException as e:
                                        print(f"❌ Request failed: {str(e)}")
                                        return False
                                        
                                    except IOError as e:
                                        print(f"❌ File save error: {str(e)}")
                                        return False

                                # Usage
                                download_claim_template('claim_orders_template.xlsx')

Download Template

With Class Implementation

apiKey = $apiKey;
                                        $this->baseUrl = 'https://api.bigfix.in/api/warrantify';
                                    }
                                    
                                    public function downloadTemplate($outputPath = 'template.xlsx') {
                                        $url = $this->baseUrl . '/sample-template/';
                                        
                                        $headers = array(
                                            'X-API-Key: ' . $this->apiKey
                                        );
                                        
                                        $ch = curl_init($url);
                                        curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
                                        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
                                        curl_setopt($ch, CURLOPT_FOLLOWLOCATION, true);
                                        curl_setopt($ch, CURLOPT_TIMEOUT, 30);
                                        
                                        $response = curl_exec($ch);
                                        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
                                        $contentType = curl_getinfo($ch, CURLINFO_CONTENT_TYPE);
                                        
                                        if (curl_errno($ch)) {
                                            $error = curl_error($ch);
                                            curl_close($ch);
                                            return [
                                                'success' => false,
                                                'error' => 'cURL error: ' . $error
                                            ];
                                        }
                                        
                                        curl_close($ch);
                                        
                                        if ($httpCode === 200) {
                                            $bytes = file_put_contents($outputPath, $response);
                                            
                                            if ($bytes === false) {
                                                return [
                                                    'success' => false,
                                                    'error' => 'Failed to save file'
                                                ];
                                            }
                                            
                                            return [
                                                'success' => true,
                                                'path' => $outputPath,
                                                'size' => $bytes,
                                                'message' => 'Template downloaded successfully'
                                            ];
                                        } else {
                                            return [
                                                'success' => false,
                                                'http_code' => $httpCode,
                                                'error' => $response
                                            ];
                                        }
                                    }
                                    
                                    public function printDownloadResult($result) {
                                        if ($result['success']) {
                                            echo "✅ " . $result['message'] . "\n";
                                            echo "📄 File: " . $result['path'] . "\n";
                                            echo "📊 Size: " . number_format($result['size']) . " bytes\n";
                                        } else {
                                            echo "❌ Download failed: " . $result['error'] . "\n";
                                        }
                                    }
                                }

                                // Usage
                                $downloader = new TemplateDownloader('YOUR_API_KEY');
                                $result = $downloader->downloadTemplate('claim_template.xlsx');
                                $downloader->printDownloadResult($result);
                                ?>

Order Tracking API

Track claim orders in real-time using the Reference ID. This API provides detailed tracking information including current status and complete tracking history with timestamps.

GET https://api.bigfix.in/api/warrantify/claim/tracking/

Authentication

All API requests must include proper authentication headers.

Header	Type	Required	Description
X-API-Key	string	Required	Your API authentication key

Query Parameters

Pass the reference ID as a query parameter to track the order.

Parameter	Type	Required	Description
ReferenceID	string	Required	Unique reference ID of the claim order (case-sensitive)

Tracking Workflows

The API supports three different tracking workflows based on the order type:

Workflow Types:

Service Center Flow: Orders sent to service centers for part replacement
Technician Flow: Orders handled by technicians with parts
No Part Call Flow: Orders that don't require part replacement

Service Center Flow

Status Code	Description
created	Order created in system
assigned	Assigned to technician
accepted	Technician accepted the order
reached customer location	Technician reached customer location
customer not in location	Customer unavailable at location
pickup done	Device picked up from customer
estimation raised	Repair estimation created
verified date	Estimation verified
reached service centre	Device reached service center
part demanded	Replacement part requested
awaiting approval	Waiting for approval
approved	Repair approved
handed over to ASP	Handed to authorized service provider
part allocated	Replacement part allocated
part received	Part received at service center
performing service	Device under repair
devicecollectedfromasp	Device collected from ASP
repair completed	Repair work completed
Servicer visit	Service personnel visit scheduled/completed
delivered	Device delivered to customer

Technician Flow

Status Code	Description
created	Order created in system
assigned	Assigned to technician
accepted	Technician accepted the order
reached customer location	Technician reached customer location
customer not in location	Customer unavailable at location
pickup done	Device picked up from customer
estimation raised	Repair estimation created
verified date	Estimation verified
part demanded	Replacement part requested
awaiting approval	Waiting for approval
approved	Repair approved
handed over to ASP	Handed to authorized service provider
part allocated	Replacement part allocated
part received	Part received by technician
technician visit	Technician visit scheduled/completed
performing service	Device under repair
devicecollectedfromasp	Device collected from ASP
repair completed	Repair work completed
delivered	Device delivered to customer

No Part Call Flow

Status Code	Description
created	Order created in system
assigned	Assigned to technician
accepted	Technician accepted the order
reached customer location	Technician reached customer location
customer not in location	Customer unavailable at location
pickup done	Device picked up from customer
estimation raised	Repair estimation created
verified date	Estimation verified
diagnosis complete	Diagnosis completed (no parts needed)
awaiting approval	Waiting for approval
approved	Repair approved
handed over to ASP	Handed to authorized service provider
performing service	Device under repair
device collected from ASP	Device collected from ASP
repair completed	Repair work completed
delivered	Device delivered to customer

Success Response

When tracking information is found, the API returns the current status and complete tracking history:

Field	Type	Description
Success	string	"True" for successful requests
Status_code	string	HTTP status code "200"
DATA.current_status	object	Current status with date and status code
DATA.current_status.date	string	Date and time in format DD-MM-YYYY HH:MM:SS
DATA.current_status.status	string	Current status description
DATA.tracking_details	array	Array of all tracking events with dates and statuses

Response Details:

current_status: Shows the most recent status update
tracking_details: Contains complete chronological history
Multiple visits: Customer location visits are numbered (e.g., "reached customer location - 1", "reached customer location - 2")
Date format: All dates follow DD-MM-YYYY HH:MM:SS format

Error Responses

The API may return the following error codes:

Status Code	Error Type	Description	Solution
400	Bad Request	ReferenceID is required as a query parameter	Include ReferenceID in query string
401	Unauthorized	Invalid or missing API key	Verify X-API-Key header
404	Not Found	Reference ID does not exist	Verify the Reference ID is correct
200	No Tracking Data	No tracking information available	Order exists but tracking not yet started
500	Server Error	Internal server error	Retry request or contact support

Best Practices

Recommendations:

Store the Reference ID immediately after order creation
Use exact Reference ID (case-sensitive matching)
Poll this endpoint periodically for status updates
Implement caching to reduce API calls
Handle "No tracking information available" gracefully
Parse dates consistently using DD-MM-YYYY HH:MM:SS format

Important Notes:

Tracking information may not be available immediately after order creation
Multiple customer visits are numbered sequentially
Status workflow varies based on part requirements
All timestamps are in server timezone

Code Examples

Request Example

curl --location 'https://api.bigfix.in/api/warrantify/claim/tracking/?ReferenceID=CLM10001' \
                              --header 'X-API-Key: YOUR_API_KEY'

Success Response (200)

{
                                "Success": "True",
                                "Status_code": "200",
                                "DATA": {
                                    "current_status": {
                                    "date": "16-02-2026 14:30:45",
                                    "status": "performing service"
                                    },
                                    "tracking_details": [
                                    {
                                        "date": "15-02-2026 10:15:30",
                                        "status": "created"
                                    },
                                    {
                                        "date": "15-02-2026 11:20:15",
                                        "status": "assigned"
                                    },
                                    {
                                        "date": "15-02-2026 12:45:00",
                                        "status": "accepted"
                                    },
                                    {
                                        "date": "15-02-2026 15:30:25",
                                        "status": "reached customer location - 1"
                                    },
                                    {
                                        "date": "15-02-2026 16:00:10",
                                        "status": "pickup done"
                                    },
                                    {
                                        "date": "16-02-2026 09:15:40",
                                        "status": "estimation raised"
                                    },
                                    {
                                        "date": "16-02-2026 10:30:20",
                                        "status": "approved"
                                    },
                                    {
                                        "date": "16-02-2026 14:30:45",
                                        "status": "performing service"
                                    }
                                    ]
                                }
                                }

Error Response (404)

{
                                "Success": "False",
                                "Status_code": "404",
                                "Message": "Reference ID: CLM10001 does not exist."
                                }

Request Example

                                const axios = require('axios');

                                const trackOrder = async (referenceId) => {
                                try {
                                    const response = await axios.get(
                                    'https://api.bigfix.in/api/warrantify/claim/tracking/',
                                    {
                                        params: {
                                        ReferenceID: referenceId
                                        },
                                        headers: {
                                        'X-API-Key': 'YOUR_API_KEY'
                                        }
                                    }
                                    );

                                    if (response.data.Success === "True") {
                                    console.log('Current Status:', response.data.DATA.current_status);
                                    console.log('\nTracking History:');
                                    response.data.DATA.tracking_details.forEach((event, index) => {
                                        console.log(`${index + 1}. ${event.date} - ${event.status}`);
                                    });
                                    }

                                    return response.data;
                                } catch (error) {
                                    console.error('Error:', error.response?.data || error.message);
                                    return null;
                                }
                                };

                                // Usage
                                trackOrder('CLM10001');

With Polling

const axios = require('axios');

                                class OrderTracker {
                                constructor(apiKey) {
                                    this.apiKey = apiKey;
                                    this.baseUrl = 'https://api.bigfix.in/api/warrantify/claim/tracking/';
                                }

                                async getTracking(referenceId) {
                                    try {
                                    const response = await axios.get(this.baseUrl, {
                                        params: { ReferenceID: referenceId },
                                        headers: { 'X-API-Key': this.apiKey }
                                    });
                                    return response.data;
                                    } catch (error) {
                                    throw new Error(error.response?.data?.Message || error.message);
                                    }
                                }

                                async pollUntilStatus(referenceId, targetStatus, intervalMs = 30000, maxAttempts = 20) {
                                    let attempts = 0;

                                    while (attempts < maxAttempts) {
                                    const tracking = await this.getTracking(referenceId);

                                    if (tracking.Success === "True" && tracking.DATA.current_status) {
                                        console.log(`Current: ${tracking.DATA.current_status.status}`);

                                        if (tracking.DATA.current_status.status === targetStatus) {
                                        console.log(`✅ Reached target status: ${targetStatus}`);
                                        return tracking;
                                        }
                                    }

                                    attempts++;
                                    console.log(`Waiting ${intervalMs/1000}s... (${attempts}/${maxAttempts})`);
                                    await new Promise(resolve => setTimeout(resolve, intervalMs));
                                    }

                                    throw new Error('Max polling attempts reached');
                                }
                                }

                                // Usage
                                const tracker = new OrderTracker('YOUR_API_KEY');
                                tracker.pollUntilStatus('CLM10001', 'delivered', 30000, 20)
                                .then(result => console.log('Order delivered!', result))
                                .catch(err => console.error('Error:', err));

Request Example

import requests

                                url = "https://api.bigfix.in/api/warrantify/claim/tracking/"

                                headers = {
                                    'X-API-Key': 'YOUR_API_KEY'
                                }

                                params = {
                                    'ReferenceID': 'CLM10001'
                                }

                                response = requests.get(url, headers=headers, params=params)

                                if response.status_code == 200:
                                    data = response.json()
                                    
                                    if data['Success'] == 'True':
                                        print("Current Status:")
                                        print(f"  Date: {data['DATA']['current_status']['date']}")
                                        print(f"  Status: {data['DATA']['current_status']['status']}")
                                        
                                        print("\nTracking History:")
                                        for idx, event in enumerate(data['DATA']['tracking_details'], 1):
                                            print(f"{idx}. {event['date']} - {event['status']}")
                                else:
                                    print(f"Error {response.status_code}: {response.text}")

With Class Implementation

                                import requests
                                import time
                                from datetime import datetime

                                class ClaimOrderTracker:
                                    def __init__(self, api_key):
                                        self.api_key = api_key
                                        self.base_url = "https://api.bigfix.in/api/warrantify/claim/tracking/"
                                    
                                    def get_tracking(self, reference_id):
                                        """Get tracking information for a claim order"""
                                        headers = {'X-API-Key': self.api_key}
                                        params = {'ReferenceID': reference_id}
                                        
                                        try:
                                            response = requests.get(
                                                self.base_url, 
                                                headers=headers, 
                                                params=params,
                                                timeout=30
                                            )
                                            
                                            if response.status_code == 200:
                                                return response.json()
                                            elif response.status_code == 404:
                                                return {
                                                    'Success': 'False',
                                                    'Message': f'Reference ID {reference_id} not found'
                                                }
                                            else:
                                                return {
                                                    'Success': 'False',
                                                    'Message': f'Error {response.status_code}'
                                                }
                                        except Exception as e:
                                            return {
                                                'Success': 'False',
                                                'Message': f'Request failed: {str(e)}'
                                            }
                                    
                                    def print_tracking(self, reference_id):
                                        """Print formatted tracking information"""
                                        result = self.get_tracking(reference_id)
                                        
                                        if result['Success'] == 'True':
                                            print(f"\n📦 Order Tracking: {reference_id}")
                                            print("=" * 60)
                                            
                                            current = result['DATA']['current_status']
                                            print(f"\n🔵 Current Status: {current['status']}")
                                            print(f"   Date: {current['date']}")
                                            
                                            print(f"\n📋 Tracking History ({len(result['DATA']['tracking_details'])} events):")
                                            print("-" * 60)
                                            
                                            for event in result['DATA']['tracking_details']:
                                                print(f"  {event['date']} | {event['status']}")
                                            
                                            print("=" * 60)
                                        else:
                                            print(f"\n❌ {result.get('Message', 'Tracking failed')}")
                                    
                                    def poll_until_status(self, reference_id, target_status, 
                                                        interval=30, max_attempts=20):
                                        """Poll tracking until target status is reached"""
                                        print(f"🔍 Polling for status: {target_status}")
                                        
                                        for attempt in range(1, max_attempts + 1):
                                            result = self.get_tracking(reference_id)
                                            
                                            if result['Success'] == 'True':
                                                current = result['DATA']['current_status']['status']
                                                print(f"Attempt {attempt}: {current}")
                                                
                                                if current == target_status:
                                                    print(f"✅ Target status reached!")
                                                    return result
                                            
                                            if attempt < max_attempts:
                                                print(f"   Waiting {interval}s...")
                                                time.sleep(interval)
                                        
                                        print(f"❌ Max attempts reached")
                                        return None

                                # Usage
                                tracker = ClaimOrderTracker('YOUR_API_KEY')
                                tracker.print_tracking('CLM10001')

                                # Poll until delivered
                                # tracker.poll_until_status('CLM10001', 'delivered', interval=30, max_attempts=20)

Request Example

 $event) {
                                        echo ($index + 1) . ". " . $event['date'] . " - " . $event['status'] . "\n";
                                    }
                                } else {
                                    echo "Error: " . ($result['Message'] ?? 'Unknown error') . "\n";
                                }
                                ?>

With Class Implementation

apiKey = $apiKey;
                                        $this->baseUrl = 'https://api.bigfix.in/api/warrantify/claim/tracking/';
                                    }
                                    
                                    public function getTracking($referenceId) {
                                        $url = $this->baseUrl . '?ReferenceID=' . urlencode($referenceId);
                                        
                                        $headers = array(
                                            'X-API-Key: ' . $this->apiKey
                                        );
                                        
                                        $ch = curl_init($url);
                                        curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
                                        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
                                        curl_setopt($ch, CURLOPT_TIMEOUT, 30);
                                        
                                        $response = curl_exec($ch);
                                        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
                                        
                                        if (curl_errno($ch)) {
                                            $error = curl_error($ch);
                                            curl_close($ch);
                                            return [
                                                'success' => false,
                                                'error' => 'cURL error: ' . $error
                                            ];
                                        }
                                        
                                        curl_close($ch);
                                        
                                        $result = json_decode($response, true);
                                        
                                        return [
                                            'success' => $httpCode === 200 && $result['Success'] === 'True',
                                            'http_code' => $httpCode,
                                            'data' => $result
                                        ];
                                    }
                                    
                                    public function printTracking($referenceId) {
                                        echo "\n📦 Order Tracking: {$referenceId}\n";
                                        echo str_repeat("=", 60) . "\n";
                                        
                                        $result = $this->getTracking($referenceId);
                                        
                                        if ($result['success']) {
                                            $data = $result['data']['DATA'];
                                            
                                            echo "\n🔵 Current Status: {$data['current_status']['status']}\n";
                                            echo "   Date: {$data['current_status']['date']}\n";
                                            
                                            echo "\n📋 Tracking History (" . count($data['tracking_details']) . " events):\n";
                                            echo str_repeat("-", 60) . "\n";
                                            
                                            foreach ($data['tracking_details'] as $event) {
                                                echo "  {$event['date']} | {$event['status']}\n";
                                            }
                                            
                                            echo str_repeat("=", 60) . "\n";
                                        } else {
                                            $message = $result['data']['Message'] ?? 'Tracking failed';
                                            echo "\n❌ {$message}\n";
                                        }
                                    }
                                }

                                // Usage
                                $tracker = new ClaimOrderTracker('YOUR_API_KEY');
                                $tracker->printTracking('CLM10001');

                                // Get raw data
                                $result = $tracker->getTracking('CLM10001');
                                if ($result['success']) {
                                    $currentStatus = $result['data']['DATA']['current_status']['status'];
                                    echo "Status: {$currentStatus}\n";
                                }
                                ?>

Claim Request API

Authentication

Request Body Parameters

Success Response

Error Responses

Bulk Claim Order Upload API

Authentication

Request Parameters

Excel File Structure

Processing Logic

Success Response

Error Responses

Best Practices

Download Excel Template API

Authentication

Request Parameters

Template Structure

Success Response

Error Responses

How to Use the Template

Best Practices

Order Tracking API

Authentication

Query Parameters

Tracking Workflows

Service Center Flow

Technician Flow

No Part Call Flow

Success Response

Error Responses

Best Practices