MENU navbar-image

Introduction

Base URL

https://api.clearit.com

Authenticating requests

Authenticate requests to this API's endpoints 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://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://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://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://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://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://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://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://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

(POST api/us/getEstimateCalculation)

This endpoint is for the getting estimate calulation

Example request:
curl --request POST \
    "https://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.53999999999999914734871708787977695465087890625,
    \"commodities_json_string\": \"[{}]\"
}"

const url = new URL(
    "https://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.53999999999999914734871708787977695465087890625,
    "commodities_json_string": "[{}]"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://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.53999999999999914734871708787977695465087890625,
            'commodities_json_string' => '[{}]',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.clearit.com/api/us/getEstimateCalculation'
payload = {
    "reference_id": "myCode",
    "shipping_method": 2,
    "shipping_from": "US",
    "bond_type": 3,
    "freight_charge": 33.53999999999999914734871708787977695465087890625,
    "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://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://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://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://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://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://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://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://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://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://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://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://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://api.clearit.com/api/us/attachTicketDocument" \
    --header "Token: string required" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"file\": \"suscipit\",
    \"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://api.clearit.com/api/us/attachTicketDocument"
);

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

let body = {
    "file": "suscipit",
    "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://api.clearit.com/api/us/attachTicketDocument',
    [
        'headers' => [
            'Token' => 'string required',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'file' => 'suscipit',
            '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://api.clearit.com/api/us/attachTicketDocument'
payload = {
    "file": "suscipit",
    "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

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://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://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://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://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://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://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://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://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://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://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://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://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

Verify Invoice

requires authentication

(POST api/us/verifyInvoice)

This endpoint is for the Verify Invoice

Example request:
curl --request POST \
    "https://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\": \"error\",
            \"trade_name\": \"officia\",
            \"user_first_name\": \"ex\",
            \"user_last_name\": \"sed\"
        }
    ]
}"

const url = new URL(
    "https://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": "error",
            "trade_name": "officia",
            "user_first_name": "ex",
            "user_last_name": "sed"
        }
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://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' => 'error',
                    'trade_name' => 'officia',
                    'user_first_name' => 'ex',
                    'user_last_name' => 'sed',
                ],
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.clearit.com/api/us/verifyInvoice'
payload = {
    "document_identifier": "F07FE9DF-CEBF-7051-F2E1-2CBQ23D5B9A0",
    "document_details": [
        {
            "company_name": "error",
            "trade_name": "officia",
            "user_first_name": "ex",
            "user_last_name": "sed"
        }
    ]
}
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://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\": \"labore\",
            \"trade_name\": \"animi\",
            \"user_first_name\": \"fuga\",
            \"user_last_name\": \"beatae\"
        }
    ]
}"

const url = new URL(
    "https://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": "labore",
            "trade_name": "animi",
            "user_first_name": "fuga",
            "user_last_name": "beatae"
        }
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://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' => 'labore',
                    'trade_name' => 'animi',
                    'user_first_name' => 'fuga',
                    'user_last_name' => 'beatae',
                ],
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.clearit.com/api/us/verifyArrivalNotice'
payload = {
    "document_identifier": "F07FE9DF-CEBF-7051-F2E1-2CBQ23D5B9A0",
    "document_details": [
        {
            "company_name": "labore",
            "trade_name": "animi",
            "user_first_name": "fuga",
            "user_last_name": "beatae"
        }
    ]
}
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://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\": \"dicta\",
            \"trade_name\": \"cum\",
            \"user_first_name\": \"a\",
            \"user_last_name\": \"et\"
        }
    ]
}"

const url = new URL(
    "https://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": "dicta",
            "trade_name": "cum",
            "user_first_name": "a",
            "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://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' => 'dicta',
                    'trade_name' => 'cum',
                    'user_first_name' => 'a',
                    'user_last_name' => 'et',
                ],
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.clearit.com/api/us/verifyBillOfLading'
payload = {
    "document_identifier": "F07FE9DF-CEBF-7051-F2E1-2CBQ23D5B9A0",
    "document_details": [
        {
            "company_name": "dicta",
            "trade_name": "cum",
            "user_first_name": "a",
            "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/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://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\": \"autem\",
            \"user_first_name\": \"repellendus\",
            \"user_last_name\": \"nihil\"
        }
    ]
}"

const url = new URL(
    "https://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": "autem",
            "user_first_name": "repellendus",
            "user_last_name": "nihil"
        }
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://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' => 'autem',
                    'user_first_name' => 'repellendus',
                    'user_last_name' => 'nihil',
                ],
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.clearit.com/api/us/verifyAirwayBill'
payload = {
    "document_identifier": "F07FE9DF-CEBF-7051-F2E1-2CBQ23D5B9A0",
    "document_details": [
        {
            "company_name": "rerum",
            "trade_name": "autem",
            "user_first_name": "repellendus",
            "user_last_name": "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/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://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\": \"molestiae\",
            \"trade_name\": \"numquam\",
            \"user_first_name\": \"quos\",
            \"user_last_name\": \"ab\"
        }
    ]
}"

const url = new URL(
    "https://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": "molestiae",
            "trade_name": "numquam",
            "user_first_name": "quos",
            "user_last_name": "ab"
        }
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://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' => 'molestiae',
                    'trade_name' => 'numquam',
                    'user_first_name' => 'quos',
                    'user_last_name' => 'ab',
                ],
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.clearit.com/api/us/verifyISFWorksheet'
payload = {
    "document_identifier": "F07FE9DF-CEBF-7051-F2E1-2CBQ23D5B9A0",
    "document_details": [
        {
            "company_name": "molestiae",
            "trade_name": "numquam",
            "user_first_name": "quos",
            "user_last_name": "ab"
        }
    ]
}
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://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://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://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://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 Code

requires authentication

(POST api/us/predictCode)

This endpoint is for predicting HTS code based on clarifying answers

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

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

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

let body = {
    "clarifying_answers": "{}"
};

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

url = 'https://api.clearit.com/api/us/predictCode'
payload = {
    "clarifying_answers": "{}"
}
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/predictCode

Body Parameters

clarifying_answers  json  

JSON data containing description and clarifying answers