Shipping Label Gateway API

import requests

BASE_URL = "https://app.example.com/gateway/v1"
API_KEY = "gw_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.example.com/gateway/v1";
const API_KEY = "gw_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.example.com/gateway/v1";
$apiKey = "gw_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.example.com/gateway/v1"
API_KEY = "gw_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: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

using System.Net.Http;

var baseUrl = "https://app.example.com/gateway/v1";
var apiKey = "gw_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 gw_your_api_key_here",
    "Content-Type": "application/json",
}

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

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

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

<?php
$ch = curl_init("https://app.example.com/gateway/v1/account/");
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer gw_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.example.com/gateway/v1/account/")
request = Net::HTTP::Get.new(uri)
request["Authorization"] = "Bearer gw_your_api_key_here"
request["Content-Type"] = "application/json"

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

puts JSON.parse(response.body)

using System.Net.Http;

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

var response = await client.GetAsync(
    "https://app.example.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: true) 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']}/{account['daily_orders_limit']}")

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}/${data.daily_orders_limit}`);

$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']}/{$account['daily_orders_limit']}\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: true) do |http|
  http.request(request)
end

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

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")}/{data.GetProperty("daily_orders_limit")}");

import requests

response = requests.post(
    f"{BASE_URL}/orders/validate",
    headers=headers,
    json={
        "orders": [
            {
                "reference": "ORDER-001",
                "ship_from": {
                    "name": "John Smith",
                    "address1": "123 Sender St",
                    "city": "Los Angeles",
                    "state": "CA",
                    "zip": "90001",
                },
                "ship_to": {
                    "name": "Jane Doe",
                    "address1": "456 Receiver Ave",
                    "address2": "Apt 2B",
                    "city": "New York",
                    "state": "NY",
                    "zip": "10001",
                },
                "package": {
                    "weight_oz": 12,
                    "length": 10,
                    "width": 8,
                    "height": 4,
                },
                "service_type": "priority_mail",
            }
        ]
    },
)

result = response.json()
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: "123 Sender St",
            city: "Los Angeles",
            state: "CA",
            zip: "90001",
          },
          ship_to: {
            name: "Jane Doe",
            address1: "456 Receiver Ave",
            address2: "Apt 2B",
            city: "New York",
            state: "NY",
            zip: "10001",
          },
          package: {
            weight_oz: 12,
            length: 10,
            width: 8,
            height: 4,
          },
          service_type: "priority_mail",
        },
      ],
    }),
  }
);

const result = await response.json();
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" => "123 Sender St",
                "city" => "Los Angeles",
                "state" => "CA",
                "zip" => "90001",
            ],
            "ship_to" => [
                "name" => "Jane Doe",
                "address1" => "456 Receiver Ave",
                "address2" => "Apt 2B",
                "city" => "New York",
                "state" => "NY",
                "zip" => "10001",
            ],
            "package" => [
                "weight_oz" => 12,
                "length" => 10,
                "width" => 8,
                "height" => 4,
            ],
            "service_type" => "priority_mail",
        ],
    ],
]);

$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);
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: "123 Sender St",
        city: "Los Angeles", state: "CA", zip: "90001"
      },
      ship_to: {
        name: "Jane Doe", address1: "456 Receiver Ave",
        address2: "Apt 2B",
        city: "New York", state: "NY", zip: "10001"
      },
      package: {
        weight_oz: 12, length: 10,
        width: 8, height: 4
      },
      service_type: "priority_mail"
    }
  ]
}.to_json

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

result = JSON.parse(response.body)
puts "Batch: #{result['data']['batch_id']}"

var payload = new
{
    orders = new[]
    {
        new
        {
            reference = "ORDER-001",
            ship_from = new
            {
                name = "John Smith",
                address1 = "123 Sender St",
                city = "Los Angeles",
                state = "CA",
                zip = "90001"
            },
            ship_to = new
            {
                name = "Jane Doe",
                address1 = "456 Receiver Ave",
                address2 = "Apt 2B",
                city = "New York",
                state = "NY",
                zip = "10001"
            },
            package = new
            {
                weight_oz = 12,
                length = 10,
                width = 8,
                height = 4
            },
            service_type = "priority_mail"
        }
    }
};

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,
)

result = response.json()
for order in result["data"]["accepted"]:
    print(f"Order {order['order_id']} created (ref: {order['reference']})")

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 result = await response.json();
result.data.accepted.forEach((order) => {
  console.log(`Order ${order.order_id} created`);
});

$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);

$result = json_decode(curl_exec($ch), true);
foreach ($result["data"]["accepted"] as $order) {
    echo "Order {$order['order_id']} created\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: true) do |http|
  http.request(request)
end

result = JSON.parse(response.body)
result["data"]["accepted"].each do |order|
  puts "Order #{order['order_id']} created"
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();
Console.WriteLine(json);

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,
    )
    data = response.json()["data"]

    if data["status"] == "completed":
        print(f"Tracking: {data['order_details']['tracking_number']}")
        print(f"Label: {data['files']['label_pdf']}")
        break
    elif data["status"] == "failed":
        print(f"Failed: {data['error_data']}")
        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}` } }
  );
  const { data } = await res.json();

  if (data.status === "completed") {
    console.log("Tracking:", data.order_details.tracking_number);
    console.log("Label:", data.files.label_pdf);
    break;
  } else if (data.status === "failed") {
    console.log("Failed:", data.error_data);
    break;
  }

  await new Promise((r) => setTimeout(r, interval));
  elapsed += interval;
  interval = Math.min(interval * 1.5, 30000);
}

$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);
    $data = json_decode(curl_exec($ch), true)["data"];

    if ($data["status"] === "completed") {
        echo "Tracking: {$data['order_details']['tracking_number']}\n";
        break;
    } elseif ($data["status"] === "failed") {
        echo "Failed\n";
        break;
    }

    sleep($interval);
    $elapsed += $interval;
    $interval = min($interval * 1.5, 30);
}

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: true) { |http| http.request(req) }
  data = JSON.parse(res.body)["data"]

  if data["status"] == "completed"
    puts "Tracking: #{data['order_details']['tracking_number']}"
    break
  elsif data["status"] == "failed"
    puts "Failed: #{data['error_data']}"
    break
  end

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

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();
    using var doc = JsonDocument.Parse(json);
    var status = doc.RootElement
        .GetProperty("data")
        .GetProperty("status")
        .GetString();

    if (status == "completed" || status == "failed")
    {
        Console.WriteLine(json);
        break;
    }

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

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,
    )
    data = response.json()["data"]

    if data["status"] in ("completed", "partial", "failed"):
        print(f"Batch {data['status']}:")
        print(f"  Summary: {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}` } }
  );
  const { data } = await res.json();

  if (["completed", "partial", "failed"].includes(data.status)) {
    console.log(`Batch ${data.status}:`, data.summary);
    break;
  }

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

$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);
    $data = json_decode(curl_exec($ch), true)["data"];

    if (in_array($data["status"], ["completed", "partial", "failed"])) {
        echo "Batch {$data['status']}\n";
        print_r($data["summary"]);
        break;
    }

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

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: true) { |http| http.request(req) }
  data = JSON.parse(res.body)["data"]

  if ["completed", "partial", "failed"].include?(data["status"])
    puts "Batch #{data['status']}: #{data['summary']}"
    break
  end

  sleep(interval)
  elapsed += interval
end

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();
    using var doc = JsonDocument.Parse(json);
    var status = doc.RootElement
        .GetProperty("data")
        .GetProperty("status")
        .GetString();

    if (status == "completed" || status == "partial"
        || status == "failed")
    {
        Console.WriteLine(json);
        break;
    }

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

response = requests.get(
    f"{BASE_URL}/orders/",
    headers=headers,
    params={
        "status": "completed",
        "date_from": "2025-04-03",
        "per_page": 50,
    },
)

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

const params = new URLSearchParams({
  status: "completed",
  date_from: "2025-04-03",
  per_page: "50",
});

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

const data = await response.json();
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",
    "date_from" => "2025-04-03",
    "per_page" => 50,
]);

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

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

uri = URI("#{BASE_URL}/orders/")
uri.query = URI.encode_www_form(
  status: "completed",
  date_from: "2025-04-03",
  per_page: 50
)

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

data = JSON.parse(res.body)
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=2025-04-03&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']}")
print(f"Tracking: {data['order_details']['tracking_number']}")

if data.get("files"):
    print(f"Label: {data['files']['label_pdf']}")

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);
console.log("Tracking:", data.order_details.tracking_number);
if (data.files) console.log("Label:", data.files.label_pdf);

$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";
echo "Tracking: {$data['order_details']['tracking_number']}\n";
if (isset($data["files"])) {
    echo "Label: {$data['files']['label_pdf']}\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: true) { |http| http.request(req) }

data = JSON.parse(res.body)["data"]
puts "Status: #{data['status']}"
puts "Tracking: #{data['order_details']['tracking_number']}"
puts "Label: #{data['files']['label_pdf']}" if data["files"]

var orderId = "6615b1c2d3e4f5a6b7c8d9e0";

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

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