Entwicklerzentrum - Super Label

REST API Dokumentation

Erkunden, testen und integrieren Sie unsere RESTful-Endpunkte. Vollständige Swagger UI mit interaktivem Request-Builder und Authentifizierungsunterstützung.

REST API

GraphQL API Dokumentation

Fragen Sie genau die Daten ab, die Sie benötigen, mit unserer GraphQL API. Interaktiver Playground mit Schema-Explorer und Operationstests.

GraphQL

MCP-Kolumne

AI-Agenten & MCP-Clients: Setup, Sicherheitsprofile, Freigaben und Live-Tools für User- + Developer-Server.

MCP

Integrationsleitfäden

Vier in sich geschlossene Wege. Jeder ist für sich vollständig: anmelden, anfragen, buchen, Label oder zahlen, Tracking und eine Testliste. Bleiben Sie auf dem Weg, den Sie geöffnet haben.

Versandintegration

Abholung und Zustellung (eigene Flotte)

Abhol- oder Zustellauftrag anlegen, lokales Etikett drucken, verfolgen und Ereignisse empfangen — eigene Flotte, von Anfang bis Ende. Eine Preisauskunft ist optional.

Abholung oder Zustellung → lokales Label → Verfolgung → Ereignisse

FLOTTE

Versandetiketten

Versandarten listen, Preis einholen, Versandetikett buchen, PDF laden und die Sendung verfolgen.

Methoden → Preis → Etikett kaufen → PDF → Verfolgung

ETIKETTEN

Versandservice

Die eigenen Versanddienste der Spedition: Dienste listen, schätzen, buchen, bezahlen und verfolgen.

Dienste → Schätzung → anlegen → zahlen → Tracking

DIENSTE

Lagerung und Versand

Ware einlagern, bezahlen und auf diesem Weg die eingelagerten Positionen wieder auslagern.

Einlagern → zahlen → Positionen → auslagern → Tracking

LAGER

MCP-Kolumne

MCP 47 tools

Eigener Leitfaden für AI-Agenten und MCP-Clients: User- vs. Developer-Server, Least-Privilege-Profile, Dry-Run, Freigaben und Live-Tool-Katalog.

Profile & Scopes Menschliche Freigaben Dry-Run-Schreibvorgänge Developer-MCP

Webhooks — Webhook-Integrationsleitfaden

Erhalten Sie Echtzeitereignisse von Superroute — Bestellungen, Statusänderungen, Tracking-Updates. Mit signierten Payloads, automatischen Wiederholungen und integriertem Debugger.

WEBHOOKS

OTEP — Öffnen Sie das Tracking-Ereignisprotokoll

Ein Ereignis. Unendlich viele Wege. — Eigenzustellung, Drittanbieterzustellung und Carrier-Sendungen verschmelzen pro Sendungsnummer zu einer geordneten Ereignis-Zeitleiste.

OTEP

Leitfaden zu Integrations-Updates

Alle Neuerungen in API und Webhooks — idempotentes Stornieren, Abgleich-Feeds, v2-Signaturen, neue Events — mit Beispielen zum Kopieren. Alles vollständig abwärtskompatibel.

NEW

Postman Collection

Stets aktuelle Collection, live aus der API-Dokumentation generiert — in Postman importieren und direkt mit API-Aufrufen starten.

JSON

Bestellstatus-Wörterbuch & Ablauf

Das vollständige Statuswörterbuch und die Übergangsdiagramme, live aus dem bereitgestellten Code generiert.

MARKDOWN

Tracking-Ereigniscodes

Kundenbezogene Tracking-Ereigniscodes (Abhol- und Lieferseite), OTEP-Zuordnung, gängige Abläufe und Anleitung zur eigenen Tracking-Seite mit der öffentlichen API.

TRACKING

Erste Schritte

API-Token abrufen

Melden Sie sich an und gehen Sie zu Einstellungen → API-Schlüssel, um Ihr persönliches Zugriffstoken zu generieren.

API auswählen

Verwenden Sie REST für Standard-CRUD-Operationen, GraphQL für flexible Datenabfragen oder MCP, um KI-Assistenten direkt mit Ihren Logistikdaten zu verbinden.

Entwicklung starten

Öffnen Sie die interaktive Dokumentation, testen Sie Endpunkte im Browser und kopieren Sie die Code-Snippets in Ihre Anwendung.

Authentifizierung

Alle drei APIs verwenden denselben Bearer-Token (über den Login-Endpunkt erhalten). Einige Endpunkte sind öffentlich und erfordern keine Authentifizierung — einschließlich Login, öffentliches Tracking und Fahrer-Selbstregistrierung.

Token über den Login-Endpunkt abrufen:

                # POST /api/v1/user/login

                { "email": "you@example.com", "password": "••••••••" }

Anfrage-Header

Authorization: Bearer YOUR_ACCESS_TOKEN

REST Erforderlich für die meisten Endpunkte. Login, öffentliches Tracking und Fahrer-Selbstregistrierung sind öffentlich (kein Token erforderlich).

GQL Für authentifizierte Operationen erforderlich. Öffentliche Operationen (Login, Tracking) funktionieren ohne Token.

MCP Optional. Öffentliche Tools funktionieren ohne Token; ein gültiges Token ermöglicht Zugriff auf personalisierte Daten.

Basis-URLs

REST API https://api.superlabel.ca/api
GraphQL https://api.superlabel.ca/api/graphql
MCP https://api.superlabel.ca/mcp

Welche API soll ich verwenden?

REST API

Standard-CRUD-Operationen, Webhooks, Auftrags-/Routenverwaltung

GraphQL

Flexible Datenabfragen, benutzerdefinierte Berichte, verschachtelte Abfragen

MCP

KI-Assistenten-Integration (Claude, Cursor, Copilot usw.)

KI-Integration

Verleihen Sie Ihrem KI-Assistenten Logistik-Superkräfte. Verbinden Sie sich über MCP für eine codefreie Einrichtung, rufen Sie unsere API direkt von Ihrem KI-Agenten auf oder laden Sie die Skill-Datei für eine vollständige semantische Anleitung herunter.

Verfügbare Funktionen

Öffentliche Sendungsverfolgung

Rufen Sie den Lieferstatus, die Ereignis-Zeitleiste und den Zustellnachweis (Unterschrift/Foto) eines beliebigen Pakets anhand der Sendungsnummer ab.

ÖFFENTLICH

Betriebsereignisse

Erhalten Sie den vollständigen Prüfpfad für Aufträge — wer welchen Status wann und wo geändert hat, mit GPS-Koordinaten und angehängten Fotos.

AUTHENTIFIZIERUNG ERFORDERLICH

Etiketten-Service

Versandangebote von Speditionen einholen, Versandetiketten erstellen, Etiketten-PDFs herunterladen, Sendungen stornieren und Tagesabschluss-Manifeste einreichen.

AUTHENTIFIZIERUNG ERFORDERLICH

Lokale Zustellung

Zustell-/Abholaufträge erstellen, optimierte Mehrfahrer-Routen planen und den gesamten Last-Mile-Zustellworkflow verwalten.

AUTHENTIFIZIERUNG ERFORDERLICH

END USER Benutzer-MCP-Server

Für KI-Assistenten, die von Ihren Kunden verwendet werden. Konfiguration einfügen und Ihre KI kann sofort Pakete verfolgen — keine Programmierung erforderlich.

ENDPOINT

https://api.superlabel.ca/mcp

Verfügbare Werkzeuge (47 Live-Tools)

track_package Track a package by its tracking number. Returns delivery status, trackin... ÖFFENTLICH

otep_tracking Get the unified OTEP (Open Tracking Event Protocol) timeline for a track... ÖFFENTLICH

get_capabilities List MCP tools available to the current connection, with risk level, req... ÖFFENTLICH

get_orders List orders with filtering and pagination. Returns order details includi... AUTH

get_order_detail Get full details of a specific order by ID, including address, status, p... AUTH

find_order Fuzzy-find orders across tracking number, external tracking, ref, recipi... AUTH

get_operation_events Get the full audit trail for orders — every status change, who performed... AUTH

create_order Create a delivery/pickup order. D=delivery (warehouse→customer), P=picku... AUTH

cancel_order Cancel an existing order by order ID. Only works for orders not yet deli... confirm

bulk_create_orders Create up to 100 delivery orders in one call. Returns a per-order succes... confirm

reroute_to_address Change the delivery address of an order that has not been picked up yet:... confirm

update_delivery_instruction Update only the delivery_instruction field on an existing order (PATCH).... AUTH

update_order_note Update only the internal note field on an existing order (PATCH). AUTH

update_time_window_by_refs Bulk-update delivery time windows (and optional schedule_date) for order... AUTH

hold_order Put an order on HOLD so it is not dispatched until release_order. HIGH-R... confirm

release_order Release an order from HOLD back to NEW_ORDER. HIGH-RISK: requires confir... confirm

propose_write Queue a write/high-risk tool for human approval instead of executing it.... AUTH

list_pending_approvals List pending MCP write approvals for this business (or mine_only). AUTH

approve_pending_write Approve and execute a pending write proposal. HIGH-RISK: requires confir... confirm

reject_pending_write Reject a pending write proposal without executing it. AUTH

get_routes List delivery routes with their status, assigned driver, and order count... AUTH

get_route_detail Get one route with its stop/order list. Prefer this over get_routes when... AUTH

get_drivers List drivers for the authenticated business (ids, names, capacity defaul... AUTH

get_driver_routes_today Orders assigned to a driver on a given date (defaults to today). Useful... AUTH

get_build_route_options List routing engines, balance modes, capacity types, and defaults before... AUTH

build_route Build/optimize a delivery route (POST /api/v3/client/build-route). HIGH-... confirm

order_snapshot One-call order context for support: order detail + operation events + pu... AUTH

list_exceptions List failed/returned/exception-like orders for a schedule date (default... AUTH

get_shipping_methods List available shipping carriers/methods. Returns IDs and names — use th... AUTH

get_shipping_rate Get a shipping cost quote. Dry-run — no label created. Returns rate opti... AUTH

create_shipping_label Book a shipment with a carrier and generate a shipping label with tracki... AUTH

quote_and_ship One-shot: rate across all enabled carriers, pick the best one by strateg... AUTH

compare_all_carriers Get rate quotes from every enabled carrier for the same shipment, in one... AUTH

search_address Search and resolve addresses by postal code or free-text query. Returns... AUTH

daily_digest One-call summary of today's logistics activity: total orders, by status,... AUTH

get_orders_summary Aggregate order metrics over a time window: counts by status, top carrie... AUTH

get_account_credits Get the authenticated customer's wallet balance, currency, and recent to... AUTH

get_warehouses List WMS warehouses available to the authenticated business. AUTH

get_inventory Query WMS inventory (POST /api/v1/wms/inventory). Pass filters supported... AUTH

list_datasets List custom datasets available to the business. AUTH

get_dataset Get one dataset by id (metadata/columns). AUTH

list_dataset_groups List groups inside a dataset. AUTH

search_dataset_records Search records across groups in a dataset (POST .../search). AUTH

list_alliances List alliances the authenticated business belongs to. AUTH

get_alliance Get one alliance by id. AUTH

list_alliance_members List members of an alliance. AUTH

list_accessible_clients List clients accessible via alliance partnerships. AUTH

// .mcp.json — Ops-Agent mit schmalem Profil
{
  "mcpServers": {
    "superroute": {
      "type": "url",
      "url": "https://api.superlabel.ca/mcp",
      "headers": {
        "Authorization": "Bearer <token>",
        "X-MCP-Profile": "ops-readonly"
      }
    }
  }
}

DEVELOPER Entwickler-MCP-Server

Für KI-Codierungsassistenten (Claude Code, Cursor usw.), die Ihnen beim Erstellen von Superroute-Integrationen helfen. Ihre KI kann direkt APIs aufrufen, Endpunkte testen und Integrationscode generieren.

ENDPOINT

https://api.superlabel.ca/mcp/developer

Verfügbare Werkzeuge (25 Live-Tools)

track_package Paket anhand der Sendungsnummer verfolgen ÖFFENTLICH

get_operation_events Auftrags-Auditprotokoll abrufen AUTH

get_shipping_methods Verfügbare Carrier auflisten AUTH

get_shipping_rate Versandangebot abrufen AUTH

create_shipping_label Versandetikett erstellen AUTH

get_shipping_label Label-Details & Download-Info AUTH

create_order Zustell-/Abholauftrag erstellen AUTH

build_route Optimierte Lieferrouten bauen AUTH

get_build_route_options Get available options for building routes: routing engines with their balance modes, capacity ty... AUTH

get_api_endpoints Search the complete Superroute REST API catalog (the same OpenAPI spec that powers /api/document... ÖFFENTLICH

get_graphql_operations Search the Superroute GraphQL catalog — every query and mutation, grouped by category, each with... ÖFFENTLICH

run_graphql_query Execute a query or mutation against the Superroute GraphQL endpoint (POST /api/graphql) and retu... AUTH

get_otep_tracking Get a package's tracking history as an OTEP (Open Tracking Event Protocol) document — the normal... ÖFFENTLICH

validate_otep_payload Run an OTEP document or event through the live conformance validator (POST /api/v1/otep/validate... ÖFFENTLICH

check_skill_update Check if a newer version of the Superroute AI integration skill file is available. Returns curre... ÖFFENTLICH

get_integration_guide Integrationsanleitung abrufen ÖFFENTLICH

get_otep_guide Get the OTEP (Open Tracking Event Protocol) development guide — the What/When/Where/Why event mo... ÖFFENTLICH

get_webhook_guide Webhook-Integrationsleitfaden ÖFFENTLICH

verify_webhook_signature Verify whether an incoming webhook signature is valid. Pass the raw payload (string or JSON obje... ÖFFENTLICH

test_webhook_delivery Fire a real, properly-signed test webhook from Superroute servers to a URL the developer provide... AUTH

get_webhook_settings Read the caller's own webhook configuration — every per-event callback URL, the behaviour flags,... AUTH

update_webhook_settings Self-serve update of the caller's webhook configuration (PUT /api/v1/webhook-settings). Partial:... AUTH

get_order_audit_timeline Chronological audit timeline of ONE order across every source: web actions, driver app scans, wa... AUTH

get_webhook_delivery_logs List recorded webhook delivery attempts for the caller — event type, target URL, HTTP status, at... AUTH

replay_webhook_delivery Re-send a webhook that was already logged, by delivery-log id (get the id from get_webhook_deliv... AUTH

// .mcp.json — Connection-Bearer bevorzugt
{
  "mcpServers": {
    "superroute-dev": {
      "type": "url",
      "url": "https://api.superlabel.ca/mcp/developer",
      "headers": {
        "Authorization": "Bearer <token>"
      }
    }
  }
}

Nach 2026-12-31 kein api_token in Tool-Argumenten. Authorization auf der MCP-Verbindung verwenden.

User-MCP dient der Verwaltung mit Agenten; Developer-MCP dem Integrationsbau. Vollständiges Sicherheitsmodell in der MCP-Kolumne. MCP-Kolumne öffnen →

AI Tool-Erkennungsendpunkte

Strukturierte Funktionsbeschreibungen für AI-Agenten, LLM-Tool-Aufrufsysteme und MCP-Clients. Alle Endpunkte sind öffentlich, keine Authentifizierung erforderlich.

PRIMARY AI Tools-Manifest

Vollständiges Manifest mit Tooldefinitionen, Schemata, Authentifizierungsinformationen und Workflows.

GET https://api.superlabel.ca/api/.well-known/ai-tools.json

Auch erhältlich: /llms.txt

FORMAT Multiformat-Export

Erhalten Sie Werkzeugdefinitionen im nativen Format Ihrer AI-Plattform.

# OpenAI function calling
GET https://api.superlabel.ca/api/ai/tools?format=openai

# Anthropic Claude tool_use
GET https://api.superlabel.ca/api/ai/tools?format=anthropic

# MCP tools/list
GET https://api.superlabel.ca/api/ai/tools?format=mcp

# LangChain StructuredTool
GET https://api.superlabel.ca/api/ai/tools?format=langchain

REST OpenAPI + AI-Erweiterungen

OpenAPI-Spezifikation angereichert mit x-ai-* -Erweiterungen (Toolnamen, Verwendungszweck, Kategorien).

GET https://api.superlabel.ca/api/ai/tools/openapi

GQL GraphQL + AI Hinweise

GraphQL-Dokumente angereichert mit aiHints pro Vorgang (Wann zu verwenden, zugehörige Arbeitsabläufe).

GET https://api.superlabel.ca/api/ai/tools/graphql

Schnelle Integration

Python (OpenAI SDK )

import requests, json
tools = requests.get(
  "https://api.superlabel.ca/api/ai/tools?format=openai"
).json()["tools"]

# Pass to OpenAI
response = client.chat.completions.create(
  model="gpt-4",
  messages=messages,
  tools=tools
)

Python (Claude SDK )

import requests, anthropic
tools = requests.get(
  "https://api.superlabel.ca/api/ai/tools?format=anthropic"
).json()["tools"]

# Pass to Claude
response = client.messages.create(
  model="claude-sonnet-4-20250514",
  messages=messages,
  tools=tools
)

Node.js (abrufen)

const res = await fetch(
  "https://api.superlabel.ca/api/ai/tools?format=openai"
);
const { tools } = await res.json();

// Use with any LLM SDK
console.log(`Loaded ${tools.length} tools`);

Zusammenfassung der Funktionen: Für eine übersichtliche Übersicht (nur Kategorien und Werkzeugnamen) verwenden Sie GET https://api.superlabel.ca/api/ai/capabilities

AI Werkzeugspielplatz

Testen Sie die Superroute AI-Tools direkt in Ihrem Browser. Wählen Sie ein Tool aus, geben Sie die Parameter ein und sehen Sie sich die Live-Antwort von API an.

Wählen Sie Werkzeug

track_package

Anforderungstext ( JSON )

Antwort

Klicken Sie auf „Ausführen“, um das Tool auszuführen...

Mit REST oder GraphQL entwickeln

Für Entwickler, die benutzerdefinierte KI-Agenten, Chatbots oder programmatische Integrationen erstellen. Rufen Sie unsere API direkt aus Ihrem Code auf mit vollem Zugriff auf alle Logistikfunktionen.

REST REST API Endpunkte

# Paket verfolgen (öffentlich)
GET https://api.superlabel.ca/api/v1/tracking/{number}

# Betriebsereignisse
POST https://api.superlabel.ca/api/v1/tracking/operationevents

# Versandtarif abrufen
POST https://api.superlabel.ca/api/v1/labelservice/rate

# Versandetikett erstellen
POST https://api.superlabel.ca/api/v1/labelservice/submitOrder

# Zustellauftrag erstellen
POST https://api.superlabel.ca/api/v1/client/orderCreate

# Optimierte Route erstellen
POST https://api.superlabel.ca/api/v3/client/build-route

# Webhooks konfigurieren
PUT https://api.superlabel.ca/api/v1/webhook-settings

# Offene Tracking-Zeitleiste (OTEP)
GET https://api.superlabel.ca/api/v1/otep/trackings/{number}

Vollständige Dokumentation

GQL GraphQL Operationen

# Einzelner Endpunkt
POST https://api.superlabel.ca/api/graphql

# Verfügbare Operationen
trackingPublic       ← Paket verfolgen (öffentlich)
trackingOperationevents ← Betriebsereignisse
labelserviceRate      ← Versandtarif abrufen
labelserviceSubmitOrder ← Versandetikett erstellen
clientOrderCreate     ← Zustellauftrag erstellen
clientBuildRoute      ← Optimierte Route erstellen
webhookSettingsUpdate ← Webhooks konfigurieren
otepTracking          ← Offene Tracking-Zeitleiste (OTEP)

Vollständige Dokumentation

Wir empfehlen die REST API für die meisten KI-Integrationen — sie ist einfacher zu debuggen und jeder Endpunkt ist eigenständig. Verwenden Sie GraphQL, wenn Sie flexible Abfragen benötigen oder verschachtelte Daten in einer einzigen Anfrage abrufen möchten.

Superroute KI-Integrations-Skill

Eine umfassende Skill-Datei mit tiefgreifendem Logistik-Domänenwissen — was jede API macht, wann sie zu verwenden ist, was Parameter im realen Geschäftskontext bedeuten, wie Ergebnisse zu interpretieren sind und wie sich Funktionen zusammenfügen.

Skill-Datei herunterladen (.md)

So verwenden Sie die Skill-Datei

Claude Code

1 Laden Sie die obige Datei herunter
2 Platzieren Sie sie im Verzeichnis .claude/skills/ Ihres Projekts
3 Geben Sie /integrate in Claude Code ein, um den interaktiven Assistenten zu starten

mkdir -p .claude/skills
cp superroute-ai-integration.md .claude/skills/

Cursor

1 Laden Sie die obige Datei herunter
2 Platzieren Sie sie im Verzeichnis .cursor/rules/ Ihres Projekts
3 Cursor verwendet sie automatisch als Kontext, wenn Sie nach der Superroute-Integration fragen

mkdir -p .cursor/rules
cp superroute-ai-integration.md .cursor/rules/

Andere KI-Tools

1 Laden Sie die obige Datei herunter
2 Fügen Sie den Inhalt in den System-Prompt oder die Wissensbasis Ihres KI-Tools ein
3 Die KI verwendet die semantischen Beschreibungen zur Integrationsanleitung

# Oder in den System-Prompt einfügen
cat superroute-ai-integration.md

Skill-Datei aktuell halten

SCHNELL Ein-Befehl-Upgrade

Laden Sie die neueste Skill-Datei direkt vom Server herunter. Überschreibt Ihre lokale Kopie.

# Claude Code
curl -sS https://api.superlabel.ca/api/ai-skill -o .claude/skills/superroute-ai-integration.md

# Cursor
curl -sS https://api.superlabel.ca/api/ai-skill -o .cursor/rules/superroute-ai-integration.md

API Versionscheck-API

Prüfen Sie die neueste Version auf dem Server. Vergleichen Sie den Hash mit Ihrer lokalen Datei.

GET https://api.superlabel.ca/api/ai-skill/version

Antwort:
{ "version": "1.0.0", "hash": "abc123...", "download_url": "..." }

MCP Auto-Update über MCP

Wenn Sie den Developer MCP-Server verbunden haben, kann Ihr KI-Assistent mit dem check_skill_update-Tool nach Updates suchen. Übergeben Sie den MD5-Hash Ihrer lokalen Datei.

// Aufruf über Developer MCP Server
{
  "method": "tools/call",
  "params": {
    "name": "check_skill_update",
    "arguments": { "current_hash": "your_local_file_md5_hash" }
  }
}

CRON Auto-Update-Skript (Cron / CI)

Fügen Sie dieses Skript in Ihre CI-Pipeline oder als Cron-Job ein, um die Skill-Datei automatisch aktuell zu halten.

#!/bin/bash
# auto-update-skill.sh
SKILL_FILE=".claude/skills/superroute-ai-integration.md"
BASE_URL="https://api.superlabel.ca"

mkdir -p "$(dirname "$SKILL_FILE")"
LOCAL_HASH=$(md5sum "$SKILL_FILE" 2>/dev/null | cut -d' ' -f1)
SERVER_HASH=$(curl -s "$BASE_URL/api/ai-skill/version" | python3 -c "import sys,json; print(json.load(sys.stdin)['hash'])")

if [ "$LOCAL_HASH" != "$SERVER_HASH" ]; then
  curl -sS "$BASE_URL/api/ai-skill" -o "$SKILL_FILE"
  echo "Updated!"
fi

Die Skill-Datei geht über API-Dokumentation hinaus — sie lehrt Ihren KI-Assistenten die geschäftliche Bedeutung jedes Parameters, wie Antworten zu interpretieren sind und wie Funktionen für komplexe Logistik-Workflows kombiniert werden.

Codebeispiele

REST REST API — Paket verfolgen

Paket verfolgen (kein Token erforderlich)

curl https://api.superlabel.ca/api/v1/tracking/SR123456

Paket verfolgen (kein Token erforderlich)

<?php
$res = (new \GuzzleHttp\Client())->get('https://api.superlabel.ca/api/v1/tracking/SR123456');
print_r(json_decode($res->getBody(), true));

Paket verfolgen (kein Token erforderlich)

import requests
res = requests.get('https://api.superlabel.ca/api/v1/tracking/SR123456')
print(res.json())

Paket verfolgen (kein Token erforderlich)

resp, _ := http.Get("https://api.superlabel.ca/api/v1/tracking/SR123456")
var result map[string]interface{}
json.NewDecoder(resp.Body).Decode(&result)

Paket verfolgen (kein Token erforderlich)

const res = await fetch('https://api.superlabel.ca/api/v1/tracking/SR123456');
const data = await res.json();

Paket verfolgen (kein Token erforderlich)

HttpClient client = HttpClient.newHttpClient();
HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://api.superlabel.ca/api/v1/tracking/SR123456"))
    .build();
HttpResponse<String> res = client.send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(res.body());

Paket verfolgen (kein Token erforderlich)

require 'net/http'
puts Net::HTTP.get(URI('https://api.superlabel.ca/api/v1/tracking/SR123456'))

GQL GraphQL — Bestellungen abfragen

Bestellungen abfragen

curl -X POST https://api.superlabel.ca/api/graphql \
  -H "Content-Type: application/json" \
  -d '{"query":"query { trackingPublic(trackingNumber: \"SR123456\") { trackingNumber status events { timestamp description } } }"}'

Bestellungen abfragen

$query = 'query { trackingPublic(trackingNumber: "SR123456") { trackingNumber status } }';
$res = (new \GuzzleHttp\Client())->post('https://api.superlabel.ca/api/graphql', [
    'json' => ['query' => $query, 'variables' => []],
]);
print_r(json_decode($res->getBody(), true));

Bestellungen abfragen

import requests
query = 'query { trackingPublic(trackingNumber: "SR123456") { trackingNumber status } }'
res = requests.post('https://api.superlabel.ca/api/graphql', json={'query': query, 'variables': {}})
print(res.json())

Bestellungen abfragen

payload, _ := json.Marshal(map[string]interface{}{
    "query":     `query { trackingPublic(trackingNumber: "SR123456") { trackingNumber status } }`,
    "variables": map[string]interface{}{},
})
req, _ := http.NewRequest("POST", "https://api.superlabel.ca/api/graphql", bytes.NewBuffer(payload))
req.Header.Set("Content-Type", "application/json")
resp, _ := http.DefaultClient.Do(req)

Bestellungen abfragen

const res = await fetch('https://api.superlabel.ca/api/graphql', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ query: `query { trackingPublic(trackingNumber: "SR123456") { trackingNumber status } }` }),
});
const data = await res.json();

Bestellungen abfragen

String body = "{\"query\":\"query { trackingPublic(trackingNumber: \\\"SR123456\\\") { trackingNumber status } }\"}";
HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://api.superlabel.ca/api/graphql"))
    .header("Content-Type", "application/json")
    .POST(HttpRequest.BodyPublishers.ofString(body)).build();
HttpResponse<String> res = HttpClient.newHttpClient().send(req, HttpResponse.BodyHandlers.ofString());

Bestellungen abfragen

require 'net/http'; require 'json'
uri = URI('https://api.superlabel.ca/api/graphql')
req = Net::HTTP::Post.new(uri, 'Content-Type' => 'application/json')
req.body = JSON.dump({ query: 'query { trackingPublic(trackingNumber: "SR123456") { trackingNumber status } }' })
puts Net::HTTP.start(uri.hostname, uri.port) { |h| h.request(req) }.body

MCP MCP — Paket verfolgen

Paket verfolgen (kein Token erforderlich)

curl -X POST https://api.superlabel.ca/mcp \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"track_package","arguments":{"tracking_number":"SR123456"}}}'

Paket verfolgen (kein Token erforderlich)

$payload = [
    'jsonrpc' => '2.0', 'id' => 1, 'method' => 'tools/call',
    'params'  => ['name' => 'track_package', 'arguments' => ['tracking_number' => 'SR123456']],
];
$res = (new \GuzzleHttp\Client())->post('https://api.superlabel.ca/mcp', ['json' => $payload]);
print_r(json_decode($res->getBody(), true));

Paket verfolgen (kein Token erforderlich)

import requests
payload = {
    'jsonrpc': '2.0', 'id': 1, 'method': 'tools/call',
    'params': {'name': 'track_package', 'arguments': {'tracking_number': 'SR123456'}},
}
res = requests.post('https://api.superlabel.ca/mcp', json=payload)
print(res.json())

Paket verfolgen (kein Token erforderlich)

payload, _ := json.Marshal(map[string]interface{}{
    "jsonrpc": "2.0", "id": 1, "method": "tools/call",
    "params": map[string]interface{}{
        "name": "track_package",
        "arguments": map[string]interface{}{"tracking_number": "SR123456"},
    },
})
req, _ := http.NewRequest("POST", "https://api.superlabel.ca/mcp", bytes.NewBuffer(payload))
req.Header.Set("Content-Type", "application/json")
resp, _ := http.DefaultClient.Do(req)

Paket verfolgen (kein Token erforderlich)

const res = await fetch('https://api.superlabel.ca/mcp', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
        jsonrpc: '2.0', id: 1, method: 'tools/call',
        params: { name: 'track_package', arguments: { tracking_number: 'SR123456' } },
    }),
});
const data = await res.json();

Paket verfolgen (kein Token erforderlich)

String body = "{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"tools/call\",\"params\":{\"name\":\"track_package\",\"arguments\":{\"tracking_number\":\"SR123456\"}}}";
HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://api.superlabel.ca/mcp"))
    .header("Content-Type", "application/json")
    .POST(HttpRequest.BodyPublishers.ofString(body)).build();
HttpResponse<String> res = HttpClient.newHttpClient().send(req, HttpResponse.BodyHandlers.ofString());

Paket verfolgen (kein Token erforderlich)

require 'net/http'; require 'json'
uri = URI('https://api.superlabel.ca/mcp')
req = Net::HTTP::Post.new(uri, 'Content-Type' => 'application/json')
req.body = JSON.dump({ jsonrpc: '2.0', id: 1, method: 'tools/call',
    params: { name: 'track_package', arguments: { tracking_number: 'SR123456' } } })
puts Net::HTTP.start(uri.hostname, uri.port) { |h| h.request(req) }.body