DEVELOPER

Centre Développeur

Tout ce dont vous avez besoin pour intégrer notre plateforme — REST, GraphQL et MCP.

REST /api/v1/orders JSON
GQL query { orders { id } } GraphQL
MCP track_package(number) Tool
Centre Développeur

Documentation REST API

Explorez, testez et intégrez nos endpoints RESTful. Interface Swagger UI complète avec constructeur de requêtes interactif et support d'authentification.

Documentation GraphQL API

Interrogez exactement les données dont vous avez besoin avec notre API GraphQL. Playground interactif avec explorateur de schéma et tests d'opérations.

Colonne MCP

Agents IA et clients MCP : configuration, profils de sécurité, approbations et outils live.

Guides d’intégration

Quatre parcours autonomes. Chacun est complet à lui seul : s’authentifier, tarifer, réserver, étiquette ou payer, suivi, et une liste de tests. Restez sur le parcours que vous avez ouvert.

Expédition

Enlèvement et livraison (flotte propre)

Créer une commande d’enlèvement ou de livraison, imprimer l’étiquette locale, suivre et recevoir les événements — flotte propre, de bout en bout. Le tarif est facultatif.

Enlèvement ou livraison → étiquette locale → suivi → événements

Étiquettes transporteur

Lister les modes d’expédition, obtenir un tarif, réserver une étiquette transporteur, télécharger le PDF et suivre l’envoi.

Modes → tarif → acheter → PDF → suivi

Services d’expédition

Utiliser les services d’expédition de l’entreprise : lister, estimer, commander, payer et suivre.

Prestations → estimation → créer → payer → suivi

Stockage et expédition

Entreposer des marchandises, payer, puis les expédier sur ce parcours.

Stocker → payer → choisir → expédier → suivi

Colonne MCP

MCP 47 tools

Guide dédié aux agents IA et clients MCP : serveurs User vs Developer, profils least-privilege, dry-run, approbations et catalogue live.

Profils et scopes Approbations humaines Écritures dry-run Developer MCP

Webhooks — Guide d'Intégration des Webhooks

Recevez les événements en temps réel de Superroute — commandes, changements de statut, mises à jour de suivi. Avec charges utiles signées, nouvelles tentatives automatiques et débogueur intégré.

WEBHOOKS

OTEP — Protocole d'événement de suivi ouvert

Un seul événement. Des trajets infinis. — La livraison en propre, la livraison par des tiers et les expéditions transporteur fusionnent en une seule chronologie d'événements ordonnée par numéro de suivi.

OTEP

Guide des nouveautés d’intégration

Toutes les nouveautés de l’API et des webhooks — annulation idempotente, flux de réconciliation, signatures v2, nouveaux événements — avec des exemples prêts à copier. Le tout entièrement rétrocompatible.

NEW

Postman Collection

Collection toujours à jour, générée en direct depuis la documentation de l’API — importez-la dans Postman et commencez à appeler l’API.

JSON

Dictionnaire et flux des statuts de commande

Le dictionnaire complet des statuts de commande et les diagrammes de transition, générés en direct depuis le code déployé.

MARKDOWN

Codes d’événements de suivi

Codes d’événements de suivi (côté ramassage et livraison), mapping OTEP, flux courants et guide pour créer votre page de suivi avec l’API publique.

TRACKING

Démarrage rapide

1
Obtenir votre token API

Connectez-vous et accédez à Paramètres → Clés API pour générer votre jeton d'accès personnel.

2
Choisir votre API

Utilisez REST pour les opérations CRUD standard, GraphQL pour des requêtes de données flexibles, ou MCP pour connecter des assistants IA à vos données logistiques.

3
Commencer à développer

Ouvrez la documentation interactive pour tester les endpoints dans le navigateur, puis copiez les extraits de code dans votre application.

Authentification

Les trois APIs utilisent le même token Bearer (obtenu via le endpoint de connexion). Certains endpoints sont publics et ne nécessitent pas d'authentification — y compris la connexion, le suivi public et l'auto-inscription des chauffeurs.

Obtenez un token via l'endpoint de connexion :

# POST /api/v1/user/login
{ "email": "you@example.com", "password": "••••••••" }

En-tête de requête

Authorization: Bearer YOUR_ACCESS_TOKEN
REST Requis pour la plupart des endpoints. La connexion, le suivi public et l'auto-inscription des chauffeurs sont publics (pas de token nécessaire).
GQL Requis pour les opérations authentifiées. Les opérations publiques (connexion, suivi) fonctionnent sans token.
MCP Facultatif. Les outils publics fonctionnent sans token ; un token valide débloque l'accès aux données personnalisées.
URLs de base

 

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

Quelle API utiliser ?

REST API

Opérations CRUD standard, webhooks, gestion des commandes/itinéraires

GraphQL

Requêtes flexibles, rapports personnalisés, requêtes imbriquées

MCP

Intégration d'assistant IA (Claude, Cursor, Copilot, etc.)

Intégration IA

Donnez à votre assistant IA des super-pouvoirs logistiques. Connectez-vous via MCP sans code, appelez notre API directement depuis votre agent IA, ou téléchargez le fichier de compétences pour un guide sémantique complet.

Capacités disponibles
Suivi public

Consultez le statut de livraison, la chronologie des événements et la preuve de livraison (signature/photo) de n'importe quel colis par numéro de suivi.

PUBLIC
Événements d'opération

Obtenez la piste d'audit complète des commandes — qui a changé quel statut, quand, où, avec coordonnées GPS et photos jointes.

AUTHENTIFICATION REQUISE
Service d'étiquettes

Obtenez des devis d'expédition auprès des transporteurs, créez des étiquettes d'expédition, téléchargez les PDF d'étiquettes, annulez des envois et soumettez des manifestes de fin de journée.

AUTHENTIFICATION REQUISE
Livraison locale

Créez des commandes de livraison/collecte, construisez des itinéraires optimisés multi-chauffeurs et gérez le flux complet de livraison du dernier kilomètre.

AUTHENTIFICATION REQUISE
END USER Serveur MCP Utilisateur

Pour les assistants IA utilisés par vos clients. Collez la configuration et votre IA peut suivre les colis instantanément — aucun code nécessaire.

ENDPOINT
https://api.superlabel.ca/mcp
Outils disponibles (47 outils live)
track_package Track a package by its tracking number. Returns delivery status, trackin... PUBLIC
otep_tracking Get the unified OTEP (Open Tracking Event Protocol) timeline for a track... PUBLIC
get_capabilities List MCP tools available to the current connection, with risk level, req... PUBLIC
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 — agent ops à profil restreint { "mcpServers": { "superroute": { "type": "url", "url": "https://api.superlabel.ca/mcp", "headers": { "Authorization": "Bearer <token>", "X-MCP-Profile": "ops-readonly" } } } }
DEVELOPER Serveur MCP Développeur

Pour les assistants de codage IA (Claude Code, Cursor, etc.) qui vous aident à construire des intégrations Superroute. Votre IA peut appeler directement les APIs, tester les endpoints et générer du code d'intégration.

ENDPOINT
https://api.superlabel.ca/mcp/developer
Outils disponibles (25 outils live)
track_package Suivre un colis par numéro de suivi PUBLIC
get_operation_events Obtenir la piste d'audit de la commande AUTH
get_shipping_methods Lister les transporteurs disponibles AUTH
get_shipping_rate Obtenir un devis de tarif d'expédition AUTH
create_shipping_label Créer une étiquette d'expédition AUTH
get_shipping_label Obtenir les détails et le téléchargement du bordereau AUTH
create_order Créer une commande de livraison/collecte AUTH
build_route Construire des tournées optimisées 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... PUBLIC
get_graphql_operations Search the Superroute GraphQL catalog — every query and mutation, grouped by category, each with... PUBLIC
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... PUBLIC
validate_otep_payload Run an OTEP document or event through the live conformance validator (POST /api/v1/otep/validate... PUBLIC
check_skill_update Check if a newer version of the Superroute AI integration skill file is available. Returns curre... PUBLIC
get_integration_guide Obtenir le guide d'intégration PUBLIC
get_otep_guide Get the OTEP (Open Tracking Event Protocol) development guide — the What/When/Where/Why event mo... PUBLIC
get_webhook_guide Guide d’intégration webhook PUBLIC
verify_webhook_signature Verify whether an incoming webhook signature is valid. Pass the raw payload (string or JSON obje... PUBLIC
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 de connexion préféré { "mcpServers": { "superroute-dev": { "type": "url", "url": "https://api.superlabel.ca/mcp/developer", "headers": { "Authorization": "Bearer <token>" } } } }

Après 2026-12-31, ne passez pas api_token en argument. Utilisez Authorization sur la connexion MCP.

User MCP sert à gérer Superroute avec des agents ; Developer MCP à construire des intégrations. Le modèle complet est dans la colonne MCP. Ouvrir la colonne MCP →
AI Points de terminaison de découverte d'outils

Descriptions structurées des fonctionnalités pour les agents AI, les systèmes d'appel d'outils LLM et les clients MCP. Tous les points de terminaison sont publics, aucune authentification n'est requise.

PRIMARY Manifeste des outils AI

Manifeste complet avec définitions d'outils, schémas, informations d'authentification et flux de travail.

GET https://api.superlabel.ca/api/.well-known/ai-tools.json
Également disponible: /llms.txt
FORMAT Exportation multiformat

Obtenez des définitions d'outils au format natif de votre plateforme 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 Extensions OpenAPI + AI

Spécification OpenAPI enrichie avec les extensions x-ai-* (noms des outils, quand les utiliser, catégories).

GET https://api.superlabel.ca/api/ai/tools/openapi
GQL GraphQL + AI Astuces

Documents GraphQL enrichis de aiHints par opération (quand utiliser, workflows associés).

GET https://api.superlabel.ca/api/ai/tools/graphql
Intégration rapide
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 (récupérer)
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`);
Résumé des fonctionnalités : Pour un aperçu léger (uniquement les catégories et les noms d'outils), utilisez GET https://api.superlabel.ca/api/ai/capabilities
AI Outils Aire de jeux

Testez les outils Superroute AI directement dans votre navigateur. Sélectionnez un outil, remplissez les paramètres et voyez la réponse API en direct.

Sélectionner un outil
track_package
Réponse
Cliquez sur "Exécuter" pour exécuter l'outil...
Développez avec REST ou GraphQL

Pour les développeurs construisant des agents IA personnalisés, des chatbots ou des intégrations programmatiques. Appelez notre API directement depuis votre code avec un accès complet à toutes les capacités logistiques.

REST Points de terminaison REST API
# Suivre un colis (public) GET https://api.superlabel.ca/api/v1/tracking/{number} # Événements d'opération POST https://api.superlabel.ca/api/v1/tracking/operationevents # Obtenir un tarif d'expédition POST https://api.superlabel.ca/api/v1/labelservice/rate # Créer une étiquette d'expédition POST https://api.superlabel.ca/api/v1/labelservice/submitOrder # Créer une commande de livraison POST https://api.superlabel.ca/api/v1/client/orderCreate # Construire un itinéraire optimisé POST https://api.superlabel.ca/api/v3/client/build-route # Configurer les webhooks PUT https://api.superlabel.ca/api/v1/webhook-settings # Chronologie de suivi ouverte (OTEP) GET https://api.superlabel.ca/api/v1/otep/trackings/{number}
Documentation complète
GQL Opérations GraphQL
# Point de terminaison unique POST https://api.superlabel.ca/api/graphql # Opérations disponibles trackingPublic ← Suivre un colis (public) trackingOperationevents ← Événements d'opération labelserviceRate ← Obtenir un tarif d'expédition labelserviceSubmitOrder ← Créer une étiquette d'expédition clientOrderCreate ← Créer une commande de livraison clientBuildRoute ← Construire un itinéraire optimisé webhookSettingsUpdate ← Configurer les webhooks otepTracking ← Chronologie de suivi ouverte (OTEP)
Documentation complète
Nous recommandons l'API REST pour la plupart des intégrations IA — elle est plus facile à déboguer et chaque endpoint est autonome. Utilisez GraphQL quand vous avez besoin de requêtes flexibles ou souhaitez récupérer des données imbriquées en une seule requête.
Compétence d'intégration Superroute IA

Un fichier de compétences complet avec une connaissance approfondie du domaine logistique — ce que fait chaque API, quand l'utiliser, ce que les paramètres signifient dans un contexte métier réel, comment interpréter les résultats et comment les capacités se combinent.

Télécharger le fichier de compétences (.md)
Comment utiliser le fichier de compétences
Claude Code
  • 1 Téléchargez le fichier ci-dessus
  • 2 Placez-le dans le répertoire .claude/skills/ de votre projet
  • 3 Tapez /integrate dans Claude Code pour lancer l'assistant interactif
mkdir -p .claude/skills cp superroute-ai-integration.md .claude/skills/
Cursor
  • 1 Téléchargez le fichier ci-dessus
  • 2 Placez-le dans le répertoire .cursor/rules/ de votre projet
  • 3 Cursor l'utilisera automatiquement comme contexte lorsque vous poserez des questions sur l'intégration Superroute
mkdir -p .cursor/rules cp superroute-ai-integration.md .cursor/rules/
Autres outils IA
  • 1 Téléchargez le fichier ci-dessus
  • 2 Collez le contenu dans le prompt système ou la base de connaissances de votre outil IA
  • 3 L'IA utilisera les descriptions sémantiques pour guider l'intégration
# Ou collez dans le prompt système cat superroute-ai-integration.md
Gardez votre fichier de compétences à jour
RAPIDE Mise à jour en une commande

Téléchargez la dernière version du fichier de compétences directement depuis le serveur.

# 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 de vérification de version

Vérifiez la dernière version sur le serveur avant de télécharger. Comparez le hash avec votre fichier local.

GET https://api.superlabel.ca/api/ai-skill/version Réponse : { "version": "1.0.0", "hash": "abc123...", "download_url": "..." }
MCP Mise à jour automatique via MCP

Si vous avez connecté le serveur MCP développeur, votre assistant IA peut vérifier les mises à jour avec l'outil check_skill_update. Transmettez le hash MD5 de votre fichier local.

// Appel via le serveur MCP développeur { "method": "tools/call", "params": { "name": "check_skill_update", "arguments": { "current_hash": "your_local_file_md5_hash" } } }
CRON Script de mise à jour automatique (Cron / CI)

Ajoutez ce script à votre pipeline CI ou tâche cron pour garder le fichier de compétences toujours à jour.

#!/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
Le fichier de compétences va au-delà de la documentation API — il enseigne à votre assistant IA la signification métier de chaque paramètre, comment interpréter les réponses et comment combiner les capacités pour des flux logistiques complexes.

Exemples de code

REST REST API — Suivre un colis
Suivre un colis (pas de token nécessaire)
curl https://api.superlabel.ca/api/v1/tracking/SR123456
Suivre un colis (pas de token nécessaire)
<?php $res = (new \GuzzleHttp\Client())->get('https://api.superlabel.ca/api/v1/tracking/SR123456'); print_r(json_decode($res->getBody(), true));
Suivre un colis (pas de token nécessaire)
import requests res = requests.get('https://api.superlabel.ca/api/v1/tracking/SR123456') print(res.json())
Suivre un colis (pas de token nécessaire)
resp, _ := http.Get("https://api.superlabel.ca/api/v1/tracking/SR123456") var result map[string]interface{} json.NewDecoder(resp.Body).Decode(&result)
Suivre un colis (pas de token nécessaire)
const res = await fetch('https://api.superlabel.ca/api/v1/tracking/SR123456'); const data = await res.json();
Suivre un colis (pas de token nécessaire)
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());
Suivre un colis (pas de token nécessaire)
require 'net/http' puts Net::HTTP.get(URI('https://api.superlabel.ca/api/v1/tracking/SR123456'))
GQL GraphQL — Interroger les commandes
Interroger les commandes
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 } } }"}'
Interroger les commandes
$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));
Interroger les commandes
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())
Interroger les commandes
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)
Interroger les commandes
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();
Interroger les commandes
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());
Interroger les commandes
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 — Suivre un colis
Suivre un colis (sans token requis)
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"}}}'
Suivre un colis (sans token requis)
$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));
Suivre un colis (sans token requis)
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())
Suivre un colis (sans token requis)
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)
Suivre un colis (sans token requis)
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();
Suivre un colis (sans token requis)
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());
Suivre un colis (sans token requis)
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