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 hébergés en Europe. Pointez votre SDK ou client HTTP existant vers l'URL de base ci-dessous, authentifiez-vous avec une clé API de votre dashboard, et chaque modèle en ligne est disponible via le même endpoint — chacun étiqueté souverain UE ou accès rapide, 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.

Machine-readable OpenAPI spec: /openapi.json (OpenAPI 3.1).

https://getfrontiereai.eu/api/v1

Deux endpoints :

Authentification

Chaque appel au endpoint de chat 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. Si une clé fuite, révoquez-la 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 librairie 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, par le même routage UE, au 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, pas sur nos serveurs, tant que vous ne synchronisez pas explicitement un fil sur votre compte.

Ouvrir la console →

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 supporte pas 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 « coming soon ». Chaque entrée porte les champs OpenAI (id, object, created, owned_by), context_length et pricing (prix client en euros par million de tokens, en entrée et en sortie) quand ils sont vérifiés, plus quatre champs propres à Frontière AI : status ("live" ou "coming-soon"), sovereign (booléen), tool_calling (booléen, présent uniquement là où nous l'avons mesuré par un appel réel — filtrez dessus avant de bâtir un agent) et note (avertissement d'usage, quand il y en a un).

{
  "object": "list",
  "data": [
    {
      "id": "glm-5.2",
      "object": "model",
      "created": 1786022547,
      "owned_by": "Zhipu / Z.ai",
      "label": "GLM-5.2 (Zhipu/Z.ai)",
      "provider": "scaleway",
      "status": "live",
      "sovereign": true,
      "tool_calling": true,
      "pricing": {
        "currency": "EUR",
        "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."
    }
  ]
}

sovereign: true signifie que la société qui exploite l'infrastructure n'a aucun contrôle capitalistique ou juridictionnel non-UE (principe SecNumCloud) — OVHcloud, Scaleway, ou serveurs UE dédiés. Les modèles servis via une infrastructure américaine (même en région UE) sont étiquetés accès rapide, jamais souverain — vous filtrez à chaque appel, en toute connaissance de cause.

Les prix au token de chaque modèle en ligne sont listés sur le catalogue de modèles. Appeler un modèle « coming soon » 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.

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 telles quelles, avec leur statut et leur corps d'origine — ce que vous obtiendriez en appelant le provider directement.

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. Pas d'abonnement, pas de carte enregistrée, pas de facture en fin de mois — quand le solde atteint zéro, les appels renvoient 402 et rien d'autre ne se passe.

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.

Modèles de raisonnement

glm-5.2 et kimi-k3 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-m3",
    "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.

Serveur MCP

Frontière AI expose un endpoint Model Context Protocol (MCP) qui donne aux agents IA (Claude Code, Codex, Cursor, Roo Code, 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 stateless : 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 et de solde en exigent une.

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 live via un provider de recherche UE). Une page dédiée détaille l'installation et chaque outil.

https://getfrontiereai.eu/api/mcp

Transport: POST with application/json — JSON-RPC 2.0, stateless (no SSE, no sessions).

Available tools

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 :

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

FAQ