KryptoShip Gateway API

import requests

BASE_URL = "https://app.kryptoship.com/gateway/v1"
API_KEY = "sk_live_your_api_key_here"
headers = {"Authorization": f"Bearer {API_KEY}"}

response = requests.get(
    f"{BASE_URL}/account/",
    headers=headers,
)
print(response.json())

const BASE_URL = "https://app.kryptoship.com/gateway/v1";
const API_KEY = "sk_live_your_api_key_here";

const response = await fetch(`${BASE_URL}/account/`, {
  headers: { "Authorization": `Bearer ${API_KEY}` },
});

const data = await response.json();
console.log(data);

<?php
$baseUrl = "https://app.kryptoship.com/gateway/v1";
$apiKey = "sk_live_your_api_key_here";

$ch = curl_init("$baseUrl/account/");
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer $apiKey",
]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

$response = curl_exec($ch);
echo $response;

require "net/http"
require "json"

BASE_URL = "https://app.kryptoship.com/gateway/v1"
API_KEY = "sk_live_your_api_key_here"

uri = URI("#{BASE_URL}/account/")
request = Net::HTTP::Get.new(uri)
request["Authorization"] = "Bearer #{API_KEY}"

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") do |http|
  http.request(request)
end

puts JSON.parse(response.body)

using System;                 // Console, DateTime, Math — implicit on net6+
using System.Net.Http;
using System.Text;             // Encoding (request bodies)
using System.Text.Json;        // JsonSerializer / JsonDocument
using System.Threading.Tasks;  // Task.Delay in the polling loops

var baseUrl = "https://app.kryptoship.com/gateway/v1";
var apiKey = "sk_live_your_api_key_here";

var client = new HttpClient();
client.DefaultRequestHeaders.Add(
    "Authorization", $"Bearer {apiKey}"
);

var response = await client.GetAsync($"{baseUrl}/account/");
var json = await response.Content.ReadAsStringAsync();
Console.WriteLine(json);

import requests

headers = {
    "Authorization": "Bearer sk_live_your_api_key_here",
    "Content-Type": "application/json",
}

response = requests.get(
    "https://app.kryptoship.com/gateway/v1/account/",
    headers=headers,
)
print(response.json())

const response = await fetch(
  "https://app.kryptoship.com/gateway/v1/account/",
  {
    headers: {
      "Authorization": "Bearer sk_live_your_api_key_here",
      "Content-Type": "application/json",
    },
  }
);

const data = await response.json();
console.log(data);

<?php
$ch = curl_init("https://app.kryptoship.com/gateway/v1/account/");
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer sk_live_your_api_key_here",
    "Content-Type: application/json",
]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

$response = json_decode(curl_exec($ch), true);
print_r($response);

require "net/http"
require "json"

uri = URI("https://app.kryptoship.com/gateway/v1/account/")
request = Net::HTTP::Get.new(uri)
request["Authorization"] = "Bearer sk_live_your_api_key_here"
request["Content-Type"] = "application/json"

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") do |http|
  http.request(request)
end

puts JSON.parse(response.body)

using System;                 // Console — implicit on net6+, explicit here
using System.Net.Http;

var client = new HttpClient();
client.DefaultRequestHeaders.Add(
    "Authorization", "Bearer sk_live_your_api_key_here"
);

var response = await client.GetAsync(
    "https://app.kryptoship.com/gateway/v1/account/"
);

var json = await response.Content.ReadAsStringAsync();
Console.WriteLine(json);

response = requests.get(
    f"{BASE_URL}/wallet/",
    headers=headers,
)
print(response.json())

const response = await fetch(`${BASE_URL}/wallet/`, {
  headers: { "Authorization": `Bearer ${API_KEY}` },
});

const data = await response.json();
console.log(data);

$ch = curl_init("$baseUrl/wallet/");
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer $apiKey",
]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

$response = json_decode(curl_exec($ch), true);
print_r($response);

uri = URI("#{BASE_URL}/wallet/")
request = Net::HTTP::Get.new(uri)
request["Authorization"] = "Bearer #{API_KEY}"

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") do |http|
  http.request(request)
end

puts JSON.parse(response.body)

var response = await client.GetAsync($"{baseUrl}/wallet/");
var json = await response.Content.ReadAsStringAsync();
Console.WriteLine(json);

response = requests.get(
    f"{BASE_URL}/account/",
    headers=headers,
)
account = response.json()["data"]
print(f"Balance: ${account['balance']}")
print(f"Orders today: {account['daily_orders_used']}")

const response = await fetch(`${BASE_URL}/account/`, {
  headers: { "Authorization": `Bearer ${API_KEY}` },
});

const { data } = await response.json();
console.log(`Balance: $${data.balance}`);
console.log(`Orders today: ${data.daily_orders_used}`);

$ch = curl_init("$baseUrl/account/");
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer $apiKey",
]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

$response = json_decode(curl_exec($ch), true);
$account = $response["data"];
echo "Balance: \${$account['balance']}\n";
echo "Orders today: {$account['daily_orders_used']}\n";

uri = URI("#{BASE_URL}/account/")
request = Net::HTTP::Get.new(uri)
request["Authorization"] = "Bearer #{API_KEY}"

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") do |http|
  http.request(request)
end

account = JSON.parse(response.body)["data"]
puts "Balance: $#{account['balance']}"
puts "Orders today: #{account['daily_orders_used']}"

var response = await client.GetAsync($"{baseUrl}/account/");
var json = await response.Content.ReadAsStringAsync();

using var doc = JsonDocument.Parse(json);
var data = doc.RootElement.GetProperty("data");
Console.WriteLine($"Balance: ${data.GetProperty("balance")}");
Console.WriteLine($"Orders today: {data.GetProperty("daily_orders_used")}");

import requests

response = requests.post(
    f"{BASE_URL}/orders/validate",
    headers=headers,
    json={
        "orders": [
            {
                "reference": "ORDER-001",
                "ship_from": {
                    "name": "John Smith",
                    "address1": "417 Montgomery St",
                    "city": "San Francisco",
                    "state": "CA",
                    "zip": "94104",
                },
                "ship_to": {
                    "name": "Jane Doe",
                    "address1": "1600 Amphitheatre Pkwy",
                    "address2": "Apt 2B",
                    "city": "Mountain View",
                    "state": "CA",
                    "zip": "94043",
                },
                "package": {
                    "weight_oz": 12,
                    "length_in": 10,
                    "width_in": 8,
                    "height_in": 4,
                },
                "service_type": "priority_mail",
            },
            {
                "reference": "ORDER-002",
                "ship_from": {
                    "name": "John Smith",
                    "address1": "417 Montgomery St",
                    "city": "San Francisco",
                    "state": "CA",
                    "zip": "94104",
                },
                "ship_to": {
                    "name": "Sam Lee",
                    "address1": "350 5th Ave",
                    "address2": "",
                    "city": "New York",
                    "state": "NY",
                    "zip": "10118",
                },
                "package": {
                    "weight_oz": 10,
                    "length_in": 9,
                    "width_in": 6,
                    "height_in": 3,
                },
                "service_type": "ground_advantage",
            }
        ]
    },
)

result = response.json()

# Check the status before unwrapping: validate has top-level 4xx paths
# (ORDERS_REQUIRED, VALIDATION_ERROR, BATCH_TOO_LARGE, 401, 413, 429) and
# on every one of them "data" is null.
if response.status_code != 200:
    raise SystemExit(
        f"validate failed: {response.status_code} "
        f"{result['error']['code']} — {result['message']}"
    )

batch_id = result["data"]["batch_id"]
print(f"Batch: {batch_id}")
print(f"Summary: {result['data']['summary']}")

const response = await fetch(
  `${BASE_URL}/orders/validate`,
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      orders: [
        {
          reference: "ORDER-001",
          ship_from: {
            name: "John Smith",
            address1: "417 Montgomery St",
            city: "San Francisco",
            state: "CA",
            zip: "94104",
          },
          ship_to: {
            name: "Jane Doe",
            address1: "1600 Amphitheatre Pkwy",
            address2: "Apt 2B",
            city: "Mountain View",
            state: "CA",
            zip: "94043",
          },
          package: {
            weight_oz: 12,
            length_in: 10,
            width_in: 8,
            height_in: 4,
          },
          service_type: "priority_mail",
        },
        {
          reference: "ORDER-002",
          ship_from: {
            name: "John Smith",
            address1: "417 Montgomery St",
            city: "San Francisco",
            state: "CA",
            zip: "94104",
          },
          ship_to: {
            name: "Sam Lee",
            address1: "350 5th Ave",
            address2: "",
            city: "New York",
            state: "NY",
            zip: "10118",
          },
          package: {
            weight_oz: 10,
            length_in: 9,
            width_in: 6,
            height_in: 3,
          },
          service_type: "ground_advantage",
        },
      ],
    }),
  }
);

const result = await response.json();

// Check the status before unwrapping: validate has top-level 4xx paths
// (ORDERS_REQUIRED, VALIDATION_ERROR, BATCH_TOO_LARGE, 401, 413, 429) and
// on every one of them "data" is null.
if (response.status !== 200) {
  throw new Error(
    `validate failed: ${response.status} ${result.error.code} — ${result.message}`
  );
}

console.log("Batch:", result.data.batch_id);
console.log("Summary:", result.data.summary);

$payload = json_encode([
    "orders" => [
        [
            "reference" => "ORDER-001",
            "ship_from" => [
                "name" => "John Smith",
                "address1" => "417 Montgomery St",
                "city" => "San Francisco",
                "state" => "CA",
                "zip" => "94104",
            ],
            "ship_to" => [
                "name" => "Jane Doe",
                "address1" => "1600 Amphitheatre Pkwy",
                "address2" => "Apt 2B",
                "city" => "Mountain View",
                "state" => "CA",
                "zip" => "94043",
            ],
            "package" => [
                "weight_oz" => 12,
                "length_in" => 10,
                "width_in" => 8,
                "height_in" => 4,
            ],
            "service_type" => "priority_mail",
        ],
        [
            "reference" => "ORDER-002",
            "ship_from" => [
                "name" => "John Smith",
                "address1" => "417 Montgomery St",
                "city" => "San Francisco",
                "state" => "CA",
                "zip" => "94104",
            ],
            "ship_to" => [
                "name" => "Sam Lee",
                "address1" => "350 5th Ave",
                "address2" => "",
                "city" => "New York",
                "state" => "NY",
                "zip" => "10118",
            ],
            "package" => [
                "weight_oz" => 10,
                "length_in" => 9,
                "width_in" => 6,
                "height_in" => 3,
            ],
            "service_type" => "ground_advantage",
        ],
    ],
]);

$ch = curl_init("$baseUrl/orders/validate");
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, $payload);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer $apiKey",
    "Content-Type: application/json",
]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

$result = json_decode(curl_exec($ch), true);
$code = curl_getinfo($ch, CURLINFO_HTTP_CODE);

// Check the status before unwrapping: validate has top-level 4xx paths
// (ORDERS_REQUIRED, VALIDATION_ERROR, BATCH_TOO_LARGE, 401, 413, 429) and
// on every one of them "data" is null.
if ($code !== 200) {
    fwrite(STDERR, "validate failed: $code " . $result["error"]["code"] . "\n");
    exit(1);
}

echo "Batch: {$result['data']['batch_id']}\n";

uri = URI("#{BASE_URL}/orders/validate")
request = Net::HTTP::Post.new(uri)
request["Authorization"] = "Bearer #{API_KEY}"
request["Content-Type"] = "application/json"
request.body = {
  orders: [
    {
      reference: "ORDER-001",
      ship_from: {
        name: "John Smith", address1: "417 Montgomery St",
        city: "San Francisco", state: "CA", zip: "94104"
      },
      ship_to: {
        name: "Jane Doe", address1: "1600 Amphitheatre Pkwy",
        address2: "Apt 2B",
        city: "Mountain View", state: "CA", zip: "94043"
      },
      package: {
        weight_oz: 12, length_in: 10,
        width_in: 8, height_in: 4
      },
      service_type: "priority_mail"
    },
    {
      reference: "ORDER-002",
      ship_from: {
        name: "John Smith", address1: "417 Montgomery St",
        city: "San Francisco", state: "CA", zip: "94104"
      },
      ship_to: {
        name: "Sam Lee", address1: "350 5th Ave",
        address2: "",
        city: "New York", state: "NY", zip: "10118"
      },
      package: {
        weight_oz: 10, length_in: 9,
        width_in: 6, height_in: 3
      },
      service_type: "ground_advantage"
    }
  ]
}.to_json

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") do |http|
  http.request(request)
end

result = JSON.parse(response.body)

# Check the status before unwrapping: validate has top-level 4xx paths
# (ORDERS_REQUIRED, VALIDATION_ERROR, BATCH_TOO_LARGE, 401, 413, 429) and
# on every one of them "data" is null.
unless response.code == "200"
  abort("validate failed: #{response.code} #{result['error']['code']}")
end

puts "Batch: #{result['data']['batch_id']}"

var payload = new
{
    orders = new[]
    {
        new
        {
            reference = "ORDER-001",
            ship_from = new
            {
                name = "John Smith",
                address1 = "417 Montgomery St",
                city = "San Francisco",
                state = "CA",
                zip = "94104"
            },
            ship_to = new
            {
                name = "Jane Doe",
                address1 = "1600 Amphitheatre Pkwy",
                address2 = "Apt 2B",
                city = "Mountain View",
                state = "CA",
                zip = "94043"
            },
            package = new
            {
                weight_oz = 12,
                length_in = 10,
                width_in = 8,
                height_in = 4
            },
            service_type = "priority_mail"
        },
        new
        {
            reference = "ORDER-002",
            ship_from = new
            {
                name = "John Smith",
                address1 = "417 Montgomery St",
                city = "San Francisco",
                state = "CA",
                zip = "94104"
            },
            ship_to = new
            {
                name = "Sam Lee",
                address1 = "350 5th Ave",
                address2 = "",
                city = "New York",
                state = "NY",
                zip = "10118"
            },
            package = new
            {
                weight_oz = 10,
                length_in = 9,
                width_in = 6,
                height_in = 3
            },
            service_type = "ground_advantage"
        }
    }
};

var content = new StringContent(
    JsonSerializer.Serialize(payload),
    Encoding.UTF8,
    "application/json"
);

var response = await client.PostAsync(
    $"{baseUrl}/orders/validate", content
);
var json = await response.Content.ReadAsStringAsync();
Console.WriteLine(json);

batch_id = "batch_6615a3f2e4b0c1d2e3f4a5b6"

response = requests.post(
    f"{BASE_URL}/orders/confirm/{batch_id}",
    headers=headers,
)
body = response.json()

# Check the status before unwrapping: on any error "data" is null.
if response.status_code == 200:
    data = body["data"]
    # A 200 does NOT guarantee an order: if every row failed validation,
    # order_id is null and labels_accepted is 0 (nothing was charged).
    # The envelope message says "Bulk order created" either way.
    if data["order_id"] is None:
        print("Confirm accepted zero labels — nothing created or charged")
    else:
        print(f"Bulk order {data['order_id']} created "
              f"({data['summary']['labels_accepted']} labels, ${data['summary']['total_price']})")
    # rejected[] is the only place the API names the dropped rows.
    for row in data["rejected"]:
        print(f"  rejected row {row['index']} "
              f"({row['reference']}): {row['error']}")
elif response.status_code == 409:
    # Already confirmed — your earlier call landed. Read the order id
    # off the batch; NEVER re-validate these rows (that double-charges).
    batch = requests.get(
        f"{BASE_URL}/batches/{batch_id}/", headers=headers,
    ).json()["data"]
    if batch is None:
        # 404: the batch was purged (24h after validation). The order,
        # if any, outlived it — reconcile by reference, never re-validate.
        raise SystemExit(
            "batch purged — reconcile with GET /orders/?reference=..."
        )
    # order_id is null in TWO states — only "status" separates them.
    if batch["order_id"]:
        print(f"Already confirmed as {batch['order_id']} — poll that order")
    elif batch["status"] == "completed":
        print("Confirm accepted zero labels — terminal, nothing was "
              "created or charged; fix the rows and validate a new batch")
    else:
        print("Confirm still in flight — keep polling this batch")
else:
    # 400 BATCH_EXPIRED, 422 INSUFFICIENT_BALANCE, 404 …
    print(f"{response.status_code} {body['error']['code']}: {body['message']}")

const batchId = "batch_6615a3f2e4b0c1d2e3f4a5b6";

const response = await fetch(
  `${BASE_URL}/orders/confirm/${batchId}`,
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${API_KEY}`,
      "Content-Type": "application/json",
    },
  }
);

const body = await response.json();

// Check the status before unwrapping: on any error "data" is null.
if (response.status === 200) {
  const { data } = body;
  // A 200 does NOT guarantee an order: if every row failed validation,
  // order_id is null and labels_accepted is 0 (nothing was charged).
  // The envelope message says "Bulk order created" either way.
  console.log(data.order_id === null
    ? "Confirm accepted zero labels — nothing created or charged"
    : `Bulk order ${data.order_id} created ` +
      `(${data.summary.labels_accepted} labels, $${data.summary.total_price})`);
  // rejected[] is the only place the API names the dropped rows.
  for (const row of data.rejected) {
    console.log(`  rejected row ${row.index} (${row.reference}): ${row.error}`);
  }
} else if (response.status === 409) {
  // Already confirmed — your earlier call landed. Read the order id
  // off the batch; NEVER re-validate these rows (that double-charges).
  const res = await fetch(`${BASE_URL}/batches/${batchId}/`,
    { headers: { "Authorization": `Bearer ${API_KEY}` } });
  const { data } = await res.json();
  if (data === null) {
    // 404: the batch was purged (24h after validation). The order,
    // if any, outlived it — reconcile by reference, never re-validate.
    throw new Error("batch purged — reconcile with GET /orders/?reference=...");
  }
  // order_id is null in TWO states — only "status" separates them.
  if (data.order_id) {
    console.log(`Already confirmed as ${data.order_id} — poll that order`);
  } else if (data.status === "completed") {
    console.log("Confirm accepted zero labels — terminal, nothing was created " +
      "or charged; fix the rows and validate a new batch");
  } else {
    console.log("Confirm still in flight — keep polling this batch");
  }
} else {
  // 400 BATCH_EXPIRED, 422 INSUFFICIENT_BALANCE, 404 …
  console.error(response.status, body.error.code, body.message);
}

$batchId = "batch_6615a3f2e4b0c1d2e3f4a5b6";

$ch = curl_init("$baseUrl/orders/confirm/$batchId");
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer $apiKey",
    "Content-Type: application/json",
]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

$body = json_decode(curl_exec($ch), true);
$code = curl_getinfo($ch, CURLINFO_HTTP_CODE);

// Check the status before unwrapping: on any error "data" is null.
if ($code === 200) {
    $data = $body["data"];
    // A 200 does NOT guarantee an order: if every row failed validation,
    // order_id is null and labels_accepted is 0 (nothing was charged).
    // The envelope message says "Bulk order created" either way.
    if ($data["order_id"] === null) {
        echo "Confirm accepted zero labels — nothing created or charged\n";
    } else {
        echo "Bulk order {$data['order_id']} created "
           . "({$data['summary']['labels_accepted']} labels)\n";
    }
    // rejected[] is the only place the API names the dropped rows.
    foreach ($data["rejected"] as $row) {
        echo "  rejected row {$row['index']} "
           . "({$row['reference']}): {$row['error']}\n";
    }
} elseif ($code === 409) {
    // Already confirmed — GET /batches/{batch_id}/ for the order id.
    // NEVER re-validate these rows: that creates a second order.
    echo "Already confirmed — reconcile via the batch endpoint\n";
} else {
    echo $code . " " . $body["error"]["code"] . "\n";
}

batch_id = "batch_6615a3f2e4b0c1d2e3f4a5b6"

uri = URI("#{BASE_URL}/orders/confirm/#{batch_id}")
request = Net::HTTP::Post.new(uri)
request["Authorization"] = "Bearer #{API_KEY}"
request["Content-Type"] = "application/json"

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") do |http|
  http.request(request)
end

body = JSON.parse(response.body)

# Check the status before unwrapping: on any error "data" is null.
case response.code
when "200"
  data = body["data"]
  # A 200 does NOT guarantee an order: if every row failed validation,
  # order_id is null and labels_accepted is 0 (nothing was charged).
  # The envelope message says "Bulk order created" either way.
  if data["order_id"].nil?
    puts "Confirm accepted zero labels — nothing created or charged"
  else
    puts "Bulk order #{data['order_id']} created " \
         "(#{data['summary']['labels_accepted']} labels)"
  end
  # rejected[] is the only place the API names the dropped rows.
  data["rejected"].each do |row|
    puts "  rejected row #{row['index']} " \
         "(#{row['reference']}): #{row['error']}"
  end
when "409"
  # Already confirmed — GET /batches/{batch_id}/ for the order id.
  # NEVER re-validate these rows: that creates a second order.
  puts "Already confirmed — reconcile via the batch endpoint"
else
  puts "#{response.code} #{body['error']['code']}"
end

var batchId = "batch_6615a3f2e4b0c1d2e3f4a5b6";

var response = await client.PostAsync(
    $"{baseUrl}/orders/confirm/{batchId}",
    new StringContent("", Encoding.UTF8, "application/json")
);

var json = await response.Content.ReadAsStringAsync();

// Branch on the status before parsing: on any error "data" is null, and a
// 503 raised by a proxy in front of the API is HTML, not an envelope.
if (response.IsSuccessStatusCode)
{
    using var doc = JsonDocument.Parse(json);
    var data = doc.RootElement.GetProperty("data");
    // A 200 does NOT guarantee an order: if every row failed validation,
    // order_id is null and labels_accepted is 0 (nothing was charged).
    // Branch on data.order_id, never on message.
    var orderId = data.GetProperty("order_id");
    if (orderId.ValueKind == JsonValueKind.Null)
    {
        Console.WriteLine("Confirm accepted zero labels — nothing created or charged");
    }
    else
    {
        var accepted = data.GetProperty("summary").GetProperty("labels_accepted").GetInt32();
        Console.WriteLine($"Bulk order {orderId.GetString()} created ({accepted} labels)");
    }
    // rejected[] is the only place the API names the dropped rows.
    foreach (var row in data.GetProperty("rejected").EnumerateArray())
    {
        var index = row.GetProperty("index").GetInt32();
        var reference = row.GetProperty("reference").GetString();
        var rowError = row.GetProperty("error").GetString();
        Console.WriteLine($"  rejected row {index} ({reference}): {rowError}");
    }
}
else if ((int)response.StatusCode == 409)
{
    // Already confirmed — your earlier call landed. Read the order id off
    // the batch; NEVER re-validate these rows (that double-charges).
    var batchResponse = await client.GetAsync($"{baseUrl}/batches/{batchId}/");
    var batchJson = await batchResponse.Content.ReadAsStringAsync();
    if ((int)batchResponse.StatusCode == 404)
    {
        // The batch was purged (24h after validation). The order, if any,
        // outlived it — reconcile by reference, never re-validate.
        throw new Exception("batch purged — reconcile with GET /orders/?reference=...");
    }
    using var batchDoc = JsonDocument.Parse(batchJson);
    var batch = batchDoc.RootElement.GetProperty("data");
    // order_id is null in TWO states — only "status" separates them.
    var batchOrderId = batch.GetProperty("order_id");
    if (batchOrderId.ValueKind != JsonValueKind.Null)
    {
        Console.WriteLine($"Already confirmed as {batchOrderId.GetString()} — poll that order");
    }
    else if (batch.GetProperty("status").GetString() == "completed")
    {
        Console.WriteLine("Confirm accepted zero labels — terminal, nothing was created or charged");
    }
    else
    {
        Console.WriteLine("Confirm still in flight — keep polling this batch");
    }
}
else
{
    // 400 BATCH_EXPIRED, 422 INSUFFICIENT_BALANCE, 404 …
    // Guard the parse: the HTML body this comment warns about would throw
    // here, turning a readable proxy error into a JsonException.
    string errCode;
    try
    {
        using var errDoc = JsonDocument.Parse(json);
        errCode = errDoc.RootElement.GetProperty("error").GetProperty("code").GetString();
    }
    catch (JsonException)
    {
        errCode = "non-JSON error body";
    }
    Console.WriteLine($"{(int)response.StatusCode} {errCode}");
}

import time

order_id = "6615b1c2d3e4f5a6b7c8d9e0"
interval = 2   # Start at 2 seconds
timeout = 120   # 2-minute timeout
elapsed = 0

while elapsed < timeout:
    response = requests.get(
        f"{BASE_URL}/orders/{order_id}/",
        headers=headers,
    )
    if response.status_code != 200:
        # On any error the envelope's "data" is null, so never unwrap it.
        # 429 and 503 are worth waiting out; 404 (wrong or foreign order id) and 401 never recover.
        # Branch on the status BEFORE parsing the body: a 503 raised by a
        # proxy in front of the API is HTML, not an envelope.
        if response.status_code in (429, 503):
            wait = int(response.headers.get("Retry-After", interval))
            time.sleep(wait)
            elapsed += wait
            continue
        code = response.json()["error"]["code"]
        raise SystemExit(f"{response.status_code} {code} - not retryable")
    data = response.json()["data"]

    # cancelled and refunded are terminal too — support can move the
    # order there at any time, and polling past them never completes.
    if data["status"] in ("completed", "partial"):
        # Bulk order (everything this API creates) vs a single order
        # created in the dashboard, which has no labels[].
        if data.get("order_type") == "bulk":
            for label in data["labels"]:
                # submitted_index is the row you sent. It is absent on legacy
                # orders — index is only a position inside this order,
                # so never print it as if it were your row number.
                where = (f"row {label['submitted_index']}"
                         if "submitted_index" in label
                         else f"position {label['index']}")
                print(f"  {where} {label['reference']}: "
                      f"{label.get('status')} {label.get('tracking_number', '')}")
            print(f"Labels PDF: {data.get('labels_pdf_url')}")
        else:
            print(f"Label PDF: {data.get('label_pdf_url')}")
        break
    elif data["status"] in ("failed", "cancelled", "refunded"):
        # error_data is carried only when the status is "failed" — on
        # cancelled/refunded the key is absent, not null. (The detail
        # endpoint always includes it; this one does not.)
        if data["status"] == "failed":
            print(f"failed: {data['error_data']}")
        else:
            print(data["status"])
        break

    time.sleep(interval)
    elapsed += interval
    interval = min(interval * 1.5, 30)
else:
    print("Timed out — check back later")

const orderId = "6615b1c2d3e4f5a6b7c8d9e0";
let interval = 2000;
const timeout = 120000;
let elapsed = 0;

while (elapsed < timeout) {
  const res = await fetch(
    `${BASE_URL}/orders/${orderId}/`,
    { headers: { "Authorization": `Bearer ${API_KEY}` } }
  );
  if (!res.ok) {
    // On any error the envelope's "data" is null, so never unwrap it.
    // 429 and 503 are worth waiting out; 404 (wrong or foreign order id) and 401 never recover.
    // Branch on the status BEFORE parsing the body: a 503 raised by a
    // proxy in front of the API is HTML, not an envelope.
    if (res.status === 429 || res.status === 503) {
      const wait = Number(res.headers.get("Retry-After") || interval / 1000) * 1000;
      await new Promise((r) => setTimeout(r, wait));
      elapsed += wait;
      continue;
    }
    const { error } = await res.json();
    throw new Error(`${res.status} ${error.code} - not retryable`);
  }
  const { data } = await res.json();

  // cancelled and refunded are terminal too — support can move the
  // order there at any time, and polling past them never completes.
  if (data.status === "completed" || data.status === "partial") {
    // Bulk order (everything this API creates) vs a single order
    // created in the dashboard, which has no labels[].
    if (data.order_type === "bulk") {
      data.labels.forEach((l) => {
        // submitted_index is the row you sent. It is absent on legacy
        // orders — index is only a position inside this order, so
        // never print it as if it were your row number.
        const where = l.submitted_index === undefined
          ? `position ${l.index}` : `row ${l.submitted_index}`;
        console.log(`  ${where} ${l.reference}: ${l.status} ${l.tracking_number || ""}`);
      });
      console.log("Labels PDF:", data.labels_pdf_url);
    } else {
      console.log("Label PDF:", data.label_pdf_url);
    }
    break;
  } else if (["failed", "cancelled", "refunded"].includes(data.status)) {
    // error_data is carried only when the status is "failed" — on
    // cancelled/refunded the key is absent, not null. (The detail
    // endpoint always includes it; this one does not.)
    if (data.status === "failed") console.log("failed:", data.error_data);
    else console.log(data.status);
    break;
  }

  await new Promise((r) => setTimeout(r, interval));
  elapsed += interval;
  interval = Math.min(interval * 1.5, 30000);
}
// The loop breaks on a terminal status, so reaching the budget means
// the order is still in flight — say so instead of exiting silently.
if (elapsed >= timeout) console.log("Timed out — check back later");

$orderId = "6615b1c2d3e4f5a6b7c8d9e0";
$interval = 2;
$timeout = 120;
$elapsed = 0;

while ($elapsed < $timeout) {
    $ch = curl_init("$baseUrl/orders/$orderId/");
    curl_setopt($ch, CURLOPT_HTTPHEADER, [
        "Authorization: Bearer $apiKey",
    ]);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_HEADER, true);   // keep the headers: Retry-After lives there
    $raw = curl_exec($ch);
    $code = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    $headerSize = curl_getinfo($ch, CURLINFO_HEADER_SIZE);
    $headers = substr($raw, 0, $headerSize);
    if ($code !== 200) {
        // On any error the envelope's "data" is null, so never unwrap it.
        // 429 and 503 are worth waiting out; 404 (wrong or foreign order id) and 401 never recover.
        if ($code === 429 || $code === 503) {
            // Honour the server cooldown; fall back to our own interval.
            preg_match('/^Retry-After:\s*(\d+)/mi', $headers, $m);
            $wait = (int) ($m[1] ?? ceil($interval));
            sleep($wait);
            $elapsed += $wait;
            continue;
        }
        // Abort loudly: a shell wrapper must be able to tell this from success.
        // Decode only now: a 503 raised by a proxy in front of the API
        // is an HTML page, not an envelope, so json_decode() returns null.
        $body = json_decode(substr($raw, $headerSize), true);
        $errCode = $body["error"]["code"] ?? "non-JSON error body";
        fwrite(STDERR, "$code $errCode - not retryable\n");
        exit(1);
    }
    $body = json_decode(substr($raw, $headerSize), true);
    $data = $body["data"];

    // cancelled and refunded are terminal too — support can move the
    // order there at any time, and polling past them never completes.
    if (in_array($data["status"], ["completed", "partial"])) {
        // Bulk order (everything this API creates) vs a single order
        // created in the dashboard, which has no labels[].
        if (($data["order_type"] ?? "") === "bulk") {
            foreach ($data["labels"] as $l) {
                // submitted_index is the row you sent; absent on legacy
                // orders, where index is only a position in this order.
                $where = isset($l["submitted_index"])
                    ? "row {$l['submitted_index']}"
                    : "position {$l['index']}";
                echo "  $where {$l['reference']}: {$l['status']} " . ($l["tracking_number"] ?? "") . "\n";
            }
            echo "Labels PDF: " . ($data["labels_pdf_url"] ?? "") . "\n";
        } else {
            echo "Label PDF: " . ($data["label_pdf_url"] ?? "") . "\n";
        }
        break;
    } elseif (in_array($data["status"], ["failed", "cancelled", "refunded"])) {
        echo $data["status"] . "\n";
        break;
    }

    // $interval becomes a float on the second pass; sleep() takes an int,
    // so cast explicitly or PHP 8.1+ warns and truncates the wait.
    sleep((int) ceil($interval));
    $elapsed += $interval;
    $interval = min($interval * 1.5, 30);
}
// The loop breaks on a terminal status, so reaching the budget means
// the order is still in flight — say so instead of exiting silently.
if ($elapsed >= $timeout) {
    echo "Timed out — check back later\n";
}

order_id = "6615b1c2d3e4f5a6b7c8d9e0"
interval = 2
timeout = 120
elapsed = 0

while elapsed < timeout
  uri = URI("#{BASE_URL}/orders/#{order_id}/")
  req = Net::HTTP::Get.new(uri)
  req["Authorization"] = "Bearer #{API_KEY}"
  res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| http.request(req) }
  unless res.is_a?(Net::HTTPSuccess)
    # On any error the envelope's "data" is null, so never unwrap it.
    # 429 and 503 are worth waiting out; 404 (wrong or foreign order id) and 401 never recover.
    # Branch on the status BEFORE parsing the body: a 503 raised by a
    # proxy in front of the API is HTML, not an envelope.
    if ["429", "503"].include?(res.code)
      wait = (res["Retry-After"] || interval).to_i
      sleep(wait)
      elapsed += wait
      next
    end
    body = JSON.parse(res.body)
    abort("#{res.code} #{body['error']['code']} - not retryable")
  end
  data = JSON.parse(res.body)["data"]

  # cancelled and refunded are terminal too — support can move the
  # order there at any time, and polling past them never completes.
  if ["completed", "partial"].include?(data["status"])
    # Bulk order (everything this API creates) vs a single order
    # created in the dashboard, which has no labels[].
    if data["order_type"] == "bulk"
      data["labels"].each do |l|
        # submitted_index is the row you sent; absent on legacy
        # orders, where index is only a position in this order.
        where = l.key?("submitted_index") ? "row #{l['submitted_index']}" : "position #{l['index']}"
        puts "  #{where} #{l['reference']}: #{l['status']} #{l['tracking_number']}"
      end
      puts "Labels PDF: #{data['labels_pdf_url']}"
    else
      puts "Label PDF: #{data['label_pdf_url']}"
    end
    break
  elsif ["failed", "cancelled", "refunded"].include?(data["status"])
    # error_data is carried only when the status is "failed" — on
    # cancelled/refunded the key is absent, not null. (The detail
    # endpoint always includes it; this one does not.)
    if data["status"] == "failed"
      puts "failed: #{data['error_data']}"
    else
      puts data["status"]
    end
    break
  end

  sleep(interval)
  elapsed += interval
  interval = [interval * 1.5, 30].min
end

# The loop breaks on a terminal status, so reaching the budget means
# the order is still in flight — say so instead of exiting silently.
puts "Timed out — check back later" if elapsed >= timeout

var orderId = "6615b1c2d3e4f5a6b7c8d9e0";
var interval = 2000;
var timeout = 120000;
var elapsed = 0;

while (elapsed < timeout)
{
    var response = await client.GetAsync(
        $"{baseUrl}/orders/{orderId}/"
    );
    var json = await response.Content.ReadAsStringAsync();
    if (!response.IsSuccessStatusCode)
    {
        // On any error the envelope's "data" is null, so never unwrap it.
        // 429 and 503 are worth waiting out; 404 (wrong or foreign order id) and 401 never recover.
        // Branch on the status BEFORE parsing the body: a 503 raised by a
        // proxy in front of the API is HTML, not an envelope.
        if ((int)response.StatusCode == 429 || (int)response.StatusCode == 503)
        {
            var wait = (int)(response.Headers.RetryAfter?.Delta?.TotalMilliseconds ?? interval);
            await Task.Delay(wait);
            elapsed += wait;
            continue;
        }
        using var errDoc = JsonDocument.Parse(json);
        var errCode = errDoc.RootElement.GetProperty("error").GetProperty("code").GetString();
        throw new Exception($"{(int)response.StatusCode} {errCode} - not retryable");
    }
    using var doc = JsonDocument.Parse(json);
    var status = doc.RootElement
        .GetProperty("data")
        .GetProperty("status")
        .GetString();

    // partial, cancelled and refunded are terminal too — polling
    // past them never reaches "completed".
    if (status == "completed" || status == "partial"
        || status == "failed" || status == "cancelled"
        || status == "refunded")
    {
        Console.WriteLine(json);
        break;
    }

    await Task.Delay(interval);
    elapsed += interval;
    interval = Math.Min((int)(interval * 1.5), 30000);
}

// The loop breaks on a terminal status, so reaching the budget means
// the order is still in flight — say so instead of exiting silently.
if (elapsed >= timeout) Console.WriteLine("Timed out — check back later");

import time

batch_id = "batch_6615a3f2e4b0c1d2e3f4a5b6"
interval = 5   # 5-second fixed interval for batches
timeout = 300   # 5-minute timeout
elapsed = 0

while elapsed < timeout:
    response = requests.get(
        f"{BASE_URL}/batches/{batch_id}/",
        headers=headers,
    )
    if response.status_code != 200:
        # On any error the envelope's "data" is null, so never unwrap it.
        # 429 and 503 are worth waiting out; 404 means the batch record was purged or unknown - reconcile with
        # GET /orders/?reference=... instead of re-validating - and 401 never recovers.
        # Branch on the status BEFORE parsing the body: a 503 raised by a
        # proxy in front of the API is HTML, not an envelope.
        if response.status_code in (429, 503):
            wait = int(response.headers.get("Retry-After", interval))
            time.sleep(wait)
            elapsed += wait
            continue
        code = response.json()["error"]["code"]
        raise SystemExit(f"{response.status_code} {code} - not retryable")
    data = response.json()["data"]

    # Decide on the status. order is None for an unconfirmed batch
    # (keep polling) AND for a confirmed-empty one, which is terminal.
    if data["status"] in (
        "completed", "partial", "failed", "cancelled", "refunded"
    ):
        print(f"Batch {data['status']}:")
        if data["order"]:
            for label in data["order"]["labels"]:
                # submitted_index is the row you sent; absent on legacy
                # orders, where index is only a position in this order.
                where = (f"row {label['submitted_index']}"
                         if "submitted_index" in label
                         else f"position {label['index']}")
                print(f"  {where} "
                      f"{label['reference']}: {label.get('status')} "
                      f"{label.get('tracking_number', '')}")
        else:
            print("  confirm created no labels —", data["summary"])
        break

    time.sleep(interval)
    elapsed += interval
else:
    print("Timed out — check back later")

const batchId = "batch_6615a3f2e4b0c1d2e3f4a5b6";
const interval = 5000;
const timeout = 300000;
let elapsed = 0;

while (elapsed < timeout) {
  const res = await fetch(
    `${BASE_URL}/batches/${batchId}/`,
    { headers: { "Authorization": `Bearer ${API_KEY}` } }
  );
  if (!res.ok) {
    // On any error the envelope's "data" is null, so never unwrap it.
    // 429 and 503 are worth waiting out; 404 means the batch record was purged or unknown - reconcile with
    // GET /orders/?reference=... instead of re-validating - and 401 never recovers.
    // Branch on the status BEFORE parsing the body: a 503 raised by a
    // proxy in front of the API is HTML, not an envelope.
    if (res.status === 429 || res.status === 503) {
      const wait = Number(res.headers.get("Retry-After") || interval / 1000) * 1000;
      await new Promise((r) => setTimeout(r, wait));
      elapsed += wait;
      continue;
    }
    const { error } = await res.json();
    throw new Error(`${res.status} ${error.code} - not retryable`);
  }
  const { data } = await res.json();

  // Decide on the status. order is null for an unconfirmed batch
  // (keep polling) AND for a confirmed-empty one, which is terminal.
  if (["completed", "partial", "failed",
      "cancelled", "refunded"].includes(data.status)) {
    if (data.order) {
      console.log(`Batch ${data.status}:`, data.order.labels);
    } else {
      console.log("confirm created no labels —", data.summary);
    }
    break;
  }

  await new Promise((r) => setTimeout(r, interval));
  elapsed += interval;
}

// Reaching the budget means the batch is still in flight.
if (elapsed >= timeout) console.log("Timed out — check back later");

$batchId = "batch_6615a3f2e4b0c1d2e3f4a5b6";
$interval = 5;
$timeout = 300;
$elapsed = 0;

while ($elapsed < $timeout) {
    $ch = curl_init("$baseUrl/batches/$batchId/");
    curl_setopt($ch, CURLOPT_HTTPHEADER, [
        "Authorization: Bearer $apiKey",
    ]);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_HEADER, true);   // keep the headers: Retry-After lives there
    $raw = curl_exec($ch);
    $code = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    $headerSize = curl_getinfo($ch, CURLINFO_HEADER_SIZE);
    $headers = substr($raw, 0, $headerSize);
    if ($code !== 200) {
        // On any error the envelope's "data" is null, so never unwrap it.
        // 429 and 503 are worth waiting out; 404 means the batch record was purged or unknown - reconcile with
        // GET /orders/?reference=... instead of re-validating - and 401 never recovers.
        if ($code === 429 || $code === 503) {
            // Honour the server cooldown; fall back to our own interval.
            preg_match('/^Retry-After:\s*(\d+)/mi', $headers, $m);
            $wait = (int) ($m[1] ?? ceil($interval));
            sleep($wait);
            $elapsed += $wait;
            continue;
        }
        // Abort loudly: a shell wrapper must be able to tell this from success.
        // Decode only now: a 503 raised by a proxy in front of the API
        // is an HTML page, not an envelope, so json_decode() returns null.
        $body = json_decode(substr($raw, $headerSize), true);
        $errCode = $body["error"]["code"] ?? "non-JSON error body";
        fwrite(STDERR, "$code $errCode - not retryable\n");
        exit(1);
    }
    $body = json_decode(substr($raw, $headerSize), true);
    $data = $body["data"];

    // Decide on the status. order is null for an unconfirmed batch
    // (keep polling) AND for a confirmed-empty one, which is terminal.
    if (in_array($data["status"],
            ["completed", "partial", "failed", "cancelled", "refunded"])) {
        echo "Batch {$data['status']}\n";
        if ($data["order"] !== null) {
            print_r($data["order"]["labels"]);
        } else {
            echo "  confirm created no labels\n";
            print_r($data["summary"]);
        }
        break;
    }

    sleep($interval);
    $elapsed += $interval;
}

// Reaching the budget means the batch is still in flight.
if ($elapsed >= $timeout) {
    echo "Timed out — check back later\n";
}

batch_id = "batch_6615a3f2e4b0c1d2e3f4a5b6"
interval = 5
timeout = 300
elapsed = 0

while elapsed < timeout
  uri = URI("#{BASE_URL}/batches/#{batch_id}/")
  req = Net::HTTP::Get.new(uri)
  req["Authorization"] = "Bearer #{API_KEY}"
  res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| http.request(req) }
  unless res.is_a?(Net::HTTPSuccess)
    # On any error the envelope's "data" is null, so never unwrap it.
    # 429 and 503 are worth waiting out; 404 means the batch record was purged or unknown - reconcile with
    # GET /orders/?reference=... instead of re-validating - and 401 never recovers.
    # Branch on the status BEFORE parsing the body: a 503 raised by a
    # proxy in front of the API is HTML, not an envelope.
    if ["429", "503"].include?(res.code)
      wait = (res["Retry-After"] || interval).to_i
      sleep(wait)
      elapsed += wait
      next
    end
    body = JSON.parse(res.body)
    abort("#{res.code} #{body['error']['code']} - not retryable")
  end
  data = JSON.parse(res.body)["data"]

  # Decide on the status. order is nil for an unconfirmed batch
  # (keep polling) AND for a confirmed-empty one, which is terminal.
  if ["completed", "partial", "failed",
      "cancelled", "refunded"].include?(data["status"])
    if data["order"]
      puts "Batch #{data['status']}: #{data['order']['labels']}"
    else
      puts "Batch #{data['status']}: confirm created no labels — #{data['summary']}"
    end
    break
  end

  sleep(interval)
  elapsed += interval
end

# Reaching the budget means the batch is still in flight.
puts "Timed out — check back later" if elapsed >= timeout

var batchId = "batch_6615a3f2e4b0c1d2e3f4a5b6";
var interval = 5000;
var timeout = 300000;
var elapsed = 0;

while (elapsed < timeout)
{
    var response = await client.GetAsync(
        $"{baseUrl}/batches/{batchId}/"
    );
    var json = await response.Content.ReadAsStringAsync();
    if (!response.IsSuccessStatusCode)
    {
        // On any error the envelope's "data" is null, so never unwrap it.
        // 429 and 503 are worth waiting out; 404 means the batch record was purged or unknown - reconcile with
        // GET /orders/?reference=... instead of re-validating - and 401 never recovers.
        // Branch on the status BEFORE parsing the body: a 503 raised by a
        // proxy in front of the API is HTML, not an envelope.
        if ((int)response.StatusCode == 429 || (int)response.StatusCode == 503)
        {
            var wait = (int)(response.Headers.RetryAfter?.Delta?.TotalMilliseconds ?? interval);
            await Task.Delay(wait);
            elapsed += wait;
            continue;
        }
        using var errDoc = JsonDocument.Parse(json);
        var errCode = errDoc.RootElement.GetProperty("error").GetProperty("code").GetString();
        throw new Exception($"{(int)response.StatusCode} {errCode} - not retryable");
    }
    using var doc = JsonDocument.Parse(json);
    var status = doc.RootElement
        .GetProperty("data")
        .GetProperty("status")
        .GetString();

    // cancelled and refunded are terminal too — support can move the
    // order there at any time.
    if (status == "completed" || status == "partial"
        || status == "failed" || status == "cancelled"
        || status == "refunded")
    {
        Console.WriteLine(json);
        break;
    }

    await Task.Delay(interval);
    elapsed += interval;
}

// Reaching the budget means the batch is still in flight.
if (elapsed >= timeout) Console.WriteLine("Timed out — check back later");

from datetime import datetime, timedelta, timezone

response = requests.get(
    f"{BASE_URL}/orders/",
    headers=headers,
    params={
        "status": "completed",   # exact lowercase value or it is ignored
        # UTC, like the cURL tab's `date -u`: the API reads this as UTC
        # midnight, so a local date would shift the window by a day.
        "date_from": (datetime.now(timezone.utc).date() - timedelta(days=7)).isoformat(),
        "per_page": 50,
    },
)

data = response.json()["data"]   # pagination lives under "data"
print(f"Total: {data['total']}, Page: {data['page']}")
for order in data["items"]:
    print(f"  {order['order_id']} — {order['status']}")

# Reconcile by your own reference (partial, case-insensitive). This is
# the lookup that replaces batch_id once a batch has been pruned.
found = requests.get(
    f"{BASE_URL}/orders/", headers=headers,
    params={"reference": "ORDER-001"},
).json()["data"]
print(f"{found['total']} order(s) carry that reference")

const weekAgo = new Date(Date.now() - 7 * 86400000)
  .toISOString().slice(0, 10);   // YYYY-MM-DD, no time part

const params = new URLSearchParams({
  status: "completed",   // exact lowercase value or it is ignored
  date_from: weekAgo,
  per_page: "50",
});

const response = await fetch(
  `${BASE_URL}/orders/?${params}`,
  { headers: { "Authorization": `Bearer ${API_KEY}` } }
);

const { data } = await response.json(); // pagination lives under "data"
console.log(`Total: ${data.total}, Page: ${data.page}`);
data.items.forEach((o) =>
  console.log(`  ${o.order_id} — ${o.status}`)
);

$query = http_build_query([
    "status" => "completed",   // exact lowercase value or it is ignored
    // gmdate(), not date(): the API reads this as UTC midnight, and
    // date() would use whatever date.timezone php.ini happens to set.
    "date_from" => gmdate("Y-m-d", strtotime("-7 days")),
    "per_page" => 50,
]);

$ch = curl_init("$baseUrl/orders/?$query");
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer $apiKey",
]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

// pagination lives under "data"
$data = json_decode(curl_exec($ch), true)["data"];
echo "Total: {$data['total']}, Page: {$data['page']}\n";
foreach ($data["items"] as $order) {
    echo "  {$order['order_id']} — {$order['status']}\n";
}

require "date"   # date is not loaded by default — Quick Start requires only net/http + json

uri = URI("#{BASE_URL}/orders/")
uri.query = URI.encode_www_form(
  status: "completed",   # exact lowercase value or it is ignored
  # UTC, like the cURL tab's `date -u` — the API reads this as UTC midnight.
  date_from: (Time.now.utc.to_date - 7).iso8601,
  per_page: 50
)

req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer #{API_KEY}"
res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| http.request(req) }

data = JSON.parse(res.body)["data"]  # pagination lives under "data"
puts "Total: #{data['total']}, Page: #{data['page']}"
data["items"].each { |o| puts "  #{o['order_id']} — #{o['status']}" }

var response = await client.GetAsync(
    $"{baseUrl}/orders/?status=completed"
    + $"&date_from={DateTime.UtcNow.AddDays(-7):yyyy-MM-dd}&per_page=50"
);

var json = await response.Content.ReadAsStringAsync();
Console.WriteLine(json);

order_id = "6615b1c2d3e4f5a6b7c8d9e0"

response = requests.get(
    f"{BASE_URL}/orders/{order_id}/details",
    headers=headers,
)

data = response.json()["data"]
print(f"Status: {data['status']}")

# Two shapes: bulk orders (everything this API creates) carry labels[];
# dashboard-created single orders carry order_details instead.
if data.get("order_type") == "bulk":
    for label in data["labels"]:
        # submitted_index is the row you sent; absent on legacy
        # orders, where index is only a position in this order.
        where = (f"row {label['submitted_index']}"
                 if "submitted_index" in label
                 else f"position {label['index']}")
        print(f"  {where} "
              f"{label['reference']}: {label.get('tracking_number', '')}")
    # Absent unless the order is completed or partial.
    if data.get("labels_pdf_url"):
        print(f"Labels PDF: {data['labels_pdf_url']}")
else:
    details = data.get("order_details", {})
    print(f"  {data.get('reference', '')}: {details.get('tracking_number', '')}")
    if data.get("label_pdf_url"):
        print(f"Label PDF: {data['label_pdf_url']}")

const orderId = "6615b1c2d3e4f5a6b7c8d9e0";

const response = await fetch(
  `${BASE_URL}/orders/${orderId}/details`,
  { headers: { "Authorization": `Bearer ${API_KEY}` } }
);

const { data } = await response.json();
console.log("Status:", data.status);

// Two shapes: bulk orders (everything this API creates) carry labels[];
// dashboard-created single orders carry order_details instead.
if (data.order_type === "bulk") {
  data.labels.forEach((l) => {
    // submitted_index is the row you sent; absent on legacy orders,
    // where index is only a position inside this order.
    const where = l.submitted_index === undefined
      ? `position ${l.index}` : `row ${l.submitted_index}`;
    console.log(`  ${where} ${l.reference}: ${l.tracking_number || ""}`);
  });
  // Absent unless the order is completed or partial.
  if (data.labels_pdf_url) console.log("Labels PDF:", data.labels_pdf_url);
} else {
  console.log(`  ${data.reference ?? ""}: ${data.order_details?.tracking_number ?? ""}`);
  if (data.label_pdf_url) console.log("Label PDF:", data.label_pdf_url);
}

$orderId = "6615b1c2d3e4f5a6b7c8d9e0";

$ch = curl_init("$baseUrl/orders/$orderId/details");
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer $apiKey",
]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

$data = json_decode(curl_exec($ch), true)["data"];
echo "Status: {$data['status']}\n";

// Two shapes: bulk orders (everything this API creates) carry labels[];
// dashboard-created single orders carry order_details instead.
if (($data["order_type"] ?? "") === "bulk") {
    foreach ($data["labels"] as $l) {
        // pending/failed labels have no tracking_number yet;
        // submitted_index is absent on legacy orders.
        $where = isset($l["submitted_index"])
            ? "row {$l['submitted_index']}"
            : "position {$l['index']}";
        echo "  $where {$l['reference']}: " . ($l["tracking_number"] ?? "") . "\n";
    }
    // Absent unless the order is completed or partial.
    if (isset($data["labels_pdf_url"])) {
        echo "Labels PDF: {$data['labels_pdf_url']}\n";
    }
} else {
    $details = $data["order_details"] ?? [];
    echo "  " . ($data["reference"] ?? "") . ": " . ($details["tracking_number"] ?? "") . "\n";
    if (isset($data["label_pdf_url"])) {
        echo "Label PDF: {$data['label_pdf_url']}\n";
    }
}

order_id = "6615b1c2d3e4f5a6b7c8d9e0"

uri = URI("#{BASE_URL}/orders/#{order_id}/details")
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer #{API_KEY}"
res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| http.request(req) }

data = JSON.parse(res.body)["data"]
puts "Status: #{data['status']}"

# Two shapes: bulk orders (everything this API creates) carry labels[];
# dashboard-created single orders carry order_details instead.
if data["order_type"] == "bulk"
  data["labels"].each do |l|
    # submitted_index is absent on legacy orders.
    where = l.key?("submitted_index") ? "row #{l['submitted_index']}" : "position #{l['index']}"
    puts "  #{where} #{l['reference']}: #{l['tracking_number']}"
  end
  # Absent unless the order is completed or partial.
  puts "Labels PDF: #{data['labels_pdf_url']}" if data["labels_pdf_url"]
else
  details = data["order_details"] || {}
  puts "  #{data['reference']}: #{details['tracking_number']}"
  puts "Label PDF: #{data['label_pdf_url']}" if data["label_pdf_url"]
end

var orderId = "6615b1c2d3e4f5a6b7c8d9e0";

var response = await client.GetAsync(
    $"{baseUrl}/orders/{orderId}/details"
);

var json = await response.Content.ReadAsStringAsync();
Console.WriteLine(json);