Documentation

Référence de l'API Frontière AI

L'API Frontière AI est une passerelle compatible OpenAI vers un catalogue sélectionné de modèles open-source puissants. Pointez votre SDK ou client HTTP existant vers l'URL de base ci-dessous, authentifiez-vous avec une clé API de votre espace client, et chaque modèle en ligne est disponible via le même endpoint. 18 des 25 modèles en ligne sont souverains UE, exploités par des fournisseurs sous contrôle européen ; les autres sont en accès rapide, exploités par des sociétés américaines — chacun est étiqueté, pour toujours savoir quelle juridiction sert vos données.

Vue d'ensemble

L'API implémente le contrat chat-completions d'OpenAI. Si votre code parle déjà à OpenAI — via le SDK officiel Python ou JavaScript, LangChain, ou un simple client HTTP — vous ne changez que deux choses : l'URL de base et la clé. Une seule clé donne accès à tout le catalogue.

Spécification OpenAPI lisible par machine : /openapi.json (OpenAPI 3.1).

https://getfrontiereai.eu/api/v1

Endpoints :

Authentification

Chaque appel aux endpoints de chat et d'embeddings porte votre clé API dans l'en-tête Authorization. Les clés se créent dans le dashboard, section Clés API — la valeur complète (sk-front-…) n'est affichée qu'une fois à la création, ensuite seulement son préfixe. Créez une clé par environnement ou par application ; chacune se révoque indépendamment sans toucher aux autres.

Authorization: Bearer sk-front-…

Gardez vos clés côté serveur (variables d'environnement, gestionnaire de secrets) — jamais dans du code client ni un dépôt public. En cas de fuite, révoquez la clé depuis le dashboard et créez-en une nouvelle ; l'ancienne cesse de fonctionner immédiatement.

Démarrage rapide

Le même appel en trois langages. Les exemples Python et JavaScript utilisent le SDK OpenAI officiel (pip install openai / npm install openai) — aucune bibliothèque spécifique à Frontière AI n'est nécessaire.

curl https://getfrontiereai.eu/api/v1/chat/completions \
  -H "Authorization: Bearer $FRONTIERE_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "glm-5.2",
    "messages": [{"role": "user", "content": "Bonjour"}]
  }'

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://getfrontiereai.eu/api/v1",
    api_key=os.environ["FRONTIERE_KEY"],
)

reply = client.chat.completions.create(
    model="glm-5.2",
    messages=[{"role": "user", "content": "Bonjour"}],
)
print(reply.choices[0].message.content)

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://getfrontiereai.eu/api/v1",
  apiKey: process.env.FRONTIERE_KEY,
});

const reply = await client.chat.completions.create({
  model: "glm-5.2",
  messages: [{ role: "user", content: "Bonjour" }],
});
console.log(reply.choices[0].message.content);

Essayer un modèle sans écrire de code

Votre espace client contient une console : une fenêtre de discussion sur le même catalogue, avec le même routage par défaut et le même prix au token. Elle sert à répondre à « quel modèle, avec quel prompt système et quels paramètres ? » avant de câbler quoi que ce soit — chaque réponse affiche le modèle, le nombre de tokens et le montant exact débité.

Une fois qu'un prompt se comporte comme vous voulez, la console traduit le modèle, les paramètres et le prompt courants en un appel curl, Python ou JavaScript prêt à coller contre cette API. Les conversations restent dans votre navigateur, jamais sur nos serveurs.

Ouvrir la console →

Mode Agent

La console a aussi un interrupteur Agent. Activé, le modèle choisi ne se contente pas de répondre : il mène une tâche pas à pas — recherches web, fichiers, documents, images — jusqu'à ce qu'elle soit faite. Il n'exécute pas de code. Comme le reste de la console, c'est un banc d'essai de cette API, pas une alternative — même catalogue, même prix au token, un plafond de dépense que vous fixez à chaque tour, et le coût exact du tour affiché à sa fin. La conversation et les fichiers de l'agent restent dans votre navigateur.

Ce que l'agent peut faire :

• Chercher sur le web. Il peut chercher et lire des pages web, dans la limite de 40 recherches par tour et 300 par jour. Chaque recherche coûte 0,00756 € et chaque page lue 0,001512 € (TVA comprise), comptés dans le plafond du tour, en plus des tokens de ce que le modèle en lit.
• Écrire et modifier des fichiers. Des fichiers texte de tout genre — Markdown, CSV, JSON, HTML… — dans l'espace de travail du fil, où ils restent pour les tours suivants de la même conversation.
• Créer des documents. Des documents Word (.docx) et PDF à partir de Markdown, et des classeurs Excel (.xlsx). Ils sont produits dans la mémoire de nos serveurs et n'y sont jamais conservés.
• Générer des images. Avec FLUX.1 [schnell], une à la fois et jusqu'à 12 par tour, en carré, paysage ou portrait. Chaque image devient un fichier JPEG de la conversation, affiché en vignette et téléchargeable comme tout autre fichier. Une image est facturée à la seconde de génération, comme l'API d'images — environ 0,02 € pour une image carrée.
• Vous remettre ses fichiers. Chaque fichier que l'agent écrit se télécharge depuis la conversation, un à la fois. Les fichiers sont gardés dans votre navigateur, avec la conversation.

Limites :

• Modèles. Seuls les modèles qui savent appeler des outils peuvent mener un tour d'agent ; la page Intégrations montre lesquels. Choisissez le modèle vous-même : le mode Agent n'est pas disponible avec Auto.
• Un tour à la fois. Par compte. Un tour compte 40 étapes au plus et n'en commence plus après 10 minutes ; « Continuer » reprend dans un nouveau tour.
• Pas de code. L'agent ne peut ni exécuter de code, ni installer de logiciel, ni atteindre votre ordinateur : il ne travaille qu'avec les outils ci-dessus.
• Pièces jointes. Comme dans le chat : le texte des documents que vous joignez est extrait dans votre navigateur et ajouté à votre message, et jusqu'à 4 images peuvent être jointes pour les modèles qui en acceptent. Une requête entière, fichiers de la conversation compris, est limitée à 4 Mo.
• Fichiers. L'espace de travail d'une conversation contient jusqu'à 200 fichiers. Un fichier texte compte jusqu'à 1 000 000 caractères, un document ou une image jusqu'à 5 Mo, et un tour peut produire jusqu'à 25 Mo de fichiers.
• Plafond de dépense. Par tour : 0,50 €, 1 €, 2 €, 5 € ou 10 €. Par défaut 2 €, et un plafond n'est jamais supérieur à votre solde.

Comment fonctionne le plafond. Avant chaque appel au modèle — et chaque image —, le coût maximal que cet appel pourrait atteindre est mis de côté sur le plafond du tour et sur votre solde, puis libéré une fois le coût réel facturé : un appel qui ne tiendrait pas est refusé, ce qui termine le tour. Vous pouvez envoyer un autre message, avec un nouveau plafond, pour continuer. Vous payez le coût réel, jamais le montant mis de côté : un tour reste donc sous son plafond, à une exception près — un fournisseur qui rapporterait plus de sortie que la limite que nous fixons à l'appel. Arrêter un tour n'annule pas ce qui est déjà parti : l'appel au modèle en cours va à son terme et il est facturé, de même qu'une image en cours de génération, même si le tour se termine avant qu'elle arrive dans votre navigateur.

Où vont vos données. Chaque appel au modèle suit la règle du modèle choisi : un modèle souverain UE n'est exécuté que par ses fournisseurs européens, un modèle en accès rapide par une société américaine, et la ligne de coût sous chaque réponse de l'agent nomme les fournisseurs concernés. Ce que l'agent envoie à ce fournisseur comprend le contenu des fichiers qu'il lit et les résultats de ses outils. Quand il génère une image, la description qu'il rédige part chez Infomaniak, société suisse, dans ses propres centres de données en Suisse — hors UE, sous décision d'adéquation de l'UE —, et la ligne de coût l'affiche avec un drapeau suisse. L'agent lui-même tourne dans notre application chez Vercel, société américaine, dans sa région de Paris : vos messages et les fichiers de la conversation y transitent le temps d'un tour et n'y sont jamais stockés. La politique de confidentialité donne le détail.

Le mode Agent n'existe que dans la console web. L'API (/api/v1) n'a pas de mode agent : elle relaie votre requête au modèle, sans jamais enchaîner d'étapes ni d'outils à votre place ni appliquer de plafond par tour. Le serveur MCP n'en a pas non plus.

Chat completions

https://getfrontiereai.eu/api/v1/chat/completions

Envoyez une conversation, recevez la réponse du modèle. Champs du corps de requête :

Le corps de la requête est transmis au provider qui héberge le modèle : les paramètres OpenAI standard se comportent exactement comme documentés par OpenAI. Les champs qu'un provider donné ne prend pas en charge sont ignorés par ce provider.

La réponse est un objet chat.completion standard. Le bloc usage est ce qui est décompté de votre solde — au token près, tokens de raisonnement inclus sur les modèles de raisonnement :

{
  "id": "chatcmpl-…",
  "object": "chat.completion",
  "model": "glm-5.2",
  "choices": [
    {
      "index": 0,
      "message": { "role": "assistant", "content": "Bonjour ! Comment puis-je aider ?" },
      "finish_reason": "stop"
    }
  ],
  "usage": { "prompt_tokens": 9, "completion_tokens": 42, "total_tokens": 51 }
}

Streaming

Passez "stream": true et la réponse arrive en server-sent events — des chunks data: portant le delta incrémental, terminés par data: [DONE]. C'est le même format que chez OpenAI : les helpers de streaming des SDK fonctionnent tels quels.

stream = client.chat.completions.create(
    model="llama-3.3-70b",
    messages=[{"role": "user", "content": "Bonjour"}],
    stream=True,
)
for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="")

Frontière AI active toujours stream_options.include_usage en amont : le dernier chunk data avant [DONE] porte l'objet usage (et un tableau choices vide). C'est ce chunk qui permet de facturer exactement les appels streamés — ne soyez pas surpris de le voir si vous parsez le flux à la main.

Modèles

https://getfrontiereai.eu/api/v1/models

Le catalogue est servi en direct par GET /api/v1/models — public, aucune clé requise. Il ne liste que les modèles en ligne : ce que vous y découvrez est appelable immédiatement ; ajoutez ?include=all pour obtenir aussi les entrées en pause et à venir, et ?kind=chat ou ?kind=embedding pour une seule famille. Chaque entrée porte les champs OpenAI (id, object, created, owned_by) et des champs propres à Frontière AI : kind ("chat" ou "embedding"), label, provider (la route tentée en premier par défaut — celle que nomme x-routed-provider sur un appel normal), status ("live", "paused" ou "coming-soon"), pause (since, reason et reason_fr — présent seulement sur un modèle en pause), sovereign (booléen), providers (la chaîne de routage par ordre de priorité, présente seulement quand un modèle a plusieurs routes ; une route marquée requires_opt_in: true ne sert que si vous autorisez tous les providers — voir Routage des données), compliance (licence, statut AI Act, résidence des données dans l'UE, et data_retention : zero_prompt_retention quand toutes les routes par défaut documentent une rétention nulle (OVHcloud), no_storage_except_errors chez Scaleway (aucun prompt stocké, sauf les requêtes en erreur ou abusives, conservées deux semaines au plus), provider_policy quand la politique de rétention propre à un provider en accès rapide s'applique — Frontière AI, elle, ne stocke aucun prompt ni aucune réponse), verified (les six contrôles Frontière Verified — true une fois le contrôle effectué, consigné et réussi, false sinon (pas encore fait, ou fait sans réussir) ; absent tant qu'aucun contrôle n'a commencé), tool_calling (présent uniquement là où nous l'avons mesuré par un appel réel — filtrez dessus avant de bâtir un agent), context_length et pricing (prix client en euros par million de tokens ; vat_included: true — TVA toujours comprise) quand ils sont vérifiés, et note (avertissement d'usage, quand il y en a un).

{
  "object": "list",
  "data": [
    {
      "id": "glm-5.2",
      "object": "model",
      "kind": "chat",
      "created": 1786022547,
      "owned_by": "Zhipu / Z.ai",
      "label": "GLM-5.2 (Zhipu/Z.ai)",
      "label_fr": "GLM-5.2 (Zhipu/Z.ai)",
      "provider": "scaleway",
      "status": "live",
      "sovereign": true,
      "compliance": {
        "open_weights": true,
        "license": "MIT",
        "license_restricted": false,
        "gpai_status": "gpai",
        "systemic_risk": null,
        "model_card_url": "https://huggingface.co/zai-org/GLM-5.2",
        "training_docs_url": "https://arxiv.org/abs/2602.15763",
        "data_retention": "no_storage_except_errors",
        "eu_data_residency": true
      },
      "verified": {
        "license": true,
        "provenance": true,
        "security": false,
        "gdpr": true,
        "benchmarks": false,
        "api": true
      },
      "tool_calling": true,
      "context_length": 256000,
      "pricing": {
        "currency": "EUR",
        "vat_included": true,
        "input_per_million": 2.52,
        "output_per_million": 7.7
      },
      "note": "Reasoning model — thinks before answering. Omit max_tokens or allow at least ~1,000.",
      "note_fr": "Modèle de raisonnement — réfléchit avant de répondre. Omettez max_tokens ou prévoyez au moins ~1 000."
    }
  ]
}

GET /api/v1/models/{id} renvoie une seule entrée, de même forme — c'est l'appel derrière models.retrieve() dans les SDK OpenAI. Un identifiant inconnu renvoie 404 model_not_found.

sovereign: true signifie que la société qui exploite l'infrastructure n'a aucun contrôle capitalistique ou juridictionnel non-UE (principe SecNumCloud) — aujourd'hui AKI.IO, Infomaniak, Mistral AI, OVHcloud ou Scaleway. Les modèles exploités par des sociétés américaines (Modal et OpenRouter) sont étiquetés accès rapide, jamais souverains, même servis depuis une région UE — vous filtrez à chaque appel, en toute connaissance de cause. Des déploiements UE dédiés à une charge de travail donnée sont possibles sur demande. Le premier modèle prévu sur un serveur UE dédié opéré par Frontière AI — kimi-k3-souverain — figure au catalogue comme à venir ; aucun modèle en ligne n'y tourne encore.

Les prix au token de chaque modèle en ligne sont listés sur le catalogue de modèles. Appeler un modèle à venir renvoie HTTP 409 — et enregistre votre intérêt : demander un modèle est la meilleure façon de voter pour sa priorité. Un identifiant inconnu renvoie 404 avec un renvoi vers le catalogue.

Routage des données

Chaque modèle a une chaîne de routage : un seul provider, ou un provider principal suivi de replis. Deux signaux facultatifs — un en-tête de requête et un réglage par clé — décident des routes qu'un appel peut emprunter :

Modèles souverains en ligne qui ont un repli non souverain (marqué requires_opt_in: true dans GET /api/v1/models) — les seuls que le réglage « Tous les fournisseurs (repli US autorisé) » change : glm-5.3, deepseek-v4.1-flash.

Le réglage par clé se trouve dans votre espace client (Clés API → Sensibilité données), une valeur par clé. Quand l'en-tête et la clé divergent, le plus strict l'emporte : une clé réglée sur « Souverain uniquement » ne peut pas être assouplie par l'en-tête, et chaque appel fait avec elle reste chez des providers souverains.

curl -i https://getfrontiereai.eu/api/v1/chat/completions \
  -H "Authorization: Bearer $FRONTIERE_KEY" \
  -H "Content-Type: application/json" \
  -H "X-Data-Sensitivity: sensitive" \
  -d '{
    "model": "glm-5.2",
    "messages": [{"role": "user", "content": "Bonjour"}]
  }'

Chaque réponse de chat completion qui a atteint un provider — en streaming ou non — porte des en-têtes qui disent où elle a été servie :

HTTP/2 200
content-type: application/json
x-routed-provider: scaleway
x-sovereign: true

Le repli se déclenche quand un provider répond 429, 500, 502, 503 ou 504, ou reste injoignable, et que le modèle a une autre route éligible. Il n'élargit jamais les règles ci-dessus : un appel limité aux providers souverains qui a épuisé ses routes souveraines reçoit l'erreur du provider, jamais une réponse d'une société américaine.

Avec le SDK OpenAI, fixez l'en-tête une fois sur le client et lisez les en-têtes de routage sur la réponse brute (en JavaScript : defaultHeaders et .withResponse()) :

client = OpenAI(
    base_url="https://getfrontiereai.eu/api/v1",
    api_key=os.environ["FRONTIERE_KEY"],
    default_headers={"X-Data-Sensitivity": "sensitive"},
)

raw = client.chat.completions.with_raw_response.create(
    model="glm-5.2",
    messages=[{"role": "user", "content": "Bonjour"}],
)
print(raw.headers.get("x-routed-provider"), raw.headers.get("x-sovereign"))
reply = raw.parse()

L'endpoint REST de chat applique tout ce qui précède. La console web applique la règle par défaut. L'outil MCP chat_completion applique le réglage de votre clé (il ne lit pas l'en-tête). Les réponses d'embeddings portent elles aussi x-routed-provider et x-sovereign, mais jamais les en-têtes de repli : chaque modèle d'embedding est servi par un seul provider, indiqué par ses champs provider et sovereign dans GET /api/v1/models.

Le routage décide quel provider d'inférence traite votre prompt. La passerelle qui le précède tourne à Paris chez Vercel, une société américaine, et ne stocke aucun prompt ni aucune réponse — le détail est sur la page confidentialité.

Erreurs

Les erreurs sont en JSON, au format OpenAI — un objet error avec un message lisible et un type stable sur lequel brancher votre code :

{
  "error": {
    "message": "Insufficient credit balance. Top up your account from the dashboard.",
    "type": "insufficient_credit"
  }
}

Les erreurs côté provider (rate limit, modèle surchargé, paramètre invalide pour ce provider) sont relayées avec leur statut et leur corps d'origine — ce que vous obtiendriez en appelant le provider directement. Si le modèle a une autre route éligible, un 429 ou une erreur 5xx déclenche d'abord un repli (voir Routage des données) ; seule l'erreur de la dernière route vous parvient, avec son corps, et avec Retry-After quand le provider en envoie un. Les refus déterministes, qu'un nouvel essai ne changera pas — 409 model_not_live, 503 model_paused, 503 provider_not_configured et 503 no_sovereign_provider — portent x-should-retry: false, pour que les SDK OpenAI officiels s'arrêtent au lieu de réessayer avec backoff.

Crédit & facturation

Frontière AI est prépayé : vous rechargez un solde (dès 10 €, via Stripe, dans le dashboard) et chaque appel réussi le décrémente. Les prix sont TTC, donc le montant débité est le montant crédité — rien n'est ajouté au moment du paiement. Pas d'abonnement, pas de carte enregistrée, pas de facture de fin de mois.

Les nouveaux appels sont refusés avec un 402 dès que le solde est à zéro ou en dessous. Les appels déjà en cours à ce moment-là — ou lancés au même instant — sont facturés en entier quand le provider rapporte leur usage : le solde peut donc passer légèrement sous zéro, et ce montant est déduit de votre prochaine recharge. Rien n'est jamais prélevé automatiquement sur une carte.

La facturation est exacte au token, calculée depuis l'objet usage que le provider rapporte pour votre appel : les prompt tokens au tarif input du modèle, les completion tokens (tokens de raisonnement inclus) au tarif output. Quand un provider sert une partie de votre prompt depuis son cache et le rapporte (usage.prompt_tokens_details.cached_tokens), ces tokens sont facturés au tarif cache du modèle, moins cher.

Votre dashboard affiche le solde, l'historique de facturation par appel (tokens in/out et prix de chaque appel) et l'historique des recharges. Le prix de chaque appel est débité au moment où le provider renvoie son usage — appels streamés compris, via le chunk usage final.

Les factures de vos recharges sont émises sur demande — le dashboard n'en génère pas. Écrivez à contact@fleeceai.agency en indiquant la date et le montant de la recharge, en ajoutant la raison sociale et le numéro de TVA si la facture est destinée à une entreprise (FLEECE AI SASU, TVA intracommunautaire FR45932329188).

Modèles de raisonnement

Les modèles de raisonnement comme glm-5.2 réfléchissent avant de répondre : cette réflexion consomme des tokens de complétion (facturés en output) avant qu'aucun texte visible ne soit produit. Avec un max_tokens trop petit, tout le budget peut partir en raisonnement — la réponse revient alors avec content: null et finish_reason « length », ce qui ressemble à une réponse vide. Omettez max_tokens ou prévoyez au moins ~1 000.

kimi-k3 tourne en plus à l'échelle zéro entre deux usages : le premier appel après une période d'inactivité peut prendre quelques minutes de préchauffage, ensuite il répond en quelques secondes. Il est servi via une infrastructure américaine et étiqueté accès rapide — vérifiez le champ sovereign si la juridiction compte pour votre usage.

Le raisonnement prend aussi du temps horloge : sur un prompt substantiel, glm-5.2 peut réfléchir plusieurs minutes avant que la réponse complète soit prête. Réglez généreusement le timeout de votre client HTTP (beaucoup d'outils coupent bien avant la minute — le module HTTP de Make.com, par exemple, coupe à 40 secondes si vous ne l'augmentez pas), ou mieux, utilisez le streaming : le premier chunk arrive en moins d'une seconde et la connexion reste active pendant toute la génération.

Embeddings

POST /api/v1/embeddings transforme du texte en vecteurs, avec la même authentification et la même facturation prépayée que le chat. Le corps de requête suit celui d'OpenAI : model, et input sous forme de chaîne ou de tableau de chaînes. La réponse est un objet de type list dont data porte un embedding par entrée, dans l'ordre d'envoi.

curl https://getfrontiereai.eu/api/v1/embeddings \
  -H "Authorization: Bearer $FRONTIERE_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "bge-multilingual-gemma2",
    "input": ["Premier document", "Second document"]
  }'

Les modèles d'embedding forment leur propre catalogue — un modèle de chat envoyé ici répond 404, et un modèle d'embedding envoyé à /chat/completions aussi. GET /api/v1/models?kind=embedding ne rend que les valides ; chaque entrée du catalogue porte par ailleurs un champ kind ("chat" ou "embedding"), de quoi les distinguer en un seul appel.

Choisissez d'abord selon dimensions : la longueur du vecteur fait partie de votre schéma de stockage, et changer de modèle plus tard oblige à recalculer tous les vecteurs conservés. La facturation ne compte que les tokens d'entrée — un embedding ne produit aucun token de sortie, il n'y a donc pas de tarif de sortie.

Images

POST /api/v1/images/generations transforme un prompt en images, avec la même clé et le même crédit prépayé que le chat. Le corps suit celui d'OpenAI : model, prompt, n (de 1 à 5) et size. Les images reviennent en JPEG dans data[].b64_json ; rien n'est hébergé ni conservé chez nous, donc response_format: "url" rend une data URL plutôt qu'un lien. Les SDK OpenAI officiels fonctionnent tels quels (client.images.generate).

curl https://getfrontiereai.eu/api/v1/images/generations \
  -H "Authorization: Bearer $FRONTIERE_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "flux-schnell",
    "prompt": "Un phare au crépuscule, aquarelle",
    "size": "1024x1024"
  }'

POST /api/v1/images/edits sert PhotoMaker V2 : envoyez 1 à 4 photos de visage (JPEG ou PNG) dans image[] en multipart, ou en data URLs base64 dans un tableau images en JSON, avec un prompt contenant le mot déclencheur img juste après le sujet — « a woman img as an astronaut ». Une photo de visage est une donnée personnelle : n'envoyez que des photos que vous avez le droit de traiter. Les deux modèles sont servis par Infomaniak dans ses propres centres de données en Suisse, hors UE mais sous décision d'adéquation de l'UE.

La génération d'images est facturée à la seconde de génération, mesurée par la passerelle autour de l'appel au fournisseur et arrondie à la seconde supérieure — comme notre fournisseur nous facture. Le champ usage.generation_seconds de la réponse est le montant exact facturé. À titre indicatif, mesuré le 7 octobre 2026 : environ 2 secondes pour une image FLUX en 1024×1024, 3 secondes en 1792×1024, 5 à 6 secondes pour un portrait PhotoMaker. Une requête refusée avant l'appel (taille invalide, mot déclencheur absent…) ne coûte rien.

Serveur MCP

Frontière AI expose un endpoint Model Context Protocol (MCP) qui donne aux agents IA (Claude Code, Codex, Cursor, Cline, Continue, etc.) un accès programmatique complet à l'API Frontière AI. Tout client compatible MCP se connecte avec une seule URL et peut parcourir le catalogue, lancer de l'inférence, créer des embeddings et vérifier le solde du compte — le tout en JSON-RPC 2.0 standard.

Connectez le client MCP de votre agent à l'URL de l'endpoint ci-dessous. L'endpoint utilise un HTTP sans état : chaque requête POST est un appel JSON-RPC 2.0 autonome avec une réponse synchrone — pas de flux SSE, pas d'état de session. L'authentification se fait en envoyant votre clé API dans l'en-tête Authorization de chaque requête (ex. Authorization: Bearer sk-front-...). Les outils de lecture (requêtes catalogue) fonctionnent sans clé ; les outils d'inférence, de solde et de recherche web en exigent une. chat_completion suit le réglage de sensibilité des données de votre clé (voir Routage des données).

Le serveur MCP expose huit outils : trois pour la découverte du catalogue (list_models, get_model, search_models — aucune authentification requise) et cinq pour les opérations authentifiées (chat_completion relaie une requête de chat vers la gateway avec facturation au token, create_embedding génère des vecteurs à partir de texte, check_balance renvoie votre solde de crédit actuel, et web_search / web_fetch donnent à l'agent un accès web en direct via un fournisseur de recherche UE). Une page dédiée détaille l'installation et chaque outil.

https://getfrontiereai.eu/api/mcp

Transport : POST en application/json — JSON-RPC 2.0, sans état (ni SSE, ni session).

Outils disponibles

Intégrations

Tout ce qui parle le protocole OpenAI fonctionne en changeant la base URL et la clé — SDK, LangChain, frameworks d'agents, outils no-code. Certaines plateformes demandent quelques étapes spécifiques, et les agents exigent en plus l'appel d'outils, que nous avons mesuré modèle par modèle. Les clients au format Anthropic comme Claude Code appellent POST /api/v1/messages avec la base URL https://getfrontiereai.eu/api — mêmes modèles, même routage, même facturation :

Intégrations : plateformes d'agents, matrice d'appel d'outils, limites connues →

FAQ