Documentation

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

L'API Frontière 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.

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

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 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. Chaque entrée porte les champs OpenAI (id, object) plus trois champs propres à Frontière : status ("live" ou "coming-soon"), sovereign (booléen) et note (avertissement d'usage, quand il y en a un).

{
  "object": "list",
  "data": [
    {
      "id": "glm-5.2",
      "object": "model",
      "label": "GLM-5.2 (Zhipu/Z.ai)",
      "provider": "scaleway",
      "status": "live",
      "sovereign": true,
      "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 est prépayé : vous rechargez un solde (dès 20 €, 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.

FAQ