Comment utiliser l'API ERNIE 5.1 ?

ERNIE 5.1 a été lancé le 9 mai 2026, et en moins d'une semaine, l'API Qianfan était opérationnelle pour celui-ci. Si vous souhaitez appeler le modèle depuis votre propre code, y acheminer des appels d'outils, ou l'intégrer à une boucle d'agent avec Apidog, ce guide vous montre le chemin complet : compte, clé, corps de requête, streaming, utilisation d'outils, gestion des erreurs.

Nous resterons pratiques. À la fin, vous aurez des extraits curl, Python et Node fonctionnels, ainsi qu'une collection de requêtes que vous pourrez importer dans Apidog.

Si vous n'avez pas encore lu l'analyse du lancement d'ERNIE 5.1, parcourez-la d'abord ; elle couvre les benchmarks et les compromis par rapport à DeepSeek V4 et Kimi K2.6. Cet article est le complément d'implémentation.

Étape 1 : Obtenir une clé API Qianfan

ERNIE 5.1 est servi via la plateforme Qianfan de Baidu Intelligent Cloud. Il n'y a pas d'« API ERNIE » séparée ; tout passe par Qianfan.

Rendez-vous sur cloud.baidu.com et créez un compte Baidu Intelligent Cloud ou connectez-vous. Les développeurs internationaux peuvent s'inscrire par e-mail ; certaines fonctionnalités d'entreprise nécessitent toujours un numéro de téléphone chinois.
Ouvrez la console Qianfan à l'adresse console.bce.baidu.com/qianfan.
Sous Gestion des clés API (API Key 管理), cliquez sur Créer une clé API. Choisissez l'espace de travail et accordez l'accès au service de complétions de chat.
Copiez la clé. Elle ressemble à bce-v3/ALTAK-xxxx/xxxx. Stockez-la dans une variable d'environnement, pas dans le code source.

export QIANFAN_API_KEY="bce-v3/ALTAK-xxxx/xxxx"

Deux choses à savoir d'emblée. Premièrement, le nouveau point de terminaison v2 utilise un seul jeton Bearer ; le flux OAuth access_token v1, plus ancien, est en cours de dépréciation et vous ne devriez pas construire de nouveau code dessus. Deuxièmement, ERNIE 5.1 est un modèle payant dès le premier jour. Rechargez un petit solde (10 ¥ suffisent pour tester) avant votre première requête.

Étape 2 : Atteindre le point de terminaison compatible OpenAI avec curl

Qianfan expose un point de terminaison de complétions de chat compatible OpenAI, de sorte que tout élément de votre pile qui comprend déjà le format d'OpenAI fonctionnera avec un simple échange d'URL de base et un changement d'ID de modèle.

URL de base : https://qianfan.baidubce.com/v2 ID du modèle : ernie-5.1 (également : ernie-5.1-preview pour les fonctionnalités en accès anticipé)

Requête minimale viable :

curl https://qianfan.baidubce.com/v2/chat/completions \
  -H "Authorization: Bearer $QIANFAN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "ernie-5.1",
    "messages": [
      {"role": "system", "content": "You are a senior API designer."},
      {"role": "user", "content": "Sketch a REST schema for a GitHub-style PR review API. Be concise."}
    ],
    "temperature": 0.3
  }'

Vous recevez une réponse au format OpenAI standard :

{
  "id": "chatcmpl-...",
  "object": "chat.completion",
  "created": 1746780000,
  "model": "ernie-5.1",
  "choices": [
    {
      "index": 0,
      "message": { "role": "assistant", "content": "..." },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 42,
    "completion_tokens": 318,
    "total_tokens": 360
  }
}

Si vous voyez 401 Unauthorized, votre clé est incorrecte ou a expiré. Si vous voyez 403, la clé est valide mais le modèle n'est pas activé sur cet espace de travail ; retournez à la console et ajoutez ERNIE 5.1 aux modèles autorisés de l'espace de travail.

Étape 3 : Appeler ERNIE 5.1 depuis Python

Étant donné que le point de terminaison est compatible OpenAI, le SDK Python officiel openai fonctionne tel quel. Il suffit de le pointer vers Qianfan.

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["QIANFAN_API_KEY"],
    base_url="https://qianfan.baidubce.com/v2",
)

response = client.chat.completions.create(
    model="ernie-5.1",
    messages=[
        {"role": "system", "content": "You explain APIs in plain English."},
        {"role": "user", "content": "Why would I use server-sent events over WebSockets for a chat UI?"},
    ],
    temperature=0.4,
)

print(response.choices[0].message.content)
print(f"\nTokens used: {response.usage.total_tokens}")

Si vous avez déjà des wrappers autour du SDK OpenAI dans votre codebase, l'échange d'ERNIE 5.1 pour des tests A/B est un changement d'une seule ligne. La même astuce fonctionne pour l'API de DeepSeek et la plupart des autres fournisseurs de modèles chinois.

Étape 4 : Diffuser des jetons pour les interfaces utilisateur de type chat

Pour toute conversation avec un utilisateur, vous souhaitez le streaming. Définissez stream: true et consommez les événements envoyés par le serveur.

stream = client.chat.completions.create(
    model="ernie-5.1",
    messages=[{"role": "user", "content": "Write a haiku about API versioning."}],
    stream=True,
)

for chunk in stream:
    delta = chunk.choices[0].delta.content
    if delta:
        print(delta, end="", flush=True)

Équivalent Curl pour le débogage :

curl https://qianfan.baidubce.com/v2/chat/completions \
  -H "Authorization: Bearer $QIANFAN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "ernie-5.1",
    "stream": true,
    "messages": [{"role": "user", "content": "Stream a 3-sentence joke."}]
  }' \
  --no-buffer

Le format du flux est identique à celui d'OpenAI : des lignes data: {...} terminées par data: [DONE].

Étape 5 : Utiliser ERNIE 5.1 avec des outils (la partie agentique)

C'est là qu'ERNIE 5.1 justifie son titre de lancement. Le modèle a obtenu un score supérieur à DeepSeek-V4-Pro sur τ³-bench et SpreadsheetBench-Verified, ce qui signifie que l'appel d'outils fonctionne en production, pas seulement dans les démos.

Même schéma que l'appel de fonction OpenAI :

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get current weather for a city.",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {"type": "string", "description": "City name, e.g. Singapore"},
                    "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]},
                },
                "required": ["city"],
            },
        },
    }
]

response = client.chat.completions.create(
    model="ernie-5.1",
    messages=[{"role": "user", "content": "What's the weather in Tokyo right now?"}],
    tools=tools,
    tool_choice="auto",
)

tool_calls = response.choices[0].message.tool_calls
if tool_calls:
    call = tool_calls[0]
    print(f"Model wants to call: {call.function.name}({call.function.arguments})")

Après que votre code exécute l'outil réel, ajoutez le résultat en tant que message de rôle tool et rappelez-le. La boucle se termine lorsque finish_reason == "stop" et tool_calls est vide.

Un piège : ERNIE 5.1 renvoie occasionnellement les arguments d'outils sous forme de JSON sous forme de chaîne de caractères à l'intérieur d'un bloc de code plutôt que sous forme de chaîne JSON propre. Analysez de manière défensive avec json.loads() enveloppé dans un try/except, et si cela échoue, supprimez les délimiteurs ```json avant de réessayer.

Étape 6 : Appeler ERNIE 5.1 depuis Node.js

Intégration directe pour tout projet Node utilisant openai v5+ :

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.QIANFAN_API_KEY,
  baseURL: "https://qianfan.baidubce.com/v2",
});

const completion = await client.chat.completions.create({
  model: "ernie-5.1",
  messages: [
    { role: "user", content: "Return a JSON object with 3 API design tips." },
  ],
  response_format: { type: "json_object" },
});

console.log(completion.choices[0].message.content);

response_format: { type: "json_object" } fonctionne et est fiable. Les schémas JSON stricts (json_schema) sont encore en cours de déploiement sur Qianfan ; vérifiez la forme de la réponse dans le code plutôt que de faire confiance à la contrainte.

Étape 7 : Tester et comparer avec Apidog

Si vous hésitez entre ERNIE 5.1, DeepSeek V4 et Kimi K2.6, ne le faites pas depuis le terminal. Utilisez Apidog pour construire un espace de travail unique avec un dossier par fournisseur, des corps de requête identiques et des environnements enregistrés par clé API.

La configuration en 60 secondes :

Ouvrez Apidog et créez un nouveau projet nommé "LLM bake-off."

Ajoutez un environnement avec QIANFAN_API_KEY, DEEPSEEK_API_KEY, MOONSHOT_API_KEY comme variables.

Créez trois requêtes pointant vers l'URL de base de chaque fournisseur avec model défini respectivement sur ernie-5.1, deepseek-chat et kimi-k2-6.

Épinglez le même tableau messages sur les trois. Utilisez la fonction "Exécuter" d'Apidog pour les déclencher en parallèle et comparer les sorties.

Le niveau gratuit gère cela confortablement. Apidog enregistre l'historique des requêtes par environnement, vous pouvez donc revenir la semaine prochaine et réexécuter la même évaluation exacte par rapport à une nouvelle version du modèle. C'est mieux que de surveiller curl dans un panneau tmux.

Pour en savoir plus sur les tests multi-fournisseurs, consultez Tester les LLM locaux comme des API et notre guide de l'API GLM 5.1.

Tarification, limites de débit et quotas

La tarification publique de Qianfan pour ERNIE 5.1 n'était pas incluse dans l'article de lancement ; consultez la grille tarifaire de la console en direct avant de citer des chiffres en interne. Trois conseils pratiques en attendant :

Les limites de débit par défaut sont définies par espace de travail. Les nouveaux comptes commencent avec un plafond QPS faible. Augmentez-le depuis la console une fois que vous avez terminé les tests.
L'utilisation des jetons apparaît dans la réponse. Le champ usage indique prompt_tokens, completion_tokens et total_tokens par appel. Enregistrez-les par requête ; ne faites pas confiance uniquement au tableau de bord pour la comptabilité des coûts.
La mise en cache n'est pas automatique. Contrairement à Anthropic, Qianfan n'expose pas actuellement de primitive de mise en cache des prompts pour ERNIE 5.1. Si vous avez un prompt système de 2 000 jetons, vous le payez à chaque appel. Concevez votre architecture en conséquence.

Gestion des erreurs qui vous sauveront

Les erreurs que vous rencontrerez en pratique, par ordre de fréquence approximatif :

Statut	Signification	Correction
401	Jeton Bearer incorrect ou expiré	Régénérer depuis la console
403	Modèle non activé sur cet espace de travail	Ajouter ERNIE 5.1 dans la console
429	Limite de débit atteinte	Attendre et réessayer avec gigue (jitter)
400 (`invalid messages`)	Ordre incorrect des rôles de message	Assurer l'alternance utilisateur/assistant
500/502	Problème côté Qianfan	Réessayer une fois ; si persiste, vérifier la page d'état

Enveloppez chaque appel dans une logique de réessai avec un backoff exponentiel plafonné à 3 tentatives. Pour la production, enregistrez le request_id des en-têtes de réponse ; le support de Baidu en aura besoin pour déboguer votre cas.

Un wrapper minimal de type production

Si vous souhaitez intégrer ERNIE 5.1 dans une vraie application dès aujourd'hui, voici le plus petit wrapper qui ne soit pas embarrassant :

import os, time, random, json
from openai import OpenAI, RateLimitError, APIError

client = OpenAI(
    api_key=os.environ["QIANFAN_API_KEY"],
    base_url="https://qianfan.baidubce.com/v2",
)

def chat(messages, *, model="ernie-5.1", temperature=0.3, max_retries=3):
    for attempt in range(max_retries):
        try:
            return client.chat.completions.create(
                model=model,
                messages=messages,
                temperature=temperature,
            )
        except RateLimitError:
            time.sleep((2 ** attempt) + random.random())
        except APIError as e:
            if e.status_code and e.status_code >= 500 and attempt < max_retries - 1:
                time.sleep(1 + attempt)
                continue
            raise
    raise RuntimeError("ERNIE 5.1 retries exhausted")

Cela couvre 80 % des cas. Pour les boucles d'outils et le streaming, construisez par-dessus.

Foire aux questions

L'API ERNIE 5.1 est-elle gratuite ? Non. Qianfan fonctionne selon un modèle de paiement à l'utilisation. Il n'y a pas de niveau gratuit permanent ; les nouveaux comptes reçoivent parfois des crédits d'essai. Pour une expérimentation gratuite, utilisez l'interface de chat ernie.baidu.com ou consultez les options de LLM gratuites.

Puis-je exécuter ERNIE 5.1 localement ? Non. Il n'y a pas de poids publics. Si l'exécution sur site est une exigence stricte, consultez comment exécuter DeepSeek V4 localement ou les meilleurs LLM locaux en 2026 à la place.

Le SDK OpenAI fonctionne-t-il sans modifications ? Oui, avec base_url défini sur https://qianfan.baidubce.com/v2 et api_key défini sur votre clé Qianfan. Le champ model accepte les ID de modèle Qianfan, pas ceux d'OpenAI. L'appel de fonction, le streaming et response_format: json_object fonctionnent tous. La validation stricte json_schema est toujours en cours de déploiement.

Comment ERNIE 5.1 gère-t-il les prompts en chinois et en anglais ? Les deux sont traités de manière prioritaire. Le score Arena Search de 1 223 provient d'un échantillon de votants multilingues. Pour les tâches techniques en anglais (code, conception d'API), il est compétitif avec la frontière fermée ; pour l'écriture créative en chinois, il est le meilleur de sa catégorie parmi les modèles chinois.

Quelle est la longueur de sortie maximale ? Non officiellement publiée. En pratique, les réponses en un seul tour plafonnent à environ 8 000 jetons avant que le modèle ne termine. Pour la génération longue, segmentez et continuez.

Vous construisez un agent sur ERNIE 5.1 ? Téléchargez Apidog et utilisez la collection de requêtes compatible OpenAI pour simuler, tester et documenter le point de terminaison Qianfan parallèlement à vos autres services.