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

Parameter	Type	Required	Description
repair_ref_no	string	Required	Unique repair reference number
client_name	string	Required	Partner / Client company name
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
centre_city	string	Required	Repair centre city
Issue	string	Required	Problem description
Size	string	Required	Device size / model number
AddressLine2	string	Optional	Secondary address line

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 Number format	Provide 10-digit mobile number
409	Conflict	Duplicate repair reference number	Use a unique repair_ref_no
500	Server Error	Internal server error	Retry request or contact support

Bulk Repair Order Upload API

Upload multiple repair orders at once using an Excel file. This API processes bulk repair requests efficiently, validates data, checks for duplicates, and returns detailed processing results.

POST https://api.bigfix.in/api/warrantify/repair/bulk-order/

Authentication

All API requests must include proper authentication headers.

Header	Type	Required	Description
X-API-Key	string	Required	Your API authentication key
Content-Type	multipart/form-data	Required	Required for file upload

Request Parameters

Submit the following form-data parameters along with your Excel file.

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 repair orders

Excel File Structure

Your Excel file must contain the following columns with proper headers:

Column Name	Required	Format	Example
repair_ref_no	Required	Unique text	REP10001
Name	Required	Text	Amit Patel
CustomerMobile	Required	10 digits	9876543210
CustomerEmail	Required	Valid email	amit@example.com
Engagement_Type	Required	Onsite/Offsite	Onsite
AddressLine1	Required	Text	Flat 301, Tower A
City	Required	Alphabets only	Bangalore
State	Required	Alphabets only	Karnataka
Pincode	Required	6 digits	560001
AssetType	Required	Text	Laptop
Make	Required	Text	Dell
Model	Required	Text	XPS 15
IMEINo	Required	Serial/IMEI number	SN123456789
Issue	Required	Text	Battery not charging

Processing Logic

The API performs the following operations:

Validation: Checks all required fields and formats
Duplicate Detection: Identifies orders with existing reference numbers
Order ID Generation: Creates unique repair order IDs for valid entries
Bulk Save: Stores all valid repair orders in the database
Notifications: Sends email notification to client with upload summary

Success Response

When the bulk upload is successfully processed, the API returns detailed results:

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 repair orders
Duplicate_Orders_Count	integer	Number of duplicate orders found
Duplicate_Reference_IDs	array	List of duplicate repair reference numbers

Error Responses

The API may return the following error codes:

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

Best Practices

Recommendations:

Validate data in your Excel file before uploading
Ensure all repair reference numbers are unique
Keep uploads under 1000 orders for optimal performance
Use the repair orders template for correct formatting
Store the response data for tracking duplicate entries
Specify accurate Engagement_Type (Onsite/Offsite) for proper service allocation

Important Notes:

Duplicate orders (based on repair_ref_no) will be skipped
Email notifications are sent after successful processing
Maximum file size: 10MB recommended
Supported format: Excel (.xlsx) only
Engagement_Type determines service workflow (Onsite vs Offsite)

Code Examples

Request Example

curl --location 'https://api.bigfix.in/api/warrantify/repair/bulk-order/' \
                                --header 'X-API-Key: YOUR_API_KEY' \
                                --form 'Client Email="support@servicecentre.com"' \
                                --form 'Client Name="Tech Service Centre"' \
                                --form 'customFile=@"/path/to/repair_orders.xlsx"'

Success Response (200)

{
                                "Success": "True",
                                "Status_code": 200,
                                "Message": "875 orders processed successfully",
                                "Uploaded_Orders_Count": 875,
                                "Duplicate_Orders_Count": 5,
                                "Duplicate_Reference_IDs": [
                                    "REP10156",
                                    "REP10287",
                                    "REP10423",
                                    "REP10654",
                                    "REP10789"
                                ]
                                }

Error Response (400)

{
                                "Success": "False",
                                "Status_code": 400,
                                "Message": "The number of orders cannot exceed 1000."
                                }

Request Example

const axios = require('axios');
                                const FormData = require('form-data');
                                const fs = require('fs');

                                const uploadBulkRepairs = async (filePath, clientEmail, clientName) => {
                                const form = new FormData();
                                form.append('Client Email', clientEmail);
                                form.append('Client Name', clientName);
                                form.append('customFile', fs.createReadStream(filePath));

                                try {
                                    const response = await axios.post(
                                    'https://api.bigfix.in/api/warrantify/repair/bulk-order/',
                                    form,
                                    {
                                        headers: {
                                        ...form.getHeaders(),
                                        'X-API-Key': 'YOUR_API_KEY'
                                        }
                                    }
                                    );

                                    console.log(`✅ ${response.data.Message}`);
                                    console.log(`📊 Uploaded: ${response.data.Uploaded_Orders_Count}`);
                                    console.log(`⚠️  Duplicates: ${response.data.Duplicate_Orders_Count}`);
                                    
                                    if (response.data.Duplicate_Reference_IDs.length > 0) {
                                    console.log('Duplicate IDs:', response.data.Duplicate_Reference_IDs);
                                    }

                                    return response.data;
                                } catch (error) {
                                    console.error('❌ Upload failed:', error.response?.data || error.message);
                                    throw error;
                                }
                                };

                                // Usage
                                uploadBulkRepairs(
                                '/path/to/repair_orders.xlsx',
                                'support@servicecentre.com',
                                'Tech Service Centre'
                                );

Request Example

import requests

                                url = "https://api.bigfix.in/api/warrantify/repair/bulk-order/"

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

                                files = {
                                    'customFile': open('/path/to/repair_orders.xlsx', 'rb')
                                }

                                data = {
                                    'Client Email': 'support@servicecentre.com',
                                    'Client Name': 'Tech Service Centre'
                                }

                                response = requests.post(
                                    url, 
                                    headers=headers, 
                                    files=files, 
                                    data=data
                                )

                                result = response.json()

                                if result['Success'] == 'True':
                                    print(f"✅ {result['Message']}")
                                    print(f"📊 Uploaded: {result['Uploaded_Orders_Count']}")
                                    print(f"⚠️  Duplicates: {result['Duplicate_Orders_Count']}")
                                    
                                    if result['Duplicate_Reference_IDs']:
                                        print("Duplicate IDs:")
                                        for ref_id in result['Duplicate_Reference_IDs']:
                                            print(f"  - {ref_id}")
                                else:
                                    print(f"❌ Error: {result['Message']}")

With Error Handling

import requests

                                def upload_bulk_repairs(file_path, client_email, client_name):
                                    """Upload bulk repair orders with comprehensive error handling"""
                                    
                                    url = "https://api.bigfix.in/api/warrantify/repair/bulk-order/"
                                    
                                    headers = {
                                        'X-API-Key': 'YOUR_API_KEY'
                                    }
                                    
                                    try:
                                        print(f"📤 Uploading repair orders from: {file_path}")
                                        
                                        with open(file_path, 'rb') as f:
                                            files = {'customFile': f}
                                            data = {
                                                'Client Email': client_email,
                                                'Client Name': client_name
                                            }
                                            
                                            response = requests.post(
                                                url, 
                                                headers=headers, 
                                                files=files, 
                                                data=data,
                                                timeout=60
                                            )
                                            
                                            result = response.json()
                                            
                                            if response.status_code == 200:
                                                print(f"\n✅ {result['Message']}")
                                                print(f"📊 Statistics:")
                                                print(f"   Uploaded: {result['Uploaded_Orders_Count']}")
                                                print(f"   Duplicates: {result['Duplicate_Orders_Count']}")
                                                
                                                if result['Duplicate_Orders_Count'] > 0:
                                                    print(f"\n⚠️  Duplicate Repair Reference IDs:")
                                                    for ref_id in result['Duplicate_Reference_IDs']:
                                                        print(f"   • {ref_id}")
                                                
                                                return {
                                                    'success': True,
                                                    'data': result
                                                }
                                            else:
                                                print(f"\n❌ Upload failed!")
                                                print(f"Error {result['Status_code']}: {result['Message']}")
                                                return {
                                                    'success': False,
                                                    'error': result['Message']
                                                }
                                                
                                    except FileNotFoundError:
                                        print(f"❌ File not found: {file_path}")
                                        return {'success': False, 'error': 'File not found'}
                                        
                                    except requests.exceptions.Timeout:
                                        print("❌ Request timed out")
                                        return {'success': False, 'error': 'Timeout'}
                                        
                                    except Exception as e:
                                        print(f"❌ Unexpected error: {str(e)}")
                                        return {'success': False, 'error': str(e)}

                                # Usage
                                result = upload_bulk_repairs(
                                    file_path='/path/to/repair_orders.xlsx',
                                    client_email='support@servicecentre.com',
                                    client_name='Tech Service Centre'
                                )

                                if result['success']:
                                    print(f"\n🎉 Upload completed successfully!")
                                else:
                                    print(f"\n💥 Upload failed: {result['error']}")

Request Example

 'support@servicecentre.com',
                                    'Client Name' => 'Tech Service Centre',
                                    'customFile' => $file
                                );

                                // Initialize cURL
                                $ch = curl_init($url);
                                curl_setopt($ch, CURLOPT_POST, true);
                                curl_setopt($ch, CURLOPT_POSTFIELDS, $data);
                                curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
                                curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

                                // Execute request
                                $response = curl_exec($ch);
                                $http_code = curl_getinfo($ch, CURLINFO_HTTP_CODE);
                                curl_close($ch);

                                // Parse response
                                $result = json_decode($response, true);

                                if ($http_code === 200 && $result['Success'] === 'True') {
                                    echo "✅ " . $result['Message'] . "\n";
                                    echo "📊 Uploaded Orders: " . $result['Uploaded_Orders_Count'] . "\n";
                                    echo "⚠️  Duplicate Orders: " . $result['Duplicate_Orders_Count'] . "\n";
                                    
                                    if (!empty($result['Duplicate_Reference_IDs'])) {
                                        echo "\nDuplicate Reference IDs:\n";
                                        foreach ($result['Duplicate_Reference_IDs'] as $ref_id) {
                                            echo "  - " . $ref_id . "\n";
                                        }
                                    }
                                } else {
                                    echo "❌ Error: " . ($result['Message'] ?? 'Unknown error') . "\n";
                                }
                                ?>

With Class Implementation

apiKey = $apiKey;
                                        $this->baseUrl = 'https://api.bigfix.in/api/warrantify/repair';
                                    }
                                    
                                    public function uploadBulkRepairs($filePath, $clientEmail, $clientName) {
                                        $url = $this->baseUrl . '/bulk-order/';
                                        
                                        if (!file_exists($filePath)) {
                                            return [
                                                'success' => false,
                                                'error' => 'File not found: ' . $filePath
                                            ];
                                        }
                                        
                                        $headers = array(
                                            'X-API-Key: ' . $this->apiKey
                                        );
                                        
                                        $file = new CURLFile($filePath);
                                        $data = array(
                                            'Client Email' => $clientEmail,
                                            'Client Name' => $clientName,
                                            'customFile' => $file
                                        );
                                        
                                        $ch = curl_init($url);
                                        curl_setopt($ch, CURLOPT_POST, true);
                                        curl_setopt($ch, CURLOPT_POSTFIELDS, $data);
                                        curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
                                        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
                                        curl_setopt($ch, CURLOPT_TIMEOUT, 60);
                                        
                                        $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 printUploadSummary($result) {
                                        if (!$result['success']) {
                                            echo "❌ Upload failed: " . $result['error'] . "\n";
                                            return;
                                        }
                                        
                                        $data = $result['data'];
                                        echo "✅ " . $data['Message'] . "\n";
                                        echo "📊 Statistics:\n";
                                        echo "   Uploaded: " . $data['Uploaded_Orders_Count'] . "\n";
                                        echo "   Duplicates: " . $data['Duplicate_Orders_Count'] . "\n";
                                        
                                        if (!empty($data['Duplicate_Reference_IDs'])) {
                                            echo "\n⚠️  Duplicate Reference IDs:\n";
                                            foreach ($data['Duplicate_Reference_IDs'] as $refId) {
                                                echo "   • " . $refId . "\n";
                                            }
                                        }
                                    }
                                }

                                // Usage
                                $uploader = new BulkRepairUploader('YOUR_API_KEY');

                                $result = $uploader->uploadBulkRepairs(
                                    '/path/to/repair_orders.xlsx',
                                    'support@servicecentre.com',
                                    'Tech Service Centre'
                                );

                                $uploader->printUploadSummary($result);
                                ?>

Column Name	Data Type	Format	Sample Value
repair_ref_no	string	Unique text	REP10001
Name	string	Text	Amit Patel
CustomerMobile	string	10 digits	9876543210
CustomerEmail	string	Valid email	amit@example.com
Engagement_Type	string	Onsite/Offsite	Onsite
AddressLine1	string	Text	Flat 301, Tower A
City	string	Alphabets only	Bangalore
State	string	Alphabets only	Karnataka
Pincode	string	6 digits	560001
AssetType	string	Text	Laptop
Make	string	Text	Dell
Model	string	Text	XPS 15
IMEINo	string	Serial/IMEI number	SN123456789
Issue	string	Text	Battery not charging

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

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

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";
                                }
                                ?>

Repair Request API

Authentication

Request Body Parameters

Success Response

Error Responses

Bulk Repair Order Upload API

Authentication

Request Parameters

Excel File Structure

Processing Logic

Success Response

Error Responses

Best Practices

Download Repair 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