Centro Sviluppatori - Super Label

Documentazione REST API

Esplora, testa e integra i nostri endpoint RESTful. Swagger UI completa con costruttore di richieste interattivo e supporto all'autenticazione.

REST API

Documentazione GraphQL API

Interroga esattamente i dati di cui hai bisogno con la nostra API GraphQL. Playground interattivo con esplorazione dello schema e test delle operazioni.

GraphQL

Colonna MCP

Agenti AI e client MCP: setup, profili di sicurezza, approvazioni e tool live.

MCP

Guide di integrazione

Quattro percorsi autonomi. Ognuno è completo da solo: autenticarsi, quotare, prenotare, etichetta o pagare, tracciamento e un elenco di verifica. Restate sul percorso che avete aperto.

Spedizione

Ritiro e consegna (flotta propria)

Creare un ordine di ritiro o consegna, stampare l’etichetta locale, tracciare e ricevere gli eventi — flotta propria, dall’inizio alla fine. Il preventivo è facoltativo.

Ritiro o consegna → etichetta locale → tracciamento → eventi

FLOTTA

Etichette corriere

Elencare i metodi di spedizione, ottenere una tariffa, prenotare un’etichetta corriere, scaricare il PDF e tracciare la spedizione.

Metodi → tariffa → acquistare → PDF → tracciamento

ETICHETTE

Servizi di spedizione

Usare i servizi di spedizione dell’azienda: elencare, stimare, creare l’ordine, pagare e tracciare.

Servizi → stima → creare → pagare → tracking

SERVIZI

Stoccaggio e uscita

Depositare merce in magazzino, pagare e poi spedirla su questo percorso.

Depositare → pagare → scegliere → uscire → tracking

MAGAZZINO

Colonna MCP

MCP 47 tools

Guida dedicata ad agenti AI e client MCP: server User vs Developer, profili least-privilege, dry-run, approvazioni e catalogo live.

Profili e scope Approvazioni umane Scritture dry-run Developer MCP

Webhook — Guida all'Integrazione Webhook

Ricevi eventi in tempo reale da Superroute — ordini, cambi di stato, aggiornamenti di tracciamento. Con payload firmati, tentativi automatici e debugger integrato.

WEBHOOKS

OTEP — Apri il protocollo degli eventi di monitoraggio

Un solo evento. Infiniti percorsi. — Consegna in proprio, consegna di terze parti e spedizioni con corriere si uniscono in un'unica cronologia ordinata di eventi per numero di tracciamento.

OTEP

Guida agli aggiornamenti di integrazione

Tutte le novità di API e webhook — annullamento idempotente, feed di riconciliazione, firme v2, nuovi eventi — con esempi pronti da copiare. Tutto pienamente retrocompatibile.

NEW

Postman Collection

Collection sempre aggiornata, generata in tempo reale dalla documentazione API — importala in Postman e inizia a chiamare l’API.

JSON

Dizionario e flusso degli stati ordine

Il dizionario completo degli stati ordine e i diagrammi di transizione, generati in tempo reale dal codice distribuito.

MARKDOWN

Codici evento di tracciamento

Codici evento di tracking (lato ritiro e consegna), mappa OTEP, flussi comuni e guida per creare la tua pagina di tracking con l’API pubblica.

TRACKING

Per iniziare

Ottieni il tuo token API

Accedi e vai su Impostazioni → Chiavi API per generare il tuo token di accesso personale.

Scegli la tua API

Usa REST per le operazioni CRUD standard, GraphQL per query di dati flessibili, o MCP per connettere assistenti IA direttamente ai tuoi dati logistici.

Inizia a sviluppare

Apri la documentazione interattiva per testare gli endpoint nel browser, poi copia i frammenti di codice nella tua applicazione.

Autenticazione

Tutte e tre le API utilizzano lo stesso token Bearer (ottenuto tramite l'endpoint di login). Alcuni endpoint sono pubblici e non richiedono autenticazione — inclusi login, tracciamento pubblico e auto-registrazione autisti.

Ottieni un token tramite l'endpoint di login:

                # POST /api/v1/user/login

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

Intestazione richiesta

Authorization: Bearer YOUR_ACCESS_TOKEN

REST Richiesto per la maggior parte degli endpoint. Login, tracciamento pubblico e auto-registrazione autisti sono pubblici (nessun token necessario).

GQL Richiesto per le operazioni autenticate. Le operazioni pubbliche (login, tracking) funzionano senza token.

MCP Facoltativo. Gli strumenti pubblici funzionano senza token; un token valido sblocca l'accesso ai dati personalizzati.

URL base

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

Quale API dovrei usare?

REST API

Operazioni CRUD standard, webhook, gestione ordini/percorsi

GraphQL

Query flessibili, report personalizzati, query annidate

MCP

Integrazione assistente IA (Claude, Cursor, Copilot ecc.)

Integrazione IA

Dai al tuo assistente IA superpoteri logistici. Connettiti tramite MCP senza scrivere codice, chiama la nostra API direttamente dal tuo agente IA, o scarica il file di competenze per una guida semantica completa.

Funzionalità disponibili

Tracciamento pubblico

Consulta lo stato di consegna, la cronologia degli eventi e la prova di consegna (firma/foto) di qualsiasi pacco tramite numero di tracciamento.

PUBBLICO

Eventi operativi

Ottieni la cronologia completa di audit degli ordini — chi ha cambiato quale stato, quando, dove, con coordinate GPS e foto allegate.

AUTENTICAZIONE RICHIESTA

Servizio etichette

Ottieni preventivi di spedizione dai corrieri, crea etichette di spedizione, scarica PDF delle etichette, annulla spedizioni e invia manifesti di fine giornata.

AUTENTICAZIONE RICHIESTA

Consegna locale

Crea ordini di consegna/ritiro, costruisci percorsi ottimizzati multi-autista e gestisci l'intero flusso di consegna dell'ultimo miglio.

AUTENTICAZIONE RICHIESTA

END USER Server MCP Utente

Per gli assistenti IA utilizzati dai tuoi clienti. Incolla la configurazione e la tua IA può tracciare pacchi istantaneamente — nessun codice necessario.

ENDPOINT

https://api.superlabel.ca/mcp

Strumenti disponibili (47 tool live)

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

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

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

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 — agente ops con profilo ristretto
{
  "mcpServers": {
    "superroute": {
      "type": "url",
      "url": "https://api.superlabel.ca/mcp",
      "headers": {
        "Authorization": "Bearer <token>",
        "X-MCP-Profile": "ops-readonly"
      }
    }
  }
}

DEVELOPER Server MCP Sviluppatore

Per gli assistenti di codifica IA (Claude Code, Cursor, ecc.) che ti aiutano a costruire integrazioni Superroute. La tua IA può chiamare direttamente le API, testare gli endpoint e generare codice di integrazione.

ENDPOINT

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

Strumenti disponibili (25 tool live)

track_package Traccia pacco tramite numero di tracciamento PUBBLICO

get_operation_events Ottieni la cronologia di audit dell'ordine AUTH

get_shipping_methods Elenco corrieri disponibili AUTH

get_shipping_rate Ottieni preventivo tariffa di spedizione AUTH

create_shipping_label Crea etichetta di spedizione AUTH

get_shipping_label Dettagli etichetta e info download AUTH

create_order Crea ordine di consegna/ritiro AUTH

build_route Costruire percorsi di consegna ottimizzati 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... PUBBLICO

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

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... PUBBLICO

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

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

get_integration_guide Ottieni guida all'integrazione PUBBLICO

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

get_webhook_guide Guida integrazione webhook PUBBLICO

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

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 — Bearer di connessione preferito
{
  "mcpServers": {
    "superroute-dev": {
      "type": "url",
      "url": "https://api.superlabel.ca/mcp/developer",
      "headers": {
        "Authorization": "Bearer <token>"
      }
    }
  }
}

Dopo 2026-12-31 non passare api_token negli argomenti. Usa Authorization sulla connessione MCP.

User MCP serve a gestire Superroute con agenti; Developer MCP a costruire integrazioni. Il modello completo è nella colonna MCP. Apri colonna MCP →

AI Endpoint di rilevamento strumenti

Descrizioni delle funzionalità strutturate per agenti AI, sistemi di chiamata di strumenti LLM e client MCP. Tutti gli endpoint sono pubblici, non è richiesta alcuna autenticazione.

PRIMARY AI Manifesto degli strumenti

Manifesto completo con definizioni di strumenti, schemi, informazioni di autenticazione e flussi di lavoro.

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

Disponibile anche: /llms.txt

FORMAT Esportazione multiformato

Ottieni le definizioni degli strumenti nel formato nativo della tua piattaforma AI.

# 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 Estensioni

Specifiche OpenAPI arricchite con estensioni x-ai-* (nomi degli strumenti, quando utilizzare, categorie).

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

GQL GraphQL + AI Suggerimenti

Documenti GraphQL arricchiti con aiHints per operazione (quando utilizzare, flussi di lavoro correlati).

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

Integrazione rapida

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
)

Pitone (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 (recupera)

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

Riepilogo delle funzionalità: Per una panoramica leggera (solo categorie e nomi di strumenti), utilizzare GET https://api.superlabel.ca/api/ai/capabilities

AI Strumenti Parco giochi

Prova gli strumenti Superroute AI direttamente nel tuo browser. Seleziona uno strumento, inserisci i parametri e visualizza la risposta API in tempo reale.

Seleziona Strumento

track_package

Corpo richiesta ( JSON )

Risposta

Fare clic su "Esegui" per eseguire lo strumento...

Sviluppa con REST o GraphQL

Per sviluppatori che costruiscono agenti IA personalizzati, chatbot o integrazioni programmatiche. Chiama la nostra API direttamente dal tuo codice con accesso completo a tutte le funzionalità logistiche.

REST Endpoint REST API

# Traccia pacco (pubblico)
GET https://api.superlabel.ca/api/v1/tracking/{number}

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

# Ottieni tariffa di spedizione
POST https://api.superlabel.ca/api/v1/labelservice/rate

# Crea etichetta di spedizione
POST https://api.superlabel.ca/api/v1/labelservice/submitOrder

# Crea ordine di consegna
POST https://api.superlabel.ca/api/v1/client/orderCreate

# Costruisci percorso ottimizzato
POST https://api.superlabel.ca/api/v3/client/build-route

# Configura i webhook
PUT https://api.superlabel.ca/api/v1/webhook-settings

# Cronologia di tracciamento aperta (OTEP)
GET https://api.superlabel.ca/api/v1/otep/trackings/{number}

Documentazione completa

GQL Operazioni GraphQL

# Endpoint singolo
POST https://api.superlabel.ca/api/graphql

# Operazioni disponibili
trackingPublic       ← Traccia pacco (pubblico)
trackingOperationevents ← Eventi operativi
labelserviceRate      ← Ottieni tariffa di spedizione
labelserviceSubmitOrder ← Crea etichetta di spedizione
clientOrderCreate     ← Crea ordine di consegna
clientBuildRoute      ← Costruisci percorso ottimizzato
webhookSettingsUpdate ← Configura i webhook
otepTracking          ← Cronologia di tracciamento aperta (OTEP)

Documentazione completa

Raccomandiamo la REST API per la maggior parte delle integrazioni IA — è più facile da debuggare e ogni endpoint è autonomo. Usa GraphQL quando hai bisogno di query flessibili o vuoi recuperare dati annidati in una singola richiesta.

Competenza di integrazione Superroute IA

Un file di competenze completo con conoscenza approfondita del dominio logistico — cosa fa ogni API, quando usarla, cosa significano i parametri nel contesto aziendale reale, come interpretare i risultati e come le funzionalità si combinano.

Scarica file di competenze (.md)

Come usare il file di competenze

Claude Code

1 Scarica il file sopra
2 Posizionalo nella directory .claude/skills/ del tuo progetto
3 Digita /integrate in Claude Code per avviare la procedura guidata interattiva

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

Cursor

1 Scarica il file sopra
2 Posizionalo nella directory .cursor/rules/ del tuo progetto
3 Cursor lo utilizzerà automaticamente come contesto quando chiederai dell'integrazione Superroute

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

Altri strumenti IA

1 Scarica il file sopra
2 Incolla il contenuto nel prompt di sistema o nella base di conoscenza del tuo strumento IA
3 L'IA utilizzerà le descrizioni semantiche per guidare l'integrazione

# O incolla nel prompt di sistema
cat superroute-ai-integration.md

Mantieni aggiornato il file skill

RAPIDO Aggiornamento con un comando

Scarica l'ultima versione del file skill direttamente dal server.

# 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 API di verifica versione

Controlla l'ultima versione sul server prima di scaricare. Confronta l'hash con il tuo file locale.

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

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

MCP Aggiornamento automatico via MCP

Se hai connesso il server MCP sviluppatore, il tuo assistente IA può verificare gli aggiornamenti usando lo strumento check_skill_update. Passa l'hash MD5 del tuo file locale.

// Chiamata via server MCP sviluppatore
{
  "method": "tools/call",
  "params": {
    "name": "check_skill_update",
    "arguments": { "current_hash": "your_local_file_md5_hash" }
  }
}

CRON Script di aggiornamento automatico (Cron / CI)

Aggiungi questo script alla tua pipeline CI o attività cron per mantenere il file skill sempre aggiornato.

#!/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

Il file di competenze va oltre la documentazione API — insegna al tuo assistente IA il significato aziendale di ogni parametro, come interpretare le risposte e come combinare le funzionalità per flussi logistici complessi.

Esempi di codice

REST REST API — Traccia pacco

Traccia pacco (nessun token necessario)

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

Traccia pacco (nessun token necessario)

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

Traccia pacco (nessun token necessario)

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

Traccia pacco (nessun token necessario)

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

Traccia pacco (nessun token necessario)

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

Traccia pacco (nessun token necessario)

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

Traccia pacco (nessun token necessario)

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

GQL GraphQL — Query ordini

Query ordini

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 } } }"}'

Query ordini

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

Query ordini

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

Query ordini

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)

Query ordini

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

Query ordini

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

Query ordini

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 — Traccia pacco