Introduction

This documentation aims to provide all the information you need to work with our API.

Base URL

https://api.dotcon.io

Authenticating requests

This API is authenticated by sending an Authorization header with the value "Bearer {YOUR_AUTH_KEY}".

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

Allegro orders management

Getting new orders

requires authentication

This method returns all Allegro new orders and "request_id". We recommend that you save "request_id" and send it back to us using the "confirm-orders” method. This will confirm that you have received the orders and you will not receive the same orders again.

Please note, that order_id field is unique in Allegro (for same merchant), if you get same order_id - this means there is no new order, but changes in same order.

In this link you can check example of a complete order: Link to example

Example request:

curl --request GET \
    --get "https://api.dotcon.io/api/v1/allegro-new-orders" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.dotcon.io/api/v1/allegro-new-orders"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.dotcon.io/api/v1/allegro-new-orders',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.dotcon.io/api/v1/allegro-new-orders'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200, success):


{
"request_id": 1234,
"orders": [
{
  "marketplace_id": "AB",
  "order_id": "12345678-a123-12ab-1234-123456789abc",
  "status": "new",
  "fba": 0,
  "shipment_carrier": "NULL",
  "tracking": "NULL",
   Other order information...
         {
             "sku": "12345",
             "ean": "ABCDEFGHI",
             "product_name": "ABCDEFGHI",
             "offer_id": 12345678,
             "offer_name": "Name",
             "quantity": "1",
             "price_amount": "10",
              Other order item information...
         }
}
]
}

Example response (401, wrong token):


{
    "message": "Unauthenticated."
}

Example response (200, there are no new orders):


{
 []
}

Received response:

Request failed with error:

Getting not fulfilled orders

requires authentication

This method returns all not fulfilled orders.

Example request:

curl --request GET \
    --get "https://api.dotcon.io/api/v1/allegro-not-fulfilled-orders" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.dotcon.io/api/v1/allegro-not-fulfilled-orders"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.dotcon.io/api/v1/allegro-not-fulfilled-orders',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.dotcon.io/api/v1/allegro-not-fulfilled-orders'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200, success):


{
"orders": [
{
  "marketplace_id": "AB",
  "order_id": "12345678-a123-12ab-1234-123456789abc",
  "status": "new",
  "fba": 0,
  "shipment_carrier": "NULL",
  "tracking": "NULL",
   Other order information...
         {
             "sku": "12345",
             "ean": "ABCDEFGHI",
             "product_name": "ABCDEFGHI",
             "offer_id": 12345678,
             "offer_name": "Name",
             "quantity": "1",
             "price_amount": "10",
              Other order item information...
         }
}
]
}

Example response (401, wrong token):


{
    "message": "Unauthenticated."
}

Example response (200, there are no not fulfilled orders):


{
 []
}

Received response:

Request failed with error:

Getting order

requires authentication

This method returns the order by order_id.

Example request:

curl --request GET \
    --get "https://api.dotcon.io/api/v1/allegro-order/12345678-a123-12ab-1234-123456789abc" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.dotcon.io/api/v1/allegro-order/12345678-a123-12ab-1234-123456789abc"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.dotcon.io/api/v1/allegro-order/12345678-a123-12ab-1234-123456789abc',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.dotcon.io/api/v1/allegro-order/12345678-a123-12ab-1234-123456789abc'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200, success):


{
"orders": [
{
  "marketplace_id": "AB",
  "order_id": "12345678-a123-12ab-1234-123456789abc",
  "status": "new",
  "fba": 0,
  "shipment_carrier": "NULL",
  "tracking": "NULL",
   Other order information...
         {
             "sku": "12345",
             "ean": "ABCDEFGHI",
             "product_name": "ABCDEFGHI",
             "offer_id": 12345678,
             "offer_name": "Name",
             "quantity": "1",
             "price_amount": "10",
              Other order item information...
         }
}
]
}

Example response (401, wrong token):


{
    "message": "Unauthenticated."
}

Example response (200, is no order with provided order id):


{
 []
}

Example response (422, given data was invalid):


{
    "message": "The given data was invalid.",
    "errors": {
        "order_id": [
            "The order id format is invalid."
        ]
    }
}

Received response:

Request failed with error:

Confirmation of receiving new orders

requires authentication

This method confirms you received the orders. You need to send us the "request_id", which you received after using the method "allegro-new-orders". It will confirm you received the orders, and you will not receive the same orders again next time.

Example request:

curl --request PUT \
    "https://api.dotcon.io/api/v1/allegro-confirm-orders" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"request_id\": \"1234\"
}"

const url = new URL(
    "https://api.dotcon.io/api/v1/allegro-confirm-orders"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "request_id": "1234"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://api.dotcon.io/api/v1/allegro-confirm-orders',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'request_id' => '1234',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.dotcon.io/api/v1/allegro-confirm-orders'
payload = {
    "request_id": "1234"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200, success):


{
    "message": "Data was received successfully."
}

Example response (401, wrong token):


{
    "message": "Unauthenticated."
}

Example response (422, given data was invalid):


{
    "message": "The given data was invalid.",
    "errors": {
        "request_id": [
            "The request id must be between 1 and 10 digits."
        ]
    }
}

Example response (200, the selected request id already confirmed or does not exist):


{
 []
}

Example response (422, request_id was incorrect):


{
    "message": "The given data was invalid.",
    "errors": "Provided request_id was incorrect"
}

Received response:

Request failed with error:

Sending orders tracking information

requires authentication

By this method, you can fill in and share the order tracking information.

Example request:

curl --request PUT \
    "https://api.dotcon.io/api/v1/allegro-send-order-tracking" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"order_id\": \"12345678-a123-12ab-1234-123456789abc\",
    \"shipment_carrier\": \"Name\",
    \"tracking\": \"123456789\",
    \"shipping_from_warehouse\": \"ABC\"
}"

const url = new URL(
    "https://api.dotcon.io/api/v1/allegro-send-order-tracking"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "order_id": "12345678-a123-12ab-1234-123456789abc",
    "shipment_carrier": "Name",
    "tracking": "123456789",
    "shipping_from_warehouse": "ABC"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://api.dotcon.io/api/v1/allegro-send-order-tracking',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'order_id' => '12345678-a123-12ab-1234-123456789abc',
            'shipment_carrier' => 'Name',
            'tracking' => '123456789',
            'shipping_from_warehouse' => 'ABC',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.dotcon.io/api/v1/allegro-send-order-tracking'
payload = {
    "order_id": "12345678-a123-12ab-1234-123456789abc",
    "shipment_carrier": "Name",
    "tracking": "123456789",
    "shipping_from_warehouse": "ABC"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200, success):


{
    "message": "Tracking information received successfully."
}

Example response (401, wrong token):


{
    "message": "Unauthenticated."
}

Example response (422, given data was invalid):


{
    "message": "The given data was invalid.",
    "errors": {
        "order_id": [
            "The selected order id is invalid."
        ]
    }
}

Example response (422, already exist):


{
    "errors": "Tracking information already exist."
}

Example response (422, already exist):


{
    "errors": "Order already fulfilled."
}

Received response:

Request failed with error:

Getting orders by date

requires authentication

This method returns all Allegro orders for the selected year and month. It is not possible to receive information older than 2 years.

Example request:

curl --request GET \
    --get "https://api.dotcon.io/api/v1/allegro-orders/2022/1/7" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.dotcon.io/api/v1/allegro-orders/2022/1/7"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.dotcon.io/api/v1/allegro-orders/2022/1/7',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.dotcon.io/api/v1/allegro-orders/2022/1/7'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200, success):


{
"orders": [
{
  "marketplace_id": "AB",
  "order_id": "12345678-a123-12ab-1234-123456789abc",
  "status": "new",
  "fba": 0,
  "shipment_carrier": "NULL",
  "tracking": "NULL",
   Other order information...
         {
             "sku": "12345",
             "ean": "ABCDEFGHI",
             "product_name": "ABCDEFGHI",
             "offer_id": 12345678,
             "offer_name": "Name",
             "quantity": "1",
             "price_amount": "10",
              Other order item information...
         }
}
]
}

Example response (401, wrong token):


{
    "message": "Unauthenticated."
}

Example response (200, there are no orders for this date):


{
 []
}

Example response (422, given data was invalid):


{
    "message": "The given data was invalid.",
    "errors": {
        "year": [
            "The year must be 4 digits."
        ]
    }
}

Example response (422, given data was invalid):


{
    "message": "The given data was invalid.",
    "errors": {
        "month": [
            "The month must be number greater than 0 and less than 13."
        ]
    }
}

Example response (422, invalid day):


{
    "message": "The given data was invalid.",
    "errors": {
        "day": [
            "The day must be between 1 and 31."
        ]
    }
}

Received response:

Request failed with error:

Assortment/Stock management

Uploading files

requires authentication

When uploading a file, we recommend saving the "file-id". The "file-id" will be required using the method "file-status" to request the report of the upload status and errors. The value of the "name" should be "Stock" or "Product". The "content" must be an information from CSV file in a form of string. We recommend using "file_get_contents" or "fopen" functions in PHP and equivalents in other programming languages. Additionally, the "filename" parameter in the multipart request is recommended to preserve the original file name.

In this link, you can check how we recommend using this method in PHP programming language: Link to example

In this link, you can check the detailed file specification in Lithuanian language: Link to specification

In this link, you can check the detailed file specification in English language: Link to specification

Example request:

curl --request POST \
    "https://api.dotcon.io/api/v1/upload-feed" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: multipart/form-data" \
    --header "Accept: application/json" \
    --form "Stock=@/tmp/phpxhrW0w"

const url = new URL(
    "https://api.dotcon.io/api/v1/upload-feed"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "multipart/form-data",
    "Accept": "application/json",
};

const body = new FormData();
body.append('Stock', document.querySelector('input[name="Stock"]').files[0]);

fetch(url, {
    method: "POST",
    headers,
    body,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api.dotcon.io/api/v1/upload-feed',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'multipart/form-data',
            'Accept' => 'application/json',
        ],
        'multipart' => [
            [
                'name' => 'Stock',
                'contents' => fopen('/tmp/phpxhrW0w', 'r')
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.dotcon.io/api/v1/upload-feed'
files = {
  'Stock': open('/tmp/phpxhrW0w', 'rb')
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'multipart/form-data',
  'Accept': 'application/json'
}

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

Example response (200, success):


{
    "message": "File saved successfully.",
    "file_id": 123
}

Example response (401, wrong token):


{
    "message": "Unauthenticated."
}

Example response (422, wrong name):


{
    "message": "Incorrect file name."
}

Example response (422, empty file):


{
    "message": "File is empty."
}

Example response (422, empty file):


{
 "message": "The file does not have a field "field name"."
}

Example response (422, incorrect file format):


{
    "message": "Incorrect file format."
}

Received response:

Request failed with error:

Checking file status

requires authentication

We recommend checking the status of the file not often than hourly. The final status is "Done". Any other status indicates that the upload or processing is not yet completed. All processing status options and errors are in the "Example request" section on the right.

Example request:

curl --request GET \
    --get "https://api.dotcon.io/api/v1/file-status/123" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.dotcon.io/api/v1/file-status/123"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.dotcon.io/api/v1/file-status/123',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.dotcon.io/api/v1/file-status/123'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200, success):


{
    "file_type": "Products",
    "status": "File saved successfully",
    "created_at": "2022-01-13T12:35:23.000000Z",
    "updated_at": "2022-01-13T12:35:23.000000Z"
}

Example response (401, wrong token):


{
    "message": "Unauthenticated."
}

Example response (404, id does not exist):


{
    "message": "File with this id does not exist."
}

Received response:

Request failed with error:

Authentication management

This method returns authentication token. The token will expire after 60 minutes.

Before trying to login for the first time, you must change your password, you can do this by clicking this link:

Link to change password

Example request:

curl --request POST \
    "https://api.dotcon.io/api/v1/login" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"john_smith\",
    \"password\": \"SecretPwd123!@x\"
}"

const url = new URL(
    "https://api.dotcon.io/api/v1/login"
);

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

let body = {
    "name": "john_smith",
    "password": "SecretPwd123!@x"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api.dotcon.io/api/v1/login',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'john_smith',
            'password' => 'SecretPwd123!@x',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.dotcon.io/api/v1/login'
payload = {
    "name": "john_smith",
    "password": "SecretPwd123!@x"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (201, success):


{
    "user": "Name",
    "token": "264|C1HGT4kiOvEeGkUiqQBJfWXiNfmFLoiFgYmkNo7O"
}

Example response (422, name not found):


{
"message": "The given data was invalid."
"errors": {
 "name": [
     "The selected name is invalid."
  ]
}
}

Example response (422, name is missing):


{
"message": "The given data was invalid."
"errors": {
 "name": [
     "The name must be a string.",
     "A name is required"
  ]
}
}

Example response (401, wrong password):


{
    "message": "Bad credentials"
}

Received response:

Request failed with error:

Logout

requires authentication

Example request:

curl --request POST \
    "https://api.dotcon.io/api/v1/logout" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.dotcon.io/api/v1/logout"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api.dotcon.io/api/v1/logout',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.dotcon.io/api/v1/logout'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (201, success):


{
    "message": "logged out"
}

Example response (422, wrong token):


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

File upload management

Uploading VAT Invoice

requires authentication

Upload a VAT invoice file for a specific order.

Currently, only the "allegro" platform is supported. Each order can have only one VAT invoice. Only PDF files are accepted. The file cannot be empty. The order must exist in the system. If a VAT invoice for the order already exists, the upload will be rejected.

The key-value pairs of the first associative array should look like this:

'name' => 'order_id', (order_id is a string).

'contents' => '31e88c80-a380-11ef-aaa8-ad165b9e76d3', (unique id of order whose VAT Invoice file you will send).

The key-value pairs of the second associative array should look like this:

'name' => 'invoice_number', (invoice_number is a string).

'contents' => 'AB-AB-ABC-1234-1234567', (unique invoice number).

The key-value pairs of the third associative array should look like this:

'name' => 'vat_invoice', (vat_invoice is a string).

'contents' => fopen($pdfFilePath, 'r'), (content of VAT Invoice file in pdf format).

'filename' => basename($pdfFilePath), (provided name of the file).

In this link you can check how we recommend using this method in PHP programming language: Link to example

Example request:

curl --request POST \
    "https://api.dotcon.io/api/v1/allegro/upload-vat-invoice" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: multipart/form-data" \
    --header "Accept: application/json" \
    --form "order_id=31e88c80-a380-11ef-aaa8-ad165b9e76d3" \
    --form "invoice_number=AB-AB-ABC-1234-1234567" \
    --form "vat_invoice=@/tmp/php55Mws0"

const url = new URL(
    "https://api.dotcon.io/api/v1/allegro/upload-vat-invoice"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "multipart/form-data",
    "Accept": "application/json",
};

const body = new FormData();
body.append('order_id', '31e88c80-a380-11ef-aaa8-ad165b9e76d3');
body.append('invoice_number', 'AB-AB-ABC-1234-1234567');
body.append('vat_invoice', document.querySelector('input[name="vat_invoice"]').files[0]);

fetch(url, {
    method: "POST",
    headers,
    body,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api.dotcon.io/api/v1/allegro/upload-vat-invoice',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'multipart/form-data',
            'Accept' => 'application/json',
        ],
        'multipart' => [
            [
                'name' => 'order_id',
                'contents' => '31e88c80-a380-11ef-aaa8-ad165b9e76d3'
            ],
            [
                'name' => 'invoice_number',
                'contents' => 'AB-AB-ABC-1234-1234567'
            ],
            [
                'name' => 'vat_invoice',
                'contents' => fopen('/tmp/php55Mws0', 'r')
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.dotcon.io/api/v1/allegro/upload-vat-invoice'
files = {
  'vat_invoice': open('/tmp/php55Mws0', 'rb')
}
payload = {
    "order_id": "31e88c80-a380-11ef-aaa8-ad165b9e76d3",
    "invoice_number": "AB-AB-ABC-1234-1234567"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'multipart/form-data',
  'Accept': 'application/json'
}

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

Example response (200, success):


{
    "message": "File saved successfully."
}

Example response (401, unauthenticated):


{
    "message": "Unauthenticated."
}

Example response (422, unsupported platform):


{
    "message": "Unsupported platform: allegro"
}

Example response (422, missing order_id):


{
    "message": "Missing field: order_id"
}

Example response (422, order not found):


{
    "message": "Cannot upload VAT invoice: order id: 123-4567890-9876543 does not exist for platform allegro."
}

Example response (422, missing invoice_number):


{
    "message": "Missing field: invoice_number"
}

Example response (422, invalid invoice_number):


{
    "message": "Invalid invoice_number length"
}

Example response (422, missing file):


{
    "message": "Missing file in upload."
}

Example response (422, invalid file format):


{
    "message": "Incorrect file format (only PDF allowed)."
}

Example response (422, empty file):


{
    "message": "File is empty."
}

Example response (422, duplicate upload):


{
    "message": "VAT invoice for order 123-4567890-9876543 has already been uploaded."
}

Received response:

Request failed with error:

Request

POST api/v1/{platform}/upload-vat-invoice

URL Parameters

platform string

Currently, only the "allegro" platform is supported. Allowed values: "allegro".

Body Parameters

order_id string

The ID of the order.

invoice_number string

The VAT invoice number (5–40 characters).

vat_invoice file

vat_invoice.pdf

Orders management

Getting new orders

requires authentication

This method returns all new orders and "request_id". We recommend that you save "request_id" and send it back to us using the "confirm-orders” method. This will confirm that you have received the orders and you will not receive the same orders again.

Please note, that order_id field is unique in Amazon (for same merchant), if you get same order_id - this means there is no new order, but changes in same order. For example, if customer requested cancelation, then you will receive this order update along with all new orders, and "is_buyer_requested_cancelation" field will be set to "TRUE".

In this link you can check example of a complete order: Link to example

Example request:

curl --request GET \
    --get "https://api.dotcon.io/api/v1/new-orders" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.dotcon.io/api/v1/new-orders"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.dotcon.io/api/v1/new-orders',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.dotcon.io/api/v1/new-orders'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200, success):


{
"request_id": 1234,
"orders": [
{
  "marketplace_id": "AB",
  "order_id": "012-0123456-0123456",
  "status": "new",
  "fba": 0,
  "shipment_carrier": "NULL",
  "tracking": "NULL",
   Other order information...
         {
             "sku": "12345",
             "product_name": "ABCDEFGHI",
             "quantity_purchased": 1,
             "currency": "ABC",
             "item_price": "123.12"
              Other order item information...
         }
}
]
}

Example response (401, wrong token):


{
    "message": "Unauthenticated."
}

Example response (200, there are no new orders):


{
 []
}

Received response:

Request failed with error:

Getting order

requires authentication

This method returns the order by order_id.

Example request:

curl --request GET \
    --get "https://api.dotcon.io/api/v1/order/123-1234567-1234567" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.dotcon.io/api/v1/order/123-1234567-1234567"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.dotcon.io/api/v1/order/123-1234567-1234567',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.dotcon.io/api/v1/order/123-1234567-1234567'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200, success):


{
"orders": [
{
  "marketplace_id": "AB",
  "order_id": "012-0123456-0123456",
  "status": "new",
  "fba": 0,
  "shipment_carrier": "NULL",
  "tracking": "NULL",
   Other order information...
         {
             "order_item_id": "01234567890123",
             "sku": "12345",
             "product_name": "ABCDEFGHI",
             "quantity_purchased": 1,
             "currency": "ABC",
             "item_price": "123.12"
              Other order item information...
         }
}
]
}

Example response (401, wrong token):


{
    "message": "Unauthenticated."
}

Example response (200, is no order with provided order id):


{
 []
}

Example response (422, given data was invalid):


{
    "message": "The given data was invalid.",
    "errors": {
        "order_id": [
            "The order id format is invalid."
        ]
    }
}

Received response:

Request failed with error:

Confirmation of receiving new orders

requires authentication

This method confirms you received the orders. You need to send us the "request_id", which you received after using the method "new-orders". It will confirm you received the orders, and you will not receive the same orders again next time.

Example request:

curl --request PUT \
    "https://api.dotcon.io/api/v1/confirm-orders" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"request_id\": \"1234\"
}"

const url = new URL(
    "https://api.dotcon.io/api/v1/confirm-orders"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "request_id": "1234"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://api.dotcon.io/api/v1/confirm-orders',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'request_id' => '1234',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.dotcon.io/api/v1/confirm-orders'
payload = {
    "request_id": "1234"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200, success):


{
    "message": "Data was received successfully."
}

Example response (401, wrong token):


{
    "message": "Unauthenticated."
}

Example response (422, given data was invalid):


{
    "message": "The given data was invalid.",
    "errors": {
        "request_id": [
            "The request id must be between 1 and 10 digits."
        ]
    }
}

Example response (200, the selected request id already confirmed or does not exist):


{
 []
}

Example response (422, request_id was incorrect):


{
    "message": "The given data was invalid.",
    "errors": "Provided request_id was incorrect"
}

Received response:

Request failed with error:

Sending orders tracking information

requires authentication

By this method, you can fill in and share the order tracking information.

Example request:

curl --request PUT \
    "https://api.dotcon.io/api/v1/send-order-tracking" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"order_id\": \"123-1234567-1234567\",
    \"shipment_carrier\": \"Name\",
    \"tracking\": \"123456789\",
    \"shipping_from_warehouse\": \"ABC\"
}"

const url = new URL(
    "https://api.dotcon.io/api/v1/send-order-tracking"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "order_id": "123-1234567-1234567",
    "shipment_carrier": "Name",
    "tracking": "123456789",
    "shipping_from_warehouse": "ABC"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://api.dotcon.io/api/v1/send-order-tracking',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'order_id' => '123-1234567-1234567',
            'shipment_carrier' => 'Name',
            'tracking' => '123456789',
            'shipping_from_warehouse' => 'ABC',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.dotcon.io/api/v1/send-order-tracking'
payload = {
    "order_id": "123-1234567-1234567",
    "shipment_carrier": "Name",
    "tracking": "123456789",
    "shipping_from_warehouse": "ABC"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200, success):


{
    "message": "Tracking information received successfully."
}

Example response (401, wrong token):


{
    "message": "Unauthenticated."
}

Example response (422, given data was invalid):


{
    "message": "The given data was invalid.",
    "errors": {
        "order_id": [
            "The selected order id is invalid."
        ]
    }
}

Example response (422, already exist):


{
    "errors": "Tracking information already exist."
}

Example response (422, already exist):


{
    "errors": "Order already fulfilled."
}

Received response:

Request failed with error:

Getting not fulfilled orders

requires authentication

This method returns all not fulfilled orders.

Example request:

curl --request GET \
    --get "https://api.dotcon.io/api/v1/not-fulfilled-orders" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.dotcon.io/api/v1/not-fulfilled-orders"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.dotcon.io/api/v1/not-fulfilled-orders',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.dotcon.io/api/v1/not-fulfilled-orders'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200, success):


{
"orders": [
{
  "marketplace_id": "AB",
  "order_id": "012-0123456-0123456",
  "status": "new",
  "fba": 0,
  "shipment_carrier": "NULL",
  "tracking": "NULL",
   Other order information...
         {
             "order_item_id": "01234567890123",
             "sku": "12345",
             "product_name": "ABCDEFGHI",
             "quantity_purchased": 1,
             "currency": "ABC",
             "item_price": "123.12"
              Other order item information...
         }
}
]
}

Example response (401, wrong token):


{
    "message": "Unauthenticated."
}

Example response (200, there are no not fulfilled orders):


{
 []
}

Received response:

Request failed with error:

Getting orders by date

requires authentication

This method returns all orders for the selected year and month. It is not possible to receive information older than 2 years. According to Amazon's data retention policy, orders older than 30 days will not contain personally identifiable information.

Example request:

curl --request GET \
    --get "https://api.dotcon.io/api/v1/orders/2022/1/7" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.dotcon.io/api/v1/orders/2022/1/7"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.dotcon.io/api/v1/orders/2022/1/7',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.dotcon.io/api/v1/orders/2022/1/7'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200, success):


{
"orders": [
{
  "marketplace_id": "AB",
  "order_id": "012-0123456-0123456",
  "status": "new",
  "fba": 0,
  "shipment_carrier": "NULL",
  "tracking": "NULL",
   Other order information...
         {
             "order_item_id": "01234567890123",
             "sku": "12345",
             "product_name": "ABCDEFGHI",
             "quantity_purchased": 1,
             "currency": "ABC",
             "item_price": "123.12"
              Other order item information...
         }
}
]
}

Example response (401, wrong token):


{
    "message": "Unauthenticated."
}

Example response (200, there are no orders for this date):


{
 []
}

Example response (422, given data was invalid):


{
    "message": "The given data was invalid.",
    "errors": {
        "year": [
            "The year must be 4 digits."
        ]
    }
}

Example response (422, given data was invalid):


{
    "message": "The given data was invalid.",
    "errors": {
        "month": [
            "The month must be number greater than 0 and less than 13."
        ]
    }
}

Example response (422, invalid day):


{
    "message": "The given data was invalid.",
    "errors": {
        "day": [
            "The day must be between 1 and 31."
        ]
    }
}

Received response:

Request failed with error:

Reports management

Getting report

requires authentication

This method retrieves information of latest available report for the specified report type. Currently, the supported report type is FBA_MYI_UNSUPPRESSED_INVENTORY_DATA. The response includes report information in JSON format, including the report filename and its timestamp.

Example request:

curl --request GET \
    --get "https://api.dotcon.io/api/v1/report-request/FBA_MYI_UNSUPPRESSED_INVENTORY_DATA" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.dotcon.io/api/v1/report-request/FBA_MYI_UNSUPPRESSED_INVENTORY_DATA"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.dotcon.io/api/v1/report-request/FBA_MYI_UNSUPPRESSED_INVENTORY_DATA',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.dotcon.io/api/v1/report-request/FBA_MYI_UNSUPPRESSED_INVENTORY_DATA'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200, success):


{
[
  {
      "file_name": "2025-06-01-FBA_MYI_UNSUPPRESSED_INVENTORY_DATA_EU.txt",
      "timestamp": "2025-06-03 00:51:24",
      "content": report information in JSON format,
      "region": EU,
  }
]

Example response (401, wrong token):


{
    "message": "Unauthenticated."
}

Example response (200, is no report with provided report_type):


{
 []
}

Example response (422, given data was invalid):


{
    "message": "The given data was invalid.",
    "errors": {
        "report_type": [
            "The provided report type is invalid."
        ]
    }
}

Received response:

Request failed with error:

Getting Amazon dimensions

requires authentication

This method returns the dimensions of active Amazon products. The response includes the SKU and item dimensions such as weight, height, length, and width. All dimensions are returned in kilograms and meters.

Only active products are included in the report. If no active products are found, a corresponding error message will be returned. The information is returned in JSON format.

Example request:

curl --request GET \
    --get "https://api.dotcon.io/api/v1/amazon-dimensions-data" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.dotcon.io/api/v1/amazon-dimensions-data"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.dotcon.io/api/v1/amazon-dimensions-data',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.dotcon.io/api/v1/amazon-dimensions-data'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200, success):


{
    "count": 2,
    "data": [
        {
            "sku": "ABC123",
            "weight": 1.25,
            "height": 0.12,
            "length": 0.34,
            "width": 0.18
        },
        {
            "sku": "DEF456",
            "weight": 0.8,
            "height": 0.1,
            "length": 0.25,
            "width": 0.15
        }
    ]
}

Example response (401, wrong token):


{
    "message": "Unauthenticated."
}

Example response (404, no products found):


{
    "error": "No products found"
}

Example response (404, no active products found):


{
    "error": "No active products found"
}

Received response:

Request failed with error:

Shipments management

Sending shipments information

requires authentication

This method allows you to send shipment information for given orders.

Each order must contain at least one shipment. Currently supported platform: "allegro".

Please note:

If the order already has a shipment, it will be skipped.
If at least one shipment is saved successfully, response will reflect both saved and skipped orders.
If all shipments already exist, response will return only skipped orders.
Shipment weight must be provided in kilograms.
Shipment height, width, and length must be provided in centimeters.

Example request:

curl --request POST \
    "https://api.dotcon.io/api/v1/shipment-data" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"orders\": [
        \"alias\"
    ]
}"

const url = new URL(
    "https://api.dotcon.io/api/v1/shipment-data"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "orders": [
        "alias"
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api.dotcon.io/api/v1/shipment-data',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'orders' => [
                'alias',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.dotcon.io/api/v1/shipment-data'
payload = {
    "orders": [
        "alias"
    ]
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200, success - all saved):


{
    "message": "All shipments saved successfully."
}

Example response (200, success - some skipped):


{
    "message": "Some shipments were saved successfully, but some orders were skipped because shipments already exist.",
    "skipped_orders": [
        "d94aee70-7e52-11f0-afc4-5debbe59dc7d"
    ]
}

Example response (200, no shipments saved):


{
    "message": "No shipments were saved. Shipments already exist for all provided orders.",
    "skipped_orders": [
        "d94aee70-7e52-11f0-afc4-5debbe59dc7d"
    ]
}

Example response (422, invalid data):


{
    "message": "The given data was invalid.",
    "errors": {
        "orders.0.shipments.0.type": [
            "The selected type is invalid. Allowed values: PDF_A4, PDF_A6, ZPL."
        ],
        "orders.0.shipments.0.weight": [
            "Shipment weight is required."
        ],
        "orders.0.shipments.0.platform": [
            "Platform must be either \"allegro\"."
        ]
    }
}

Example response (401, wrong token):


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Request

POST api/v1/shipment-data

Body Parameters

orders string[]

List of orders with shipments.

orders[].order_id string

The ID of the order.

orders[].shipments string[]

List of shipments for the order.

orders[].shipments[].platform string

Shipment platform. Must be "allegro".

orders[].shipments[].weight numeric

Shipment weight (kg).

orders[].shipments[].height numeric

Shipment height (cm).

orders[].shipments[].width numeric

Shipment width (cm).

orders[].shipments[].length numeric

Shipment length (cm).

orders[].shipments[].type string

Shipment label type. One of: PDF_A4, PDF_A6, ZPL.

Getting shipment label

requires authentication

This method allows you to retrieve the shipment labels for a given order. Currently, only the "allegro" platform is supported.

Please note:

Label filenames correspond to the order ID. If an order has multiple shipment labels, each file will have a suffix "_1", "_2", etc.
Label files can be in PDF or ZPL format.
Each shipment will be paired with its corresponding label file(s).

Example request:

curl --request GET \
    --get "https://api.dotcon.io/api/v1/shipment-label/allegro/d94aee70-7e52-11f0-afc4-5debbe59dc7d" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.dotcon.io/api/v1/shipment-label/allegro/d94aee70-7e52-11f0-afc4-5debbe59dc7d"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.dotcon.io/api/v1/shipment-label/allegro/d94aee70-7e52-11f0-afc4-5debbe59dc7d',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.dotcon.io/api/v1/shipment-label/allegro/d94aee70-7e52-11f0-afc4-5debbe59dc7d'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200, success):


[
    {
        "carrier": "ALLEGRO",
        "tracking_number": "AD0000K0B6",
        "file": {
            "filename": "d94aee70-7e52-11f0-afc4-5debbe59dc7d_1.pdf",
            "content": "JVBERi0xLjQKJeLjz9MKM..."
        }
    },
    {
        "carrier": "ALLEGRO",
        "tracking_number": "AD0000K0A8",
        "file": {
            "filename": "d94aee70-7e52-11f0-afc4-5debbe59dc7d_2.zpl",
            "content": "XlhBDQpeQ0kyOA0KXkZP..."
        }
    }
]

Example response (404, platform not supported):


{
    "message": "Unknown platform: {platform}"
}

Example response (404, order not found):


{
    "error": "Order not found"
}

Example response (404, no shipments found):


{
    "error": "No shipments found for order"
}

Received response:

Request failed with error:

Confirm orders are ready for pickup

requires authentication

This method allows merchants to confirm that selected orders are ready for courier pickup.

Notes:

Only orders with shipments that have a status allowing pickup confirmation can be confirmed.
If a shipment is already marked as ready for pickup, it will be listed in already_confirmed_orders.
Orders that cannot be confirmed (e.g., shipment not yet ready) will be listed in cannot_confirm_orders.
Orders not found in the system will be listed in not_found_orders.
Pickup scheduling logic:
- When this request is received, the system will first try to schedule a courier for the next day between 12:00 and 17:00.
- If the next day is Friday or Saturday, the system will look for a courier on Monday instead.
- If no suitable pickup time is available for that day, the system will take the first available proposal on the following working day, with hours between 08:00 and 17:00.

Example request:

curl --request POST \
    "https://api.dotcon.io/api/v1/allegro/confirm-orders-ready-for-pickup" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"orders\": [
        \"d94aee70-7e52-11f0-afc4-5debbe59dc7d\",
        \"d94aee70-7e52-11f0-afc4-5debbe59dc7e\"
    ]
}"

const url = new URL(
    "https://api.dotcon.io/api/v1/allegro/confirm-orders-ready-for-pickup"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "orders": [
        "d94aee70-7e52-11f0-afc4-5debbe59dc7d",
        "d94aee70-7e52-11f0-afc4-5debbe59dc7e"
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api.dotcon.io/api/v1/allegro/confirm-orders-ready-for-pickup',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'orders' => [
                'd94aee70-7e52-11f0-afc4-5debbe59dc7d',
                'd94aee70-7e52-11f0-afc4-5debbe59dc7e',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.dotcon.io/api/v1/allegro/confirm-orders-ready-for-pickup'
payload = {
    "orders": [
        "d94aee70-7e52-11f0-afc4-5debbe59dc7d",
        "d94aee70-7e52-11f0-afc4-5debbe59dc7e"
    ]
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200, success):


{
    "message": "Pickup readiness confirmation processed.",
    "confirmed_orders": [
        "d94aee70-7e52-11f0-afc4-5debbe59dc7d"
    ],
    "already_confirmed_orders": [
        "d94aee70-7e52-11f0-afc4-5debbe59dc7e"
    ],
    "cannot_confirm_orders": [
        "d94aee70-7e52-11f0-afc4-5debbe59dc7f"
    ],
    "not_found_orders": [
        "d94aee70-7e52-11f0-afc4-5debbe59dc80"
    ]
}

Example response (422, missing or invalid orders array):


{
    "error": "orders array is required"
}

Example response (422, unknown platform):


{
    "error": "Unknown platform: xyz"
}

Example response (401, wrong token):


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Statistics management

Getting performances data

requires authentication

This method returns performance information for a specific date and optionally for the past N days. If no parameters are provided, the data for today will be returned.

The behavior depends on the query parameters provided:

If no parameters are provided, data for today will be returned.
If only days_back is provided, data for today and the previous N-1 days will be returned. Example: days_back=3 on 2025-10-23 returns data for 2025-10-21, 2025-10-22, and 2025-10-23.
If both date and days_back are provided, data will start from date - (days_back-1) up to date. Example: date=2025-10-23&days_back=3 returns data for 2025-10-21, 2025-10-22, and 2025-10-23.

Example request:

curl --request GET \
    --get "https://api.dotcon.io/api/v1/performances?date=2025-10-23&days_back=3" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.dotcon.io/api/v1/performances"
);

const params = {
    "date": "2025-10-23",
    "days_back": "3",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.dotcon.io/api/v1/performances',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'date'=> '2025-10-23',
            'days_back'=> '3',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.dotcon.io/api/v1/performances'
params = {
  'date': '2025-10-23',
  'days_back': '3',
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

Example response (200, success):


{
    "start_date": "2025-10-21",
    "end_date": "2025-10-23",
    "data": "[{\"2025-10-21\":{...}}, {\"2025-10-22\":{...}}, {\"2025-10-23\":{...}}]"
}

Example response (401, wrong token):


{
    "message": "Unauthenticated."
}

Example response (422, unknown parameter):


{
    "message": "The given data was invalid.",
    "errors": {
        "unknown_param": [
            "Unknown parameter: abc. Allowed parameters are 'date' and 'days_back'."
        ]
    }
}

Example response (422, invalid date format):


{
    "message": "The given data was invalid.",
    "errors": {
        "date": [
            "Invalid date format. Expected YYYY-MM-DD."
        ]
    }
}

Example response (422, invalid date value):


{
    "message": "The given data was invalid.",
    "errors": {
        "date": [
            "Invalid date. Day does not exist in this month."
        ]
    }
}

Example response (422, invalid days_back):


{
    "message": "The given data was invalid.",
    "errors": {
        "days_back": [
            "The days_back must be a numeric value greater than or equal to 0."
        ]
    }
}

Received response:

Request failed with error:

Test data management

Restore test orders

requires authentication

When testing orders, the status of the orders is changing. This method restores all test orders to the status "new". This method can be accessed only by "Test" user.

Example request:

curl --request PATCH \
    "https://api.dotcon.io/api/v1/restore-test-orders" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.dotcon.io/api/v1/restore-test-orders"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "PATCH",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'https://api.dotcon.io/api/v1/restore-test-orders',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.dotcon.io/api/v1/restore-test-orders'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200, orders restored successfully):


{
 []
}

Example response (422, incorrect user):


{
    "message": "Incorrect user."
}

Example response (401, wrong token):


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Restore VAT calculations data

requires authentication

When testing VAT calculations data, the status of the VAT calculations data is changing. This method restores all test VAT calculations data to the status "new". This method can be accessed only by "Test" user.

Example request:

curl --request PATCH \
    "https://api.dotcon.io/api/v1/restore-test-vat-calculations-data" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.dotcon.io/api/v1/restore-test-vat-calculations-data"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "PATCH",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'https://api.dotcon.io/api/v1/restore-test-vat-calculations-data',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.dotcon.io/api/v1/restore-test-vat-calculations-data'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200, VAT calculations data restored successfully):


{
 []
}

Example response (422, incorrect user):


{
    "message": "Incorrect user."
}

Example response (401, wrong token):


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Restore Allegro test orders

requires authentication

When testing orders, the status of the orders is changing. This method restores all test orders to the status "new". This method can be accessed only by "Test" user.

Example request:

curl --request PATCH \
    "https://api.dotcon.io/api/v1/allegro-restore-test-orders" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.dotcon.io/api/v1/allegro-restore-test-orders"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "PATCH",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'https://api.dotcon.io/api/v1/allegro-restore-test-orders',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.dotcon.io/api/v1/allegro-restore-test-orders'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200, orders restored successfully):


{
 []
}

Example response (422, incorrect user):


{
    "message": "Incorrect user."
}

Example response (401, wrong token):


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

VAT calculations data management

Getting new VAT calculations data

requires authentication

This method returns all new VAT calculations data and "request_id". We recommend saving "request_id" and sending it back to us using the method "confirm-vat-calculations-data”. It will confirm you received the VAT calculations data, and you will not receive the same VAT calculations data again next time.

The field "buyer_company_name" will be empty for new VAT calculation data. This field will be filed later and information will be available through the method "Getting VAT calculations data by date".

In this link you can check full example of VAT calculation data: Link to example

Example request:

curl --request GET \
    --get "https://api.dotcon.io/api/v1/new-vat-calculations-data" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.dotcon.io/api/v1/new-vat-calculations-data"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.dotcon.io/api/v1/new-vat-calculations-data',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.dotcon.io/api/v1/new-vat-calculations-data'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200, success):


{
"request_id": 1234,
"vat_calculations_data": [
{
  "marketplace_id": "AB",
  "status": "new",
  "vat_invoice_number": "ABC-DE-FGHI-0123456789-0123-01",
  "shipment_date": "1234-01-01 00:00:00",
  "order_date": "1234-01-01 00:00:00",
  "transaction_type": "NULL",
   Other VAT invoice information...
         {
             "shipment_id": "0123456789",
             "asin": "B012345678",
             "sku": "12345",
             "quantity": "1",
             "our_price_tax_inclusive_selling_price": "12,12",
             "our_price_tax_amount": "12,12",
              Other VAT invoice detail information...
         }
}
]
}

Example response (401, wrong token):


{
    "message": "Unauthenticated."
}

Example response (200, there are no new VAT calculations data):


{
 []
}

Received response:

Request failed with error:

Confirmation of receiving new VAT calculations data

requires authentication

This method confirms you received the VAT calculations data. You need to send us the "request_id", which you received after using the method "new-vat-calculations-data". It will confirm you received the data, and you will not receive the same VAT calculations data again next time.

Example request:

curl --request PUT \
    "https://api.dotcon.io/api/v1/confirm-vat-calculations-data" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"request_id\": \"1234\"
}"

const url = new URL(
    "https://api.dotcon.io/api/v1/confirm-vat-calculations-data"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "request_id": "1234"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://api.dotcon.io/api/v1/confirm-vat-calculations-data',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'request_id' => '1234',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.dotcon.io/api/v1/confirm-vat-calculations-data'
payload = {
    "request_id": "1234"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200, success):


{
    "message": "Data was received successfully."
}

Example response (401, wrong token):


{
    "message": "Unauthenticated."
}

Example response (422, given data was invalid):


{
    "message": "The given data was invalid.",
    "errors": {
        "request_id": [
            "The request id must be between 1 and 10 digits."
        ]
    }
}

Example response (200, the selected request id already confirmed or does not exist):


{
 []
}

Example response (422, request_id was incorrect):


{
    "message": "The given data was invalid.",
    "errors": "Provided request_id was incorrect"
}

Received response:

Request failed with error:

Getting VAT calculations data by date

requires authentication

This method returns all VAT calculations data for the selected year and month. It is not possible to receive information older than 2 years.

Example request:

curl --request GET \
    --get "https://api.dotcon.io/api/v1/vat-calculations-data/2022/1/7" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.dotcon.io/api/v1/vat-calculations-data/2022/1/7"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.dotcon.io/api/v1/vat-calculations-data/2022/1/7',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.dotcon.io/api/v1/vat-calculations-data/2022/1/7'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200, success):


{
"vat_calculations_data": [
{
  "marketplace_id": "AB",
  "status": "new",
  "vat_invoice_number": "ABC-DE-FGHI-0123456789-0123-01",
  "shipment_date": "1234-01-01 00:00:00",
  "order_date": "1234-01-01 00:00:00",
  "transaction_type": "NULL",
   Other VAT invoice information...
         {
             "shipment_id": "0123456789",
             "asin": "B012345678",
             "sku": "12345",
             "quantity": "1",
             "our_price_tax_inclusive_selling_price": "12,12",
             "our_price_tax_amount": "12,12",
              Other VAT invoice detail information...
         }
}
]
}

Example response (401, wrong token):


{
    "message": "Unauthenticated."
}

Example response (200, there are no VAT calculations data for this date):


{
 []
}

Example response (422, given data was invalid):


{
    "message": "The given data was invalid.",
    "errors": {
        "year": [
            "The year must be 4 digits."
        ]
    }
}

Example response (422, older than two years):


{
    "errors": "Records older than two years cannot be retrieved"
}

Example response (422, given data was invalid):


{
    "message": "The given data was invalid.",
    "errors": {
        "month": [
            "The month must be number greater than 0 and less than 13."
        ]
    }
}

Example response (422, invalid day):


{
    "message": "The given data was invalid.",
    "errors": {
        "day": [
            "The day must be between 1 and 31."
        ]
    }
}

Received response:

Request failed with error:

Request

GET api/v1/vat-calculations-data/{year}/{month}/{day?}

URL Parameters

year integer

Year is required and will return VAT calculations data for the selected year.

month integer

Month is required and will return VAT calculations data for the selected month.

day integer optional

optional Day is optional and will return VAT calculations for the selected day of the given month and year.

Introduction

Authenticating requests

Allegro orders management

Getting new orders

Request

Getting not fulfilled orders

Request

Getting order

Request

URL Parameters

Confirmation of receiving new orders

Request

Body Parameters

Sending orders tracking information

Request

Body Parameters

Getting orders by date

Request

URL Parameters

Assortment/Stock management

Uploading files

Request

Body Parameters

Checking file status

Request

URL Parameters

Authentication management

Login

Request

Body Parameters

Logout

Request

File upload management

Uploading VAT Invoice

Request

URL Parameters

Body Parameters

Orders management

Getting new orders

Request

Getting order

Request

URL Parameters

Confirmation of receiving new orders

Request

Body Parameters

Sending orders tracking information

Request

Body Parameters

Getting not fulfilled orders

Request

Getting orders by date

Request

URL Parameters

Reports management

Getting report

Request

URL Parameters

Getting Amazon dimensions

Request

Shipments management

Sending shipments information

Request

Body Parameters

Getting shipment label

Request

URL Parameters

Confirm orders are ready for pickup

Request

URL Parameters

Body Parameters

Statistics management

Getting performances data

Request

Query Parameters

Test data management

Restore test orders

Request

Restore VAT calculations data

Request