MENU navbar-image

Laravel Documentation

Introduction

Base URL

https://dev.api.clearit.com

Authenticating requests

This API is authenticated by sending a Token header with the value "your token".

All authenticated endpoints are marked with a requires authentication badge in the documentation below.

You can retrieve your token by visiting your dashboard and clicking Generate API token.

Endpoints

Get Token

(POST api/us/getToken)

This endpoint is for the getting token

Example request:
curl --request POST \
    "https://dev.api.clearit.com/api/us/getToken" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "Token: string required" \
    --data "{
    \"affiliateCode\": \"myCode\",
    \"password\": \"myCode@123\"
}"

const url = new URL(
    "https://dev.api.clearit.com/api/us/getToken"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
    "Token": "string required",
};

let body = {
    "affiliateCode": "myCode",
    "password": "myCode@123"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://dev.api.clearit.com/api/us/getToken',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Token' => 'string required',
        ],
        'json' => [
            'affiliateCode' => 'myCode',
            'password' => 'myCode@123',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://dev.api.clearit.com/api/us/getToken'
payload = {
    "affiliateCode": "myCode",
    "password": "myCode@123"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Token': 'string required'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Request      

POST api/us/getToken

Body Parameters

affiliateCode  string  

password  string  

Get Estimate

requires authentication

(POST api/us/getEstimate)

This endpoint is for the getting estimate

Example request:
curl --request POST \
    "https://dev.api.clearit.com/api/us/getEstimate" \
    --header "Token: string required" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"estimateGuid\": \"4EA36764-DC3F-9BE5-7279-677CB94674BF\"
}"

const url = new URL(
    "https://dev.api.clearit.com/api/us/getEstimate"
);

const headers = {
    "Token": "string required",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "estimateGuid": "4EA36764-DC3F-9BE5-7279-677CB94674BF"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://dev.api.clearit.com/api/us/getEstimate',
    [
        'headers' => [
            'Token' => 'string required',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'estimateGuid' => '4EA36764-DC3F-9BE5-7279-677CB94674BF',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://dev.api.clearit.com/api/us/getEstimate'
payload = {
    "estimateGuid": "4EA36764-DC3F-9BE5-7279-677CB94674BF"
}
headers = {
  'Token': 'string required',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Request      

POST api/us/getEstimate

Body Parameters

estimateGuid  string  

Get Estimate Calculation

requires authentication

This endpoint is for the getting estimate calulation

Example request:
curl --request POST \
    "https://dev.api.clearit.com/api/us/getEstimateCalculation" \
    --header "Token: string required" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"reference_id\": \"myCode\",
    \"shipping_method\": 2,
    \"shipping_from\": \"US\",
    \"bond_type\": 3,
    \"freight_charge\": 33.54,
    \"commodities_json_string\": \"[{}]\"
}"

const url = new URL(
    "https://dev.api.clearit.com/api/us/getEstimateCalculation"
);

const headers = {
    "Token": "string required",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "reference_id": "myCode",
    "shipping_method": 2,
    "shipping_from": "US",
    "bond_type": 3,
    "freight_charge": 33.54,
    "commodities_json_string": "[{}]"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://dev.api.clearit.com/api/us/getEstimateCalculation',
    [
        'headers' => [
            'Token' => 'string required',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'reference_id' => 'myCode',
            'shipping_method' => 2,
            'shipping_from' => 'US',
            'bond_type' => 3,
            'freight_charge' => 33.54,
            'commodities_json_string' => '[{}]',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://dev.api.clearit.com/api/us/getEstimateCalculation'
payload = {
    "reference_id": "myCode",
    "shipping_method": 2,
    "shipping_from": "US",
    "bond_type": 3,
    "freight_charge": 33.54,
    "commodities_json_string": "[{}]"
}
headers = {
  'Token': 'string required',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Request      

POST api/us/getEstimateCalculation

Body Parameters

reference_id  string optional  

User's reference identifier

shipping_method  integer  

Shipping Method:
1 - Truck
2 - Ocean
3 - Air

shipping_from  string  

2 character country code

bond_type  integer  

Bond Type:
1 - Single entry bond
2 - Annual bond requested
3 - User already has their own bond

freight_charge  number  

Total freight charge for entire shipment

commodities_json_string  json  

For the commodity json string data
product_description:- User's familiar name for the commodity / product
hts_code:- Full 12 character hts code in the format 9999.99.9999
unit_price:- Unit price of the commodity
total_units:- Total number of units being imported
duty_units:- Total kg, pieces, boxes, etc - sometimes required for calculating duty
country_manufacture:- 2 character country code representing where the commodity was manufactured

Create ticket

requires authentication

(POST api/us/createTicket)

This endpoint is for the create ticket

Example request:
curl --request POST \
    "https://dev.api.clearit.com/api/us/createTicket" \
    --header "Token: string required" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"transport\": 1,
    \"userIdentifier\": \"F07FE9DF-CEBF-7051-F2E1-2CBQ23D5B9A0\",
    \"soldToId\": 1,
    \"vendorId\": 1,
    \"carrier\": \"UPS\",
    \"trackingNumber\": \"123456\",
    \"requiresDelivery\": 1,
    \"deliverySelection\": 2,
    \"deliveryAddress\": \"123 Main St, City, State, Zip\",
    \"affiliateReference\": \"reference\"
}"

const url = new URL(
    "https://dev.api.clearit.com/api/us/createTicket"
);

const headers = {
    "Token": "string required",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "transport": 1,
    "userIdentifier": "F07FE9DF-CEBF-7051-F2E1-2CBQ23D5B9A0",
    "soldToId": 1,
    "vendorId": 1,
    "carrier": "UPS",
    "trackingNumber": "123456",
    "requiresDelivery": 1,
    "deliverySelection": 2,
    "deliveryAddress": "123 Main St, City, State, Zip",
    "affiliateReference": "reference"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://dev.api.clearit.com/api/us/createTicket',
    [
        'headers' => [
            'Token' => 'string required',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'transport' => 1,
            'userIdentifier' => 'F07FE9DF-CEBF-7051-F2E1-2CBQ23D5B9A0',
            'soldToId' => 1,
            'vendorId' => 1,
            'carrier' => 'UPS',
            'trackingNumber' => '123456',
            'requiresDelivery' => 1,
            'deliverySelection' => 2,
            'deliveryAddress' => '123 Main St, City, State, Zip',
            'affiliateReference' => 'reference',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://dev.api.clearit.com/api/us/createTicket'
payload = {
    "transport": 1,
    "userIdentifier": "F07FE9DF-CEBF-7051-F2E1-2CBQ23D5B9A0",
    "soldToId": 1,
    "vendorId": 1,
    "carrier": "UPS",
    "trackingNumber": "123456",
    "requiresDelivery": 1,
    "deliverySelection": 2,
    "deliveryAddress": "123 Main St, City, State, Zip",
    "affiliateReference": "reference"
}
headers = {
  'Token': 'string required',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Request      

POST api/us/createTicket

Body Parameters

transport  integer  

Mode of transport:
1 - Truck
2 - Ocean
3 - Air
4 - Courier.

userIdentifier  string  

Identifier of user

soldToId  integer optional  

Id of Sold To entity

vendorId  integer optional  

Id of Vendor entity

carrier  string optional  

Carrier

trackingNumber  string optional  

Carrier Reference / Tracking Number

requiresDelivery  integer optional  

Requires delivery:
1 - Yes
0 - No

deliverySelection  integer optional  

Delivery selection:
1 - Commercial
2 - Residential
3 - Amazon

deliveryAddress  string optional  

Delivery address

affiliateReference  string  

Affiliate reference

Cancel ticket

requires authentication

(POST api/us/cancelTicket)

This endpoint is for the cancel ticket

Example request:
curl --request POST \
    "https://dev.api.clearit.com/api/us/cancelTicket" \
    --header "Token: string required" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"TicketIdentifier\": \"B1B7577D-1989-3A47-2D55-4CE8738EF16E\",
    \"AffiliateReference\": \"123456\"
}"

const url = new URL(
    "https://dev.api.clearit.com/api/us/cancelTicket"
);

const headers = {
    "Token": "string required",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "TicketIdentifier": "B1B7577D-1989-3A47-2D55-4CE8738EF16E",
    "AffiliateReference": "123456"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://dev.api.clearit.com/api/us/cancelTicket',
    [
        'headers' => [
            'Token' => 'string required',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'TicketIdentifier' => 'B1B7577D-1989-3A47-2D55-4CE8738EF16E',
            'AffiliateReference' => '123456',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://dev.api.clearit.com/api/us/cancelTicket'
payload = {
    "TicketIdentifier": "B1B7577D-1989-3A47-2D55-4CE8738EF16E",
    "AffiliateReference": "123456"
}
headers = {
  'Token': 'string required',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Request      

POST api/us/cancelTicket

Body Parameters

TicketIdentifier  string  

Ticket Identifier

AffiliateReference  string  

Affiliate Reference

Get document upload types

requires authentication

(POST api/us/getDocumentUploadTypes)

This endpoint is for the getting document upload types

Example request:
curl --request POST \
    "https://dev.api.clearit.com/api/us/getDocumentUploadTypes" \
    --header "Token: string required" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"transport\": 3
}"

const url = new URL(
    "https://dev.api.clearit.com/api/us/getDocumentUploadTypes"
);

const headers = {
    "Token": "string required",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "transport": 3
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://dev.api.clearit.com/api/us/getDocumentUploadTypes',
    [
        'headers' => [
            'Token' => 'string required',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'transport' => 3,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://dev.api.clearit.com/api/us/getDocumentUploadTypes'
payload = {
    "transport": 3
}
headers = {
  'Token': 'string required',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Request      

POST api/us/getDocumentUploadTypes

Body Parameters

transport  integer  

Mode of transport:
1 - Truck
2 - Ocean
3 - Air
4 - Courier

Attach a document to a ticket

requires authentication

(POST api/us/attachTicketDocument)

This endpoint allows you to attach a document to a ticket. Ensure that the document format is supported and that the ticket ID provided is valid and exists in the database.

Example request:
curl --request POST \
    "https://dev.api.clearit.com/api/us/attachTicketDocument" \
    --header "Token: string required" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"affiliateCode\": \"eum\",
    \"affiliateId\": \"distinctio\",
    \"file\": \"earum\",
    \"file_name\": \"myFile.png\",
    \"ticketIdentifier\": \"B1B7577D-1989-3A47-2D55-4CE8738EF16E\",
    \"description\": \"Commercial Invoice\",
    \"documentDescription\": \"My ticket document\",
    \"invoiceNumber\": \"123456\",
    \"supplierName\": \"supplier\",
    \"affiliateReference\": \"reference\",
    \"affiliateIdentifier\": \"F07FE9DF-CEBF-7051-F2E1-2CBQ23D5B9A0\",
    \"documentStatus\": \"ADD\"
}"

const url = new URL(
    "https://dev.api.clearit.com/api/us/attachTicketDocument"
);

const headers = {
    "Token": "string required",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "affiliateCode": "eum",
    "affiliateId": "distinctio",
    "file": "earum",
    "file_name": "myFile.png",
    "ticketIdentifier": "B1B7577D-1989-3A47-2D55-4CE8738EF16E",
    "description": "Commercial Invoice",
    "documentDescription": "My ticket document",
    "invoiceNumber": "123456",
    "supplierName": "supplier",
    "affiliateReference": "reference",
    "affiliateIdentifier": "F07FE9DF-CEBF-7051-F2E1-2CBQ23D5B9A0",
    "documentStatus": "ADD"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://dev.api.clearit.com/api/us/attachTicketDocument',
    [
        'headers' => [
            'Token' => 'string required',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'affiliateCode' => 'eum',
            'affiliateId' => 'distinctio',
            'file' => 'earum',
            'file_name' => 'myFile.png',
            'ticketIdentifier' => 'B1B7577D-1989-3A47-2D55-4CE8738EF16E',
            'description' => 'Commercial Invoice',
            'documentDescription' => 'My ticket document',
            'invoiceNumber' => '123456',
            'supplierName' => 'supplier',
            'affiliateReference' => 'reference',
            'affiliateIdentifier' => 'F07FE9DF-CEBF-7051-F2E1-2CBQ23D5B9A0',
            'documentStatus' => 'ADD',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://dev.api.clearit.com/api/us/attachTicketDocument'
payload = {
    "affiliateCode": "eum",
    "affiliateId": "distinctio",
    "file": "earum",
    "file_name": "myFile.png",
    "ticketIdentifier": "B1B7577D-1989-3A47-2D55-4CE8738EF16E",
    "description": "Commercial Invoice",
    "documentDescription": "My ticket document",
    "invoiceNumber": "123456",
    "supplierName": "supplier",
    "affiliateReference": "reference",
    "affiliateIdentifier": "F07FE9DF-CEBF-7051-F2E1-2CBQ23D5B9A0",
    "documentStatus": "ADD"
}
headers = {
  'Token': 'string required',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Request      

POST api/us/attachTicketDocument

Body Parameters

ticketID  string optional  

userID  string optional  

affiliateCode  string optional  

affiliateId  string optional  

file  string  

base64 encoded content of the file

file_name  string  

file name

ticketIdentifier  string  

Ticket identifier

description  string optional  

Description

documentDescription  string optional  

Description of document

invoiceNumber  string optional  

Invoice #

supplierName  string optional  

Supplier Name

affiliateReference  string optional  

Affiliate reference

affiliateIdentifier  string optional  

Affiliate Identifier

documentStatus  string optional  

Document Status

Get tariff number

requires authentication

(POST api/us/getTariffNumber)

This endpoint is for the getting tariff number

Example request:
curl --request POST \
    "https://dev.api.clearit.com/api/us/getTariffNumber" \
    --header "Token: string required" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"tariffNumber\": \"9999.99.9999\"
}"

const url = new URL(
    "https://dev.api.clearit.com/api/us/getTariffNumber"
);

const headers = {
    "Token": "string required",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "tariffNumber": "9999.99.9999"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://dev.api.clearit.com/api/us/getTariffNumber',
    [
        'headers' => [
            'Token' => 'string required',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'tariffNumber' => '9999.99.9999',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://dev.api.clearit.com/api/us/getTariffNumber'
payload = {
    "tariffNumber": "9999.99.9999"
}
headers = {
  'Token': 'string required',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Request      

POST api/us/getTariffNumber

Body Parameters

tariffNumber  string  

Full 12 character hts code in the format 9999.99.9999

Search tariff number

requires authentication

(POST api/us/searchTariffNumber)

This endpoint is for the search tariff number

Example request:
curl --request POST \
    "https://dev.api.clearit.com/api/us/searchTariffNumber" \
    --header "Token: string required" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"searchString\": \"102.32\"
}"

const url = new URL(
    "https://dev.api.clearit.com/api/us/searchTariffNumber"
);

const headers = {
    "Token": "string required",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "searchString": "102.32"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://dev.api.clearit.com/api/us/searchTariffNumber',
    [
        'headers' => [
            'Token' => 'string required',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'searchString' => '102.32',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://dev.api.clearit.com/api/us/searchTariffNumber'
payload = {
    "searchString": "102.32"
}
headers = {
  'Token': 'string required',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Request      

POST api/us/searchTariffNumber

Body Parameters

searchString  string  

Search string

Create User

requires authentication

(POST api/us/createUser)

This endpoint is for the create user

Example request:
curl --request POST \
    "https://dev.api.clearit.com/api/us/createUser" \
    --header "Token: string required" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"email\": \"[email protected]\",
    \"accountType\": 1,
    \"businessStructureType\": 2,
    \"signingOfficerType\": 1,
    \"legalBusinessName\": \"\\\"ABC Company\\\"\",
    \"tradeName\": \"\\\"ABC\\\"\",
    \"importerNumber\": \"\\\"123456789\\\"\",
    \"streetAddress\": \"\\\"123 Main St\\\"\",
    \"city\": \"\\\"New York\\\"\",
    \"country\": \"\\\"USA\\\"\",
    \"stateIdentifier\": \"\\\"NY\\\"\",
    \"postalCode\": \"\\\"10001\\\"\",
    \"contactFirstName\": \"\\\"John\\\"\",
    \"contactLastName\": \"\\\"Doe\\\"\",
    \"phoneNumber\": 1234567890,
    \"faxNumber\": \"\\\"1234567890\\\"\",
    \"birthDate\": \"\\\"1990-01-01\\\"\",
    \"haveBond\": 1,
    \"bondReferenceNumber\": \"\\\"123456789\\\"\",
    \"bondExpirationYear\": \"\\\"2022\\\"\",
    \"bondExpirationMonth\": \"\\\"01\\\"\",
    \"bondExpirationDay\": \"\\\"01\\\"\",
    \"bondType\": 1,
    \"affiliateReference\": \"\\\"123456789\\\"\",
    \"affiliateShipmentNumber\": \"\\\"123456789\\\"\",
    \"createdByUserId\": 64784,
    \"jurisdictionState\": \"\\\"NY\\\"\",
    \"verificationUserId\": 64784,
    \"registrationIP\": \"67.249.78.206\"
}"

const url = new URL(
    "https://dev.api.clearit.com/api/us/createUser"
);

const headers = {
    "Token": "string required",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "email": "[email protected]",
    "accountType": 1,
    "businessStructureType": 2,
    "signingOfficerType": 1,
    "legalBusinessName": "\"ABC Company\"",
    "tradeName": "\"ABC\"",
    "importerNumber": "\"123456789\"",
    "streetAddress": "\"123 Main St\"",
    "city": "\"New York\"",
    "country": "\"USA\"",
    "stateIdentifier": "\"NY\"",
    "postalCode": "\"10001\"",
    "contactFirstName": "\"John\"",
    "contactLastName": "\"Doe\"",
    "phoneNumber": 1234567890,
    "faxNumber": "\"1234567890\"",
    "birthDate": "\"1990-01-01\"",
    "haveBond": 1,
    "bondReferenceNumber": "\"123456789\"",
    "bondExpirationYear": "\"2022\"",
    "bondExpirationMonth": "\"01\"",
    "bondExpirationDay": "\"01\"",
    "bondType": 1,
    "affiliateReference": "\"123456789\"",
    "affiliateShipmentNumber": "\"123456789\"",
    "createdByUserId": 64784,
    "jurisdictionState": "\"NY\"",
    "verificationUserId": 64784,
    "registrationIP": "67.249.78.206"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://dev.api.clearit.com/api/us/createUser',
    [
        'headers' => [
            'Token' => 'string required',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'email' => '[email protected]',
            'accountType' => 1,
            'businessStructureType' => 2,
            'signingOfficerType' => 1,
            'legalBusinessName' => '"ABC Company"',
            'tradeName' => '"ABC"',
            'importerNumber' => '"123456789"',
            'streetAddress' => '"123 Main St"',
            'city' => '"New York"',
            'country' => '"USA"',
            'stateIdentifier' => '"NY"',
            'postalCode' => '"10001"',
            'contactFirstName' => '"John"',
            'contactLastName' => '"Doe"',
            'phoneNumber' => 1234567890,
            'faxNumber' => '"1234567890"',
            'birthDate' => '"1990-01-01"',
            'haveBond' => 1,
            'bondReferenceNumber' => '"123456789"',
            'bondExpirationYear' => '"2022"',
            'bondExpirationMonth' => '"01"',
            'bondExpirationDay' => '"01"',
            'bondType' => 1,
            'affiliateReference' => '"123456789"',
            'affiliateShipmentNumber' => '"123456789"',
            'createdByUserId' => 64784,
            'jurisdictionState' => '"NY"',
            'verificationUserId' => 64784,
            'registrationIP' => '67.249.78.206',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://dev.api.clearit.com/api/us/createUser'
payload = {
    "email": "[email protected]",
    "accountType": 1,
    "businessStructureType": 2,
    "signingOfficerType": 1,
    "legalBusinessName": "\"ABC Company\"",
    "tradeName": "\"ABC\"",
    "importerNumber": "\"123456789\"",
    "streetAddress": "\"123 Main St\"",
    "city": "\"New York\"",
    "country": "\"USA\"",
    "stateIdentifier": "\"NY\"",
    "postalCode": "\"10001\"",
    "contactFirstName": "\"John\"",
    "contactLastName": "\"Doe\"",
    "phoneNumber": 1234567890,
    "faxNumber": "\"1234567890\"",
    "birthDate": "\"1990-01-01\"",
    "haveBond": 1,
    "bondReferenceNumber": "\"123456789\"",
    "bondExpirationYear": "\"2022\"",
    "bondExpirationMonth": "\"01\"",
    "bondExpirationDay": "\"01\"",
    "bondType": 1,
    "affiliateReference": "\"123456789\"",
    "affiliateShipmentNumber": "\"123456789\"",
    "createdByUserId": 64784,
    "jurisdictionState": "\"NY\"",
    "verificationUserId": 64784,
    "registrationIP": "67.249.78.206"
}
headers = {
  'Token': 'string required',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Request      

POST api/us/createUser

Body Parameters

email  string  

Must be a valid email address.

accountType  integer  

Account type:
1 - Presonal
2 - Business
3 - NRI

businessStructureType  integer optional  

Business Structure Type:
1 - Corporation
2 - Sole Proprietorship
3 - LLC
4 - Partnership

signingOfficerType  integer optional  

Signing officer type:
1 - Single signing officer
2 - Co-signing officer

legalBusinessName  string optional  

Legal business name

tradeName  string optional  

Trade name

importerNumber  string optional  

Tax Id or Social Security Number

streetAddress  string  

Street address

city  string  

City

country  string  

Country

stateIdentifier  string  

State identifier

postalCode  string  

Postal code

contactFirstName  string  

Contact first name

contactLastName  string  

Contact last name

phoneNumber  integer  

Phone number
10 numerical digits

faxNumber  string optional  

Fax number

birthDate  date  

Birth date:
YYYY-MM-DD

haveBond  integer  

Does the user have a bond
1 - Yes
0 - No

bondReferenceNumber  string optional  

Bond reference number

bondExpirationYear  string optional  

Expiration year

bondExpirationMonth  string optional  

Expiration month

bondExpirationDay  string optional  

Expiration day

bondType  integer optional  

Bond type:
1 - Single entry
2 - Annual

affiliateReference  string optional  

Affiliate reference

affiliateShipmentNumber  string optional  

Affiliate Shipment Number

createdByUserId  integer optional  

Created by user ID

jurisdictionState  string optional  

State where business is registered

verificationUserId  integer optional  

Verification user ID

registrationIP  string optional  

Server IP Address

POST api/us/getAffiliateUser

requires authentication

Example request:
curl --request POST \
    "https://dev.api.clearit.com/api/us/getAffiliateUser" \
    --header "Token: string required" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"affiliateUserIdentifier\": \"provident\",
    \"userEmail\": \"nihil\"
}"

const url = new URL(
    "https://dev.api.clearit.com/api/us/getAffiliateUser"
);

const headers = {
    "Token": "string required",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "affiliateUserIdentifier": "provident",
    "userEmail": "nihil"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://dev.api.clearit.com/api/us/getAffiliateUser',
    [
        'headers' => [
            'Token' => 'string required',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'affiliateUserIdentifier' => 'provident',
            'userEmail' => 'nihil',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://dev.api.clearit.com/api/us/getAffiliateUser'
payload = {
    "affiliateUserIdentifier": "provident",
    "userEmail": "nihil"
}
headers = {
  'Token': 'string required',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Request      

POST api/us/getAffiliateUser

Body Parameters

affiliateUserIdentifier  string  

userEmail  string  

POST api/us/updateUserAffiliateReference

requires authentication

Example request:
curl --request POST \
    "https://dev.api.clearit.com/api/us/updateUserAffiliateReference" \
    --header "Token: string required" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"token\": \"nam\",
    \"userIdentifier\": \"et\",
    \"affiliateReference\": \"perspiciatis\"
}"

const url = new URL(
    "https://dev.api.clearit.com/api/us/updateUserAffiliateReference"
);

const headers = {
    "Token": "string required",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "token": "nam",
    "userIdentifier": "et",
    "affiliateReference": "perspiciatis"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://dev.api.clearit.com/api/us/updateUserAffiliateReference',
    [
        'headers' => [
            'Token' => 'string required',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'token' => 'nam',
            'userIdentifier' => 'et',
            'affiliateReference' => 'perspiciatis',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://dev.api.clearit.com/api/us/updateUserAffiliateReference'
payload = {
    "token": "nam",
    "userIdentifier": "et",
    "affiliateReference": "perspiciatis"
}
headers = {
  'Token': 'string required',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Request      

POST api/us/updateUserAffiliateReference

Body Parameters

token  string  

userIdentifier  string  

affiliateReference  string  

POST api/us/createSoldTo

requires authentication

Example request:
curl --request POST \
    "https://dev.api.clearit.com/api/us/createSoldTo" \
    --header "Token: string required" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"userIdentifier\": \"molestiae\",
    \"firstname\": \"aut\",
    \"lastname\": \"beatae\",
    \"legalBusinessName\": \"sed\",
    \"streetAddress\": \"eos\",
    \"city\": \"iste\",
    \"country\": \"error\",
    \"stateIdentifier\": \"culpa\",
    \"postalCode\": \"eos\",
    \"phoneNumber\": \"velit\",
    \"faxNumber\": \"aut\",
    \"importerNumber\": \"iste\",
    \"email\": \"deleniti\"
}"

const url = new URL(
    "https://dev.api.clearit.com/api/us/createSoldTo"
);

const headers = {
    "Token": "string required",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "userIdentifier": "molestiae",
    "firstname": "aut",
    "lastname": "beatae",
    "legalBusinessName": "sed",
    "streetAddress": "eos",
    "city": "iste",
    "country": "error",
    "stateIdentifier": "culpa",
    "postalCode": "eos",
    "phoneNumber": "velit",
    "faxNumber": "aut",
    "importerNumber": "iste",
    "email": "deleniti"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://dev.api.clearit.com/api/us/createSoldTo',
    [
        'headers' => [
            'Token' => 'string required',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'userIdentifier' => 'molestiae',
            'firstname' => 'aut',
            'lastname' => 'beatae',
            'legalBusinessName' => 'sed',
            'streetAddress' => 'eos',
            'city' => 'iste',
            'country' => 'error',
            'stateIdentifier' => 'culpa',
            'postalCode' => 'eos',
            'phoneNumber' => 'velit',
            'faxNumber' => 'aut',
            'importerNumber' => 'iste',
            'email' => 'deleniti',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://dev.api.clearit.com/api/us/createSoldTo'
payload = {
    "userIdentifier": "molestiae",
    "firstname": "aut",
    "lastname": "beatae",
    "legalBusinessName": "sed",
    "streetAddress": "eos",
    "city": "iste",
    "country": "error",
    "stateIdentifier": "culpa",
    "postalCode": "eos",
    "phoneNumber": "velit",
    "faxNumber": "aut",
    "importerNumber": "iste",
    "email": "deleniti"
}
headers = {
  'Token': 'string required',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Request      

POST api/us/createSoldTo

Body Parameters

userIdentifier  string  

firstname  string  

lastname  string  

legalBusinessName  string optional  

streetAddress  string  

city  string  

country  string  

stateIdentifier  string  

postalCode  string  

phoneNumber  string  

faxNumber  string optional  

importerNumber  string optional  

email  string optional  

POST api/us/createVendor

requires authentication

Example request:
curl --request POST \
    "https://dev.api.clearit.com/api/us/createVendor" \
    --header "Token: string required" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"userIdentifier\": \"ea\",
    \"name\": \"soluta\",
    \"address\": \"est\",
    \"city\": \"ut\",
    \"stateIdentifier\": \"est\",
    \"country\": \"ad\",
    \"postalCode\": \"repudiandae\",
    \"phoneNumber\": \"et\",
    \"email\": \"velit\"
}"

const url = new URL(
    "https://dev.api.clearit.com/api/us/createVendor"
);

const headers = {
    "Token": "string required",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "userIdentifier": "ea",
    "name": "soluta",
    "address": "est",
    "city": "ut",
    "stateIdentifier": "est",
    "country": "ad",
    "postalCode": "repudiandae",
    "phoneNumber": "et",
    "email": "velit"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://dev.api.clearit.com/api/us/createVendor',
    [
        'headers' => [
            'Token' => 'string required',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'userIdentifier' => 'ea',
            'name' => 'soluta',
            'address' => 'est',
            'city' => 'ut',
            'stateIdentifier' => 'est',
            'country' => 'ad',
            'postalCode' => 'repudiandae',
            'phoneNumber' => 'et',
            'email' => 'velit',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://dev.api.clearit.com/api/us/createVendor'
payload = {
    "userIdentifier": "ea",
    "name": "soluta",
    "address": "est",
    "city": "ut",
    "stateIdentifier": "est",
    "country": "ad",
    "postalCode": "repudiandae",
    "phoneNumber": "et",
    "email": "velit"
}
headers = {
  'Token': 'string required',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Request      

POST api/us/createVendor

Body Parameters

userIdentifier  string  

name  string  

address  string  

city  string  

stateIdentifier  string  

country  string  

postalCode  string optional  

carrierRef  string optional  

phoneNumber  string  

fax  string optional  

email  string optional  

contactName  string optional  

POST api/us/saveTicketUserHTSCode

requires authentication

Example request:
curl --request POST \
    "https://dev.api.clearit.com/api/us/saveTicketUserHTSCode" \
    --header "Token: string required" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"ticketId\": \"repudiandae\",
    \"tariffNum\": \"consequatur\",
    \"userHTSId\": \"officia\",
    \"ticketUserHtsId\": \"quas\",
    \"userId\": \"iusto\",
    \"userDescription\": \"nihil\",
    \"usageDescription\": \"necessitatibus\",
    \"sku\": \"quae\",
    \"quantity\": \"nulla\",
    \"unitPrice\": \"in\",
    \"countryId\": \"minus\",
    \"agentId\": \"rerum\",
    \"commodityID\": \"ut\",
    \"commodityURL\": \"quibusdam\",
    \"note\": \"aut\"
}"

const url = new URL(
    "https://dev.api.clearit.com/api/us/saveTicketUserHTSCode"
);

const headers = {
    "Token": "string required",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "ticketId": "repudiandae",
    "tariffNum": "consequatur",
    "userHTSId": "officia",
    "ticketUserHtsId": "quas",
    "userId": "iusto",
    "userDescription": "nihil",
    "usageDescription": "necessitatibus",
    "sku": "quae",
    "quantity": "nulla",
    "unitPrice": "in",
    "countryId": "minus",
    "agentId": "rerum",
    "commodityID": "ut",
    "commodityURL": "quibusdam",
    "note": "aut"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://dev.api.clearit.com/api/us/saveTicketUserHTSCode',
    [
        'headers' => [
            'Token' => 'string required',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'ticketId' => 'repudiandae',
            'tariffNum' => 'consequatur',
            'userHTSId' => 'officia',
            'ticketUserHtsId' => 'quas',
            'userId' => 'iusto',
            'userDescription' => 'nihil',
            'usageDescription' => 'necessitatibus',
            'sku' => 'quae',
            'quantity' => 'nulla',
            'unitPrice' => 'in',
            'countryId' => 'minus',
            'agentId' => 'rerum',
            'commodityID' => 'ut',
            'commodityURL' => 'quibusdam',
            'note' => 'aut',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://dev.api.clearit.com/api/us/saveTicketUserHTSCode'
payload = {
    "ticketId": "repudiandae",
    "tariffNum": "consequatur",
    "userHTSId": "officia",
    "ticketUserHtsId": "quas",
    "userId": "iusto",
    "userDescription": "nihil",
    "usageDescription": "necessitatibus",
    "sku": "quae",
    "quantity": "nulla",
    "unitPrice": "in",
    "countryId": "minus",
    "agentId": "rerum",
    "commodityID": "ut",
    "commodityURL": "quibusdam",
    "note": "aut"
}
headers = {
  'Token': 'string required',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Request      

POST api/us/saveTicketUserHTSCode

Body Parameters

ticketId  string  

tariffNum  string optional  

userHTSId  string optional  

ticketUserHtsId  string optional  

userId  string optional  

userDescription  string optional  

usageDescription  string optional  

sku  string optional  

quantity  string optional  

unitPrice  string optional  

countryId  string optional  

agentId  string optional  

commodityID  string optional  

commodityURL  string optional  

note  string optional  

POST api/us/getTicketByAffiliateReference

requires authentication

Example request:
curl --request POST \
    "https://dev.api.clearit.com/api/us/getTicketByAffiliateReference" \
    --header "Token: string required" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"affiliateReference\": \"in\"
}"

const url = new URL(
    "https://dev.api.clearit.com/api/us/getTicketByAffiliateReference"
);

const headers = {
    "Token": "string required",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "affiliateReference": "in"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://dev.api.clearit.com/api/us/getTicketByAffiliateReference',
    [
        'headers' => [
            'Token' => 'string required',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'affiliateReference' => 'in',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://dev.api.clearit.com/api/us/getTicketByAffiliateReference'
payload = {
    "affiliateReference": "in"
}
headers = {
  'Token': 'string required',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Request      

POST api/us/getTicketByAffiliateReference

Body Parameters

affiliateReference  string  

POST api/us/attachmentsUserHTS

requires authentication

Example request:
curl --request POST \
    "https://dev.api.clearit.com/api/us/attachmentsUserHTS" \
    --header "Token: string required" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"userHtsId\": \"vitae\",
    \"userDescription\": \"aliquid\"
}"

const url = new URL(
    "https://dev.api.clearit.com/api/us/attachmentsUserHTS"
);

const headers = {
    "Token": "string required",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "userHtsId": "vitae",
    "userDescription": "aliquid"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://dev.api.clearit.com/api/us/attachmentsUserHTS',
    [
        'headers' => [
            'Token' => 'string required',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'userHtsId' => 'vitae',
            'userDescription' => 'aliquid',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://dev.api.clearit.com/api/us/attachmentsUserHTS'
payload = {
    "userHtsId": "vitae",
    "userDescription": "aliquid"
}
headers = {
  'Token': 'string required',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Request      

POST api/us/attachmentsUserHTS

Body Parameters

userHtsId  string  

userDescription  string  

file  string optional  

POST api/us/sendSkippedFileNotification

requires authentication

Example request:
curl --request POST \
    "https://dev.api.clearit.com/api/us/sendSkippedFileNotification" \
    --header "Token: string required" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"shipmentNumber\": \"temporibus\",
    \"documentType\": \"et\",
    \"documentName\": \"facere\",
    \"documentID\": \"blanditiis\",
    \"documentChecksum\": \"omnis\",
    \"foundDocumentChecksum\": \"praesentium\",
    \"serviceMethod\": \"asperiores\",
    \"file\": \"eum\",
    \"file_name\": \"myFile.png\",
    \"ticketIdentifier\": \"B1B7577D-1989-3A47-2D55-4CE8738EF16E\",
    \"description\": \"Commercial Invoice\",
    \"documentDescription\": \"My ticket document\",
    \"invoiceNumber\": \"123456\",
    \"supplierName\": \"supplier\",
    \"affiliateReference\": \"reference\",
    \"affiliateIdentifier\": \"F07FE9DF-CEBF-7051-F2E1-2CBQ23D5B9A0\",
    \"documentStatus\": \"ADD\"
}"

const url = new URL(
    "https://dev.api.clearit.com/api/us/sendSkippedFileNotification"
);

const headers = {
    "Token": "string required",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "shipmentNumber": "temporibus",
    "documentType": "et",
    "documentName": "facere",
    "documentID": "blanditiis",
    "documentChecksum": "omnis",
    "foundDocumentChecksum": "praesentium",
    "serviceMethod": "asperiores",
    "file": "eum",
    "file_name": "myFile.png",
    "ticketIdentifier": "B1B7577D-1989-3A47-2D55-4CE8738EF16E",
    "description": "Commercial Invoice",
    "documentDescription": "My ticket document",
    "invoiceNumber": "123456",
    "supplierName": "supplier",
    "affiliateReference": "reference",
    "affiliateIdentifier": "F07FE9DF-CEBF-7051-F2E1-2CBQ23D5B9A0",
    "documentStatus": "ADD"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://dev.api.clearit.com/api/us/sendSkippedFileNotification',
    [
        'headers' => [
            'Token' => 'string required',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'shipmentNumber' => 'temporibus',
            'documentType' => 'et',
            'documentName' => 'facere',
            'documentID' => 'blanditiis',
            'documentChecksum' => 'omnis',
            'foundDocumentChecksum' => 'praesentium',
            'serviceMethod' => 'asperiores',
            'file' => 'eum',
            'file_name' => 'myFile.png',
            'ticketIdentifier' => 'B1B7577D-1989-3A47-2D55-4CE8738EF16E',
            'description' => 'Commercial Invoice',
            'documentDescription' => 'My ticket document',
            'invoiceNumber' => '123456',
            'supplierName' => 'supplier',
            'affiliateReference' => 'reference',
            'affiliateIdentifier' => 'F07FE9DF-CEBF-7051-F2E1-2CBQ23D5B9A0',
            'documentStatus' => 'ADD',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://dev.api.clearit.com/api/us/sendSkippedFileNotification'
payload = {
    "shipmentNumber": "temporibus",
    "documentType": "et",
    "documentName": "facere",
    "documentID": "blanditiis",
    "documentChecksum": "omnis",
    "foundDocumentChecksum": "praesentium",
    "serviceMethod": "asperiores",
    "file": "eum",
    "file_name": "myFile.png",
    "ticketIdentifier": "B1B7577D-1989-3A47-2D55-4CE8738EF16E",
    "description": "Commercial Invoice",
    "documentDescription": "My ticket document",
    "invoiceNumber": "123456",
    "supplierName": "supplier",
    "affiliateReference": "reference",
    "affiliateIdentifier": "F07FE9DF-CEBF-7051-F2E1-2CBQ23D5B9A0",
    "documentStatus": "ADD"
}
headers = {
  'Token': 'string required',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Request      

POST api/us/sendSkippedFileNotification

Body Parameters

shipmentNumber  string  

documentType  string  

documentName  string  

documentID  string  

documentChecksum  string  

foundDocumentChecksum  string optional  

serviceMethod  string optional  

file  string  

base64 encoded content of the file

file_name  string  

file name

ticketIdentifier  string  

Ticket identifier

description  string optional  

Description

documentDescription  string optional  

Description of document

invoiceNumber  string optional  

Invoice #

supplierName  string optional  

Supplier Name

affiliateReference  string optional  

Affiliate reference

affiliateIdentifier  string optional  

Affiliate Identifier

documentStatus  string optional  

Document Status

Verify Invoice

requires authentication

(POST api/us/verifyInvoice)

This endpoint is for the Verify Invoice

Example request:
curl --request POST \
    "https://dev.api.clearit.com/api/us/verifyInvoice" \
    --header "Token: string required" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"document_identifier\": \"F07FE9DF-CEBF-7051-F2E1-2CBQ23D5B9A0\",
    \"document_details\": [
        {
            \"company_name\": \"delectus\",
            \"trade_name\": \"voluptas\",
            \"user_first_name\": \"maiores\",
            \"user_last_name\": \"dolore\"
        }
    ]
}"

const url = new URL(
    "https://dev.api.clearit.com/api/us/verifyInvoice"
);

const headers = {
    "Token": "string required",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "document_identifier": "F07FE9DF-CEBF-7051-F2E1-2CBQ23D5B9A0",
    "document_details": [
        {
            "company_name": "delectus",
            "trade_name": "voluptas",
            "user_first_name": "maiores",
            "user_last_name": "dolore"
        }
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://dev.api.clearit.com/api/us/verifyInvoice',
    [
        'headers' => [
            'Token' => 'string required',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'document_identifier' => 'F07FE9DF-CEBF-7051-F2E1-2CBQ23D5B9A0',
            'document_details' => [
                [
                    'company_name' => 'delectus',
                    'trade_name' => 'voluptas',
                    'user_first_name' => 'maiores',
                    'user_last_name' => 'dolore',
                ],
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://dev.api.clearit.com/api/us/verifyInvoice'
payload = {
    "document_identifier": "F07FE9DF-CEBF-7051-F2E1-2CBQ23D5B9A0",
    "document_details": [
        {
            "company_name": "delectus",
            "trade_name": "voluptas",
            "user_first_name": "maiores",
            "user_last_name": "dolore"
        }
    ]
}
headers = {
  'Token': 'string required',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Request      

POST api/us/verifyInvoice

Body Parameters

document_identifier  string  

Identifier of document

document_details  object[] optional  

document_details[].company_name  string optional  

document_details[].trade_name  string optional  

document_details[].user_first_name  string optional  

document_details[].user_last_name  string optional  

Verify Arrival Notice

requires authentication

(POST api/us/verifyArrivalNotice)

This endpoint is for the Verify Arrival Notice

Example request:
curl --request POST \
    "https://dev.api.clearit.com/api/us/verifyArrivalNotice" \
    --header "Token: string required" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"document_identifier\": \"F07FE9DF-CEBF-7051-F2E1-2CBQ23D5B9A0\",
    \"document_details\": [
        {
            \"company_name\": \"officiis\",
            \"trade_name\": \"aut\",
            \"user_first_name\": \"reiciendis\",
            \"user_last_name\": \"voluptas\"
        }
    ]
}"

const url = new URL(
    "https://dev.api.clearit.com/api/us/verifyArrivalNotice"
);

const headers = {
    "Token": "string required",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "document_identifier": "F07FE9DF-CEBF-7051-F2E1-2CBQ23D5B9A0",
    "document_details": [
        {
            "company_name": "officiis",
            "trade_name": "aut",
            "user_first_name": "reiciendis",
            "user_last_name": "voluptas"
        }
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://dev.api.clearit.com/api/us/verifyArrivalNotice',
    [
        'headers' => [
            'Token' => 'string required',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'document_identifier' => 'F07FE9DF-CEBF-7051-F2E1-2CBQ23D5B9A0',
            'document_details' => [
                [
                    'company_name' => 'officiis',
                    'trade_name' => 'aut',
                    'user_first_name' => 'reiciendis',
                    'user_last_name' => 'voluptas',
                ],
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://dev.api.clearit.com/api/us/verifyArrivalNotice'
payload = {
    "document_identifier": "F07FE9DF-CEBF-7051-F2E1-2CBQ23D5B9A0",
    "document_details": [
        {
            "company_name": "officiis",
            "trade_name": "aut",
            "user_first_name": "reiciendis",
            "user_last_name": "voluptas"
        }
    ]
}
headers = {
  'Token': 'string required',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Request      

POST api/us/verifyArrivalNotice

Body Parameters

document_identifier  string  

Identifier of document

document_details  object[] optional  

document_details[].company_name  string optional  

document_details[].trade_name  string optional  

document_details[].user_first_name  string optional  

document_details[].user_last_name  string optional  

Verify Bill of Lading

requires authentication

(POST api/us/verifyBillOfLading)

This endpoint is for the Verify Bill of Lading

Example request:
curl --request POST \
    "https://dev.api.clearit.com/api/us/verifyBillOfLading" \
    --header "Token: string required" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"document_identifier\": \"F07FE9DF-CEBF-7051-F2E1-2CBQ23D5B9A0\",
    \"document_details\": [
        {
            \"company_name\": \"delectus\",
            \"trade_name\": \"delectus\",
            \"user_first_name\": \"nihil\",
            \"user_last_name\": \"ullam\"
        }
    ]
}"

const url = new URL(
    "https://dev.api.clearit.com/api/us/verifyBillOfLading"
);

const headers = {
    "Token": "string required",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "document_identifier": "F07FE9DF-CEBF-7051-F2E1-2CBQ23D5B9A0",
    "document_details": [
        {
            "company_name": "delectus",
            "trade_name": "delectus",
            "user_first_name": "nihil",
            "user_last_name": "ullam"
        }
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://dev.api.clearit.com/api/us/verifyBillOfLading',
    [
        'headers' => [
            'Token' => 'string required',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'document_identifier' => 'F07FE9DF-CEBF-7051-F2E1-2CBQ23D5B9A0',
            'document_details' => [
                [
                    'company_name' => 'delectus',
                    'trade_name' => 'delectus',
                    'user_first_name' => 'nihil',
                    'user_last_name' => 'ullam',
                ],
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://dev.api.clearit.com/api/us/verifyBillOfLading'
payload = {
    "document_identifier": "F07FE9DF-CEBF-7051-F2E1-2CBQ23D5B9A0",
    "document_details": [
        {
            "company_name": "delectus",
            "trade_name": "delectus",
            "user_first_name": "nihil",
            "user_last_name": "ullam"
        }
    ]
}
headers = {
  'Token': 'string required',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Request      

POST api/us/verifyBillOfLading

Body Parameters

document_identifier  string  

Identifier of document

document_details  object[] optional  

document_details[].company_name  string optional  

document_details[].trade_name  string optional  

document_details[].user_first_name  string optional  

document_details[].user_last_name  string optional  

Verify Airway Bill

requires authentication

(POST api/us/verifyAirwayBill)

This endpoint is for the Verify Airway Bill

Example request:
curl --request POST \
    "https://dev.api.clearit.com/api/us/verifyAirwayBill" \
    --header "Token: string required" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"document_identifier\": \"F07FE9DF-CEBF-7051-F2E1-2CBQ23D5B9A0\",
    \"document_details\": [
        {
            \"company_name\": \"rerum\",
            \"trade_name\": \"non\",
            \"user_first_name\": \"libero\",
            \"user_last_name\": \"aperiam\"
        }
    ]
}"

const url = new URL(
    "https://dev.api.clearit.com/api/us/verifyAirwayBill"
);

const headers = {
    "Token": "string required",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "document_identifier": "F07FE9DF-CEBF-7051-F2E1-2CBQ23D5B9A0",
    "document_details": [
        {
            "company_name": "rerum",
            "trade_name": "non",
            "user_first_name": "libero",
            "user_last_name": "aperiam"
        }
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://dev.api.clearit.com/api/us/verifyAirwayBill',
    [
        'headers' => [
            'Token' => 'string required',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'document_identifier' => 'F07FE9DF-CEBF-7051-F2E1-2CBQ23D5B9A0',
            'document_details' => [
                [
                    'company_name' => 'rerum',
                    'trade_name' => 'non',
                    'user_first_name' => 'libero',
                    'user_last_name' => 'aperiam',
                ],
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://dev.api.clearit.com/api/us/verifyAirwayBill'
payload = {
    "document_identifier": "F07FE9DF-CEBF-7051-F2E1-2CBQ23D5B9A0",
    "document_details": [
        {
            "company_name": "rerum",
            "trade_name": "non",
            "user_first_name": "libero",
            "user_last_name": "aperiam"
        }
    ]
}
headers = {
  'Token': 'string required',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Request      

POST api/us/verifyAirwayBill

Body Parameters

document_identifier  string  

Identifier of document

document_details  object[] optional  

document_details[].company_name  string optional  

document_details[].trade_name  string optional  

document_details[].user_first_name  string optional  

document_details[].user_last_name  string optional  

Verify ISF Worksheet

requires authentication

(POST api/us/verifyISFWorksheet)

This endpoint is for the Verify ISF Worksheet

Example request:
curl --request POST \
    "https://dev.api.clearit.com/api/us/verifyISFWorksheet" \
    --header "Token: string required" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"document_identifier\": \"F07FE9DF-CEBF-7051-F2E1-2CBQ23D5B9A0\",
    \"document_details\": [
        {
            \"company_name\": \"beatae\",
            \"trade_name\": \"corrupti\",
            \"user_first_name\": \"qui\",
            \"user_last_name\": \"et\"
        }
    ]
}"

const url = new URL(
    "https://dev.api.clearit.com/api/us/verifyISFWorksheet"
);

const headers = {
    "Token": "string required",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "document_identifier": "F07FE9DF-CEBF-7051-F2E1-2CBQ23D5B9A0",
    "document_details": [
        {
            "company_name": "beatae",
            "trade_name": "corrupti",
            "user_first_name": "qui",
            "user_last_name": "et"
        }
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://dev.api.clearit.com/api/us/verifyISFWorksheet',
    [
        'headers' => [
            'Token' => 'string required',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'document_identifier' => 'F07FE9DF-CEBF-7051-F2E1-2CBQ23D5B9A0',
            'document_details' => [
                [
                    'company_name' => 'beatae',
                    'trade_name' => 'corrupti',
                    'user_first_name' => 'qui',
                    'user_last_name' => 'et',
                ],
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://dev.api.clearit.com/api/us/verifyISFWorksheet'
payload = {
    "document_identifier": "F07FE9DF-CEBF-7051-F2E1-2CBQ23D5B9A0",
    "document_details": [
        {
            "company_name": "beatae",
            "trade_name": "corrupti",
            "user_first_name": "qui",
            "user_last_name": "et"
        }
    ]
}
headers = {
  'Token': 'string required',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Request      

POST api/us/verifyISFWorksheet

Body Parameters

document_identifier  string  

Identifier of document

document_details  object[] optional  

document_details[].company_name  string optional  

document_details[].trade_name  string optional  

document_details[].user_first_name  string optional  

document_details[].user_last_name  string optional  

Clarifying Questions

requires authentication

(POST api/us/clarifyingQuestions)

This endpoint is for the clarifying questions

Example request:
curl --request POST \
    "https://dev.api.clearit.com/api/us/clarifyingQuestions" \
    --header "Token: string required" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"description\": \"Enter a detailed description of your product?\"
}"

const url = new URL(
    "https://dev.api.clearit.com/api/us/clarifyingQuestions"
);

const headers = {
    "Token": "string required",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "description": "Enter a detailed description of your product?"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://dev.api.clearit.com/api/us/clarifyingQuestions',
    [
        'headers' => [
            'Token' => 'string required',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'description' => 'Enter a detailed description of your product?',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://dev.api.clearit.com/api/us/clarifyingQuestions'
payload = {
    "description": "Enter a detailed description of your product?"
}
headers = {
  'Token': 'string required',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Request      

POST api/us/clarifyingQuestions

Body Parameters

description  string  

Description of the product

Predict Tariff

requires authentication

(POST api/us/predictTariff)

This endpoint is for the predict tariff

Example request:
curl --request POST \
    "https://dev.api.clearit.com/api/us/predictTariff" \
    --header "Token: string required" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"description\": \"Enter a detailed description of your product?\"
}"

const url = new URL(
    "https://dev.api.clearit.com/api/us/predictTariff"
);

const headers = {
    "Token": "string required",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "description": "Enter a detailed description of your product?"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://dev.api.clearit.com/api/us/predictTariff',
    [
        'headers' => [
            'Token' => 'string required',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'description' => 'Enter a detailed description of your product?',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://dev.api.clearit.com/api/us/predictTariff'
payload = {
    "description": "Enter a detailed description of your product?"
}
headers = {
  'Token': 'string required',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Request      

POST api/us/predictTariff

Body Parameters

description  string  

Description of the product

Get HTS Details

requires authentication

(POST api/us/getHTSDetails)

This endpoint is for the getting HTS details

Example request:
curl --request POST \
    "https://dev.api.clearit.com/api/us/htsDetails" \
    --header "Token: string required" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"hts_code\": \"quod\"
}"

const url = new URL(
    "https://dev.api.clearit.com/api/us/htsDetails"
);

const headers = {
    "Token": "string required",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "hts_code": "quod"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://dev.api.clearit.com/api/us/htsDetails',
    [
        'headers' => [
            'Token' => 'string required',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'hts_code' => 'quod',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://dev.api.clearit.com/api/us/htsDetails'
payload = {
    "hts_code": "quod"
}
headers = {
  'Token': 'string required',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Request      

POST api/us/htsDetails

Body Parameters

hts_code  string  

POST api/us/calculateTariff

requires authentication

Example request:
curl --request POST \
    "https://dev.api.clearit.com/api/us/calculateTariff" \
    --header "Token: string required" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"col1_spfc_rate\": 396440244.02,
    \"col1_rate_ad_vlrm\": 64018
}"

const url = new URL(
    "https://dev.api.clearit.com/api/us/calculateTariff"
);

const headers = {
    "Token": "string required",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "col1_spfc_rate": 396440244.02,
    "col1_rate_ad_vlrm": 64018
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://dev.api.clearit.com/api/us/calculateTariff',
    [
        'headers' => [
            'Token' => 'string required',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'col1_spfc_rate' => 396440244.02,
            'col1_rate_ad_vlrm' => 64018.0,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://dev.api.clearit.com/api/us/calculateTariff'
payload = {
    "col1_spfc_rate": 396440244.02,
    "col1_rate_ad_vlrm": 64018
}
headers = {
  'Token': 'string required',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Request      

POST api/us/calculateTariff

Body Parameters

col1_spfc_rate  number  

col1_rate_ad_vlrm  number  

Get Duty Simulation

requires authentication

(POST api/us/getDutySimulation)

This endpoint is for the getting duty simulation

Example request:
curl --request POST \
    "https://dev.api.clearit.com/api/us/getDutySimulation" \
    --header "Token: string required" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"estimate_id\": 0,
    \"partner_id\": 10,
    \"user_id\": 19,
    \"transport_type_id\": 15,
    \"bond_type_id\": 1,
    \"has_free_trade_agreement\": 0,
    \"hts_code\": \"aliquam\",
    \"product_description\": \"officiis\",
    \"total_units\": \"0.00\",
    \"unit_price\": \"0.00\",
    \"country_of_origin_id\": 12,
    \"duty_units\": \"0.00\",
    \"device_type\": \"repudiandae\",
    \"freight_charge\": 133162.902
}"

const url = new URL(
    "https://dev.api.clearit.com/api/us/getDutySimulation"
);

const headers = {
    "Token": "string required",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "estimate_id": 0,
    "partner_id": 10,
    "user_id": 19,
    "transport_type_id": 15,
    "bond_type_id": 1,
    "has_free_trade_agreement": 0,
    "hts_code": "aliquam",
    "product_description": "officiis",
    "total_units": "0.00",
    "unit_price": "0.00",
    "country_of_origin_id": 12,
    "duty_units": "0.00",
    "device_type": "repudiandae",
    "freight_charge": 133162.902
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://dev.api.clearit.com/api/us/getDutySimulation',
    [
        'headers' => [
            'Token' => 'string required',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'estimate_id' => 0,
            'partner_id' => 10,
            'user_id' => 19,
            'transport_type_id' => 15,
            'bond_type_id' => 1,
            'has_free_trade_agreement' => 0,
            'hts_code' => 'aliquam',
            'product_description' => 'officiis',
            'total_units' => '0.00',
            'unit_price' => '0.00',
            'country_of_origin_id' => 12,
            'duty_units' => '0.00',
            'device_type' => 'repudiandae',
            'freight_charge' => 133162.902,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://dev.api.clearit.com/api/us/getDutySimulation'
payload = {
    "estimate_id": 0,
    "partner_id": 10,
    "user_id": 19,
    "transport_type_id": 15,
    "bond_type_id": 1,
    "has_free_trade_agreement": 0,
    "hts_code": "aliquam",
    "product_description": "officiis",
    "total_units": "0.00",
    "unit_price": "0.00",
    "country_of_origin_id": 12,
    "duty_units": "0.00",
    "device_type": "repudiandae",
    "freight_charge": 133162.902
}
headers = {
  'Token': 'string required',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Request      

POST api/us/getDutySimulation

Body Parameters

estimate_id  integer  

Estimate ID

partner_id  integer  

Partner ID (If from Partner portal)

user_id  integer  

User ID (If from User portal or Agent backend)

transport_type_id  integer  

Transport Type:
1 - Truck
2 - Ocean
3 - Air

bond_type_id  integer  

Bond Type:
1 - Single entry bond
2 - Annual bond requested
3 - User already has their own bond

has_free_trade_agreement  integer  

Has Free Trade Agreement:
1 - Yes
0 - No

hts_code  string  

Hts Code: Full 12 character HTS code in the format 9999.99.9999

product_description  string  

Product Description

total_units  string  

Total number of units

unit_price  string  

Unit price

country_of_origin_id  integer  

Country of Origin: 2 character country code representing where the commodity was manufactured

duty_units  string  

Duty units

device_type  string  

Device Type: Desktop, Mobile, Tablet

freight_charge  number optional  

optional Shipment-level freight for landed cost / breakdown. For multi-commodity estimates, send on one request only (e.g. first line) to avoid double-counting.