BroadRouter
Commencer

Quitter l’API OpenAI : migration pas à pas en Python, Node et cURL

Par l’équipe BroadNet Inference · 6 min de lecture · Publié

Changez l’URL de base, la clé d’API et l’identifiant du modèle du client. Cela suffit pour les appels Chat Completions. Le code de la Responses API doit être réécrit en Chat Completions : input devient messages, output_text devient choices[0].message.content, et les outils perdent un niveau d’imbrication. Gardez les embeddings sur un client séparé si le nouveau fournisseur n’en propose pas, puis lancez un test de fumée avant de basculer le trafic.

Faire passer une application d’OpenAI à un fournisseur compatible OpenAI est une petite modification de code si vous utilisez Chat Completions, et une réécriture si vous utilisez la Responses API. Cet article montre les diffs exacts en Python, Node et cURL, ce qu’il faut faire pour Responses, les outils, la sortie structurée et les embeddings, et un test de fumée à lancer avant de déplacer le moindre trafic. Les exemples utilisent BroadNet Inference à l’adresse https://inference.broadnet.ai/v1 ; les mêmes étapes valent pour n’importe quel fournisseur.

C’est le pendant en code de la checklist de migration, qui couvre les limites de débit, les erreurs et la planification de la bascule. Pour les URL de base d’autres fournisseurs, voir les URL de base compatibles OpenAI, vérifiées.

Qu’est-ce qui change dans la configuration du client ?

Trois valeurs : l’URL de base, la clé d’API et l’identifiant du modèle.

Python

import os
from openai import OpenAI

# before: client = OpenAI()  # reads OPENAI_API_KEY, calls api.openai.com
client = OpenAI(
    base_url="https://inference.broadnet.ai/v1",
    api_key=os.environ["BROADNET_API_KEY"],
)
r = client.chat.completions.create(
    model="broadnet/gemma-4-26b-a4b",          # was e.g. "gpt-..."
    messages=[{"role": "user", "content": "Reply with one short sentence."}],
)
print(r.choices[0].message.content)

Node

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://inference.broadnet.ai/v1",
  apiKey: process.env.BROADNET_API_KEY,
});
const r = await client.chat.completions.create({
  model: "broadnet/gemma-4-26b-a4b",
  messages: [{ role: "user", content: "Reply with one short sentence." }],
});
console.log(r.choices[0].message.content);

cURL

curl https://inference.broadnet.ai/v1/chat/completions \
  -H "Authorization: Bearer $BROADNET_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"broadnet/gemma-4-26b-a4b","messages":[{"role":"user","content":"Reply with one short sentence."}]}'

Attention au chemin : l’URL de base se termine déjà par /v1, et le SDK ajoute /chat/completions. Doubler /v1 est la première erreur la plus fréquente.

Peut-on changer sans toucher au code ?

Oui, pour du code Chat Completions. Le SDK Python lit OPENAI_BASE_URL quand aucune base_url n’est passée, et le client Node prend par défaut baseURL dans process.env['OPENAI_BASE_URL']. Les deux lisent OPENAI_API_KEY. Définir deux variables d’environnement déplace tous les appels.

C’est aussi le risque. Tous les appels partent, y compris les embeddings, la modération, les envois de fichiers et tout ce que le nouveau fournisseur n’a peut-être pas. N’utilisez la bascule par l’environnement que si votre application ne fait que des appels de chat.

Et si mon code utilise la Responses API ?

Les README des SDK d’OpenAI présentent désormais la Responses API comme l’API principale ; le README Python qualifie Chat Completions de « the previous standard (supported indefinitely) » (traduction : « l’ancien standard (pris en charge sans limite de durée) »). Beaucoup de fournisseurs compatibles n’implémentent que Chat Completions. BroadNet documente POST /v1/chat/completions et POST /v1/audio/transcriptions : les appels Responses doivent donc être réécrits. La correspondance :

Responses API Chat Completions
client.responses.create(...) client.chat.completions.create(...)
instructions="..." Premier message {"role": "system", "content": "..."}
input="..." ou une liste d’éléments messages=[...]
response.output_text response.choices[0].message.content
max_output_tokens max_tokens (documentation de BroadNet) ou max_completion_tokens
text={"format": {...}} response_format={...}
previous_response_id, conversations Renvoyer vous-même tout l’historique des messages
Outil {"type": "function", "name": ...} Outil {"type": "function", "function": {"name": ...}}
Élément de sortie function_call, réponse avec function_call_output et call_id message.tool_calls, réponse avec le rôle tool et tool_call_id
Outils intégrés (recherche web, recherche de fichiers) Non disponibles ; faites tourner votre propre outil

L’avant et l’après pour un appel simple :

# Before: Responses API
r = client.responses.create(model="gpt-...", instructions="Be brief.", input="What is RAG?")
text = r.output_text

# After: Chat Completions
r = client.chat.completions.create(
    model="broadnet/gemma-4-26b-a4b",
    messages=[{"role": "system", "content": "Be brief."},
              {"role": "user", "content": "What is RAG?"}],
)
text = r.choices[0].message.content

Le plus gros changement de structure concerne l’état. Responses peut garder l’état de la conversation côté OpenAI avec previous_response_id. Chat Completions n’a pas d’état côté serveur : votre code stocke la liste des messages et l’envoie en entier à chaque tour. Prévoyez-le dans votre budget : tout l’historique compte en tokens d’entrée à chaque appel.

Comment changent les appels d’outils ?

Dans Chat Completions, une définition d’outil imbrique la fonction sous une clé function, et la réponse revient sous forme de message tool :

import json

tools = [{
    "type": "function",
    "function": {
        "name": "get_order",
        "description": "Look up an order by ID.",
        "parameters": {"type": "object",
                       "properties": {"order_id": {"type": "string"}},
                       "required": ["order_id"]},
    },
}]
messages = [{"role": "user", "content": "Where is order A-1042?"}]
r = client.chat.completions.create(model="broadnet/glm-5.3", messages=messages, tools=tools)
msg = r.choices[0].message
if msg.tool_calls:
    messages.append(msg)                                   # keep the assistant turn
    for call in msg.tool_calls:
        args = json.loads(call.function.arguments)         # a JSON string: parse and validate it
        messages.append({"role": "tool", "tool_call_id": call.id,
                         "content": json.dumps(lookup_order(args["order_id"]))})
    r = client.chat.completions.create(model="broadnet/glm-5.3", messages=messages, tools=tools)

Le modèle compte plus que la forme. La documentation de BroadNet n’indique les outils que pour GLM 5.3 et Qwen3.8 27B. Ne branchez pas une boucle d’outils sur un modèle dont la documentation ne mentionne pas les outils, et validez les arguments avant d’exécuter quoi que ce soit. L’appel d’outils avec des modèles ouverts contient une boucle complète avec validation.

Et la sortie structurée ?

client.chat.completions.parse(..., response_format=MyPydanticModel) et zodResponseFormat côté Node envoient tous deux response_format avec un JSON Schema. Ils ne fonctionnent que si le fournisseur accepte cette forme sur ce modèle. BroadNet indique la sortie structurée pour GLM 5.3 et Qwen3.8 27B mais ne nomme pas le paramètre de requête. Faites le test en quatre étapes de mode JSON ou json_schema une fois par modèle, et continuez à valider le résultat parsé, quoi que promette le fournisseur.

Que deviennent les embeddings ?

Si vous changez l’URL de base d’un client partagé et que le fournisseur n’a pas d’endpoint d’embeddings, chaque appel à client.embeddings.create échoue. BroadNet ne vend pas d’embeddings. Gardez deux clients :

chat = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])
embed = OpenAI(api_key=os.environ["OPENAI_API_KEY"])   # or any embeddings provider

vec = embed.embeddings.create(model="text-embedding-3-small", input=query).data[0].embedding
answer = chat.chat.completions.create(model="broadnet/glm-5.3", messages=build_prompt(query, search(vec)))

Ne mélangez jamais dans un même index des vecteurs issus de deux modèles d’embeddings. Si vous changez aussi de fournisseur d’embeddings, recalculez les embeddings de tout le corpus. Le calculateur de coûts d’embeddings en chiffre le coût.

Il en va de même pour tout ce qui n’est pas du chat : génération d’images, synthèse vocale, modération, Batch API et stockage de fichiers. BroadNet ne propose rien de tout cela. Le speech-to-text, lui, suit : client.audio.transcriptions.create fonctionne avec /v1/audio/transcriptions, en WAV ou MP3, avec un champ language (guide speech-to-text pour l’arabe).

Comment change le code de streaming ?

La Responses API diffuse des événements typés, comme response.output_text.delta et response.completed. Chat Completions diffuse des chunks, et le texte se trouve dans choices[0].delta.content. L’usage n’est envoyé que si vous le demandez, et il arrive alors dans un dernier chunk avec une liste choices vide.

// Before (Responses): for await (const e of stream) if (e.type === "response.output_text.delta") out(e.delta);
const stream = await client.chat.completions.create({
  model: "broadnet/gemma-4-26b-a4b",
  messages: [{ role: "user", content: "Count from one to three." }],
  stream: true,
  stream_options: { include_usage: true },
});
for await (const chunk of stream) {
  const text = chunk.choices[0]?.delta?.content;
  if (text) process.stdout.write(text);
  if (chunk.usage) console.log("\ntokens:", chunk.usage.total_tokens);   // last chunk
}

Deux habitudes sécurisent le code de streaming après la bascule. Protégez l’accès à choices[0], car le chunk d’usage n’a pas de choices. Et traitez comme incomplet un flux qui se termine avant la ligne finale data: [DONE] ; la documentation de BroadNet demande alors de noter le X-Request-ID et de décider si une nouvelle requête est sans risque. Le streaming des chat completions présente le schéma complet en Python.

La gestion des erreurs et les retries changent-ils ?

Les classes d’erreur du SDK restent les mêmes : AuthenticationError pour 401, RateLimitError pour 429, APIStatusError pour le reste. Ce qui change, c’est la signification de chaque statut chez le nouveau fournisseur. Chez BroadNet, une 401 peut signifier un quota de paiement à l’usage épuisé, et pas seulement une mauvaise clé, et 402 signifie un solde insuffisant pour un achat. Aucune ne se règle par un retry. Une 429 peut venir de la limite de débit, de simultanéité, de débit de tokens ou de dépense. Relancez les 429 et 5xx avec backoff, et corrigez tout le reste. Le guide des erreurs et des retries contient le tableau complet.

Le SDK relance par défaut deux fois les erreurs de connexion, 408, 409, 429 et 5xx. Si vous ajoutez votre propre boucle de retry, réglez max_retries=0 sur le client pour que les deux ne s’additionnent pas.

Quels paramètres se comportent différemment ?

Paramètre Ce qu’il faut vérifier
max_tokens / max_completion_tokens OpenAI rend max_tokens obsolète ; la documentation de BroadNet l’utilise. Sur les modèles de raisonnement, il inclut la réflexion, donc de petites valeurs renvoient des réponses vides (pourquoi)
reasoning_effort BroadNet documente low ; testez les autres valeurs avant de compter dessus
stream_options: {"include_usage": true} Documenté par BroadNet ; l’usage arrive dans le dernier chunk
n, logprobs, seed, logit_bias Absents de la documentation de BroadNet ; testez-les ou supprimez-les
store, metadata Fonctionnalités de stockage d’OpenAI ; supprimez-les
Parties de contenu image_url Uniquement sur les modèles indiqués avec images : DeepSeek V4.1 Flash, Qwen3.8 27B, Gemma 4 VL 26B

Comment tester la bascule ?

Lancez un court test de fumée contre le nouveau fournisseur avant de déplacer le moindre trafic. Celui-ci vérifie le chat simple, l’usage en streaming, le budget de raisonnement et l’authentification. Ajoutez un cas d’appel d’outil si vous utilisez des outils.

import os, openai
from openai import OpenAI

client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"], max_retries=0)
FAST, REASONING = "broadnet/gemma-4-26b-a4b", "broadnet/qwen3.8-27b"
msg = [{"role": "user", "content": "Reply with the word ok."}]

# 1. Plain chat returns text and usage
r = client.chat.completions.create(model=FAST, messages=msg)
assert r.choices[0].message.content and r.usage.prompt_tokens > 0

# 2. Streaming reports usage in the last chunk
chunks = list(client.chat.completions.create(model=FAST, messages=msg, stream=True,
                                             stream_options={"include_usage": True}))
assert chunks[-1].usage is not None

# 3. A reasoning model needs room: a tiny budget can come back empty
r = client.chat.completions.create(model=REASONING, messages=msg, max_tokens=2000)
assert r.choices[0].finish_reason == "stop" and r.choices[0].message.content

# 4. A bad key raises AuthenticationError (401), which you should not retry
bad = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key="invalid", max_retries=0)
try:
    bad.chat.completions.create(model=FAST, messages=msg)
    raise AssertionError("expected 401")
except openai.AuthenticationError:
    pass
print("smoke test passed")

Comparez ensuite la qualité, pas seulement la forme. Rejouez un échantillon de vrais prompts chez les deux fournisseurs et notez les réponses ; évaluer un LLM avant de changer montre comment. L’outil de migration d’OpenAI vers BroadNet vous aide à réécrire un extrait de code et liste les fonctionnalités qu’il utilise.

Qu’est-ce qui casse le plus souvent ?

  • Une URL de base globale qui déplace aussi les appels d’embeddings et de fichiers.
  • Des helpers propres à Responses comme output_text, laissés dans du code qui appelle désormais Chat Completions.
  • Les identifiants de modèles. Les noms gpt-... n’existent pas ailleurs. Chez BroadNet, ils ressemblent à broadnet/glm-5.3.
  • Des réponses vides des modèles de raisonnement avec un petit max_tokens.
  • Les limites de débit. Une clé BroadNet en paiement à l’usage autorise 30 requêtes par minute et 4 en cours. Les traitements en masse ont besoin d’une file d’attente (gérer les 429).

La place de BroadNet Inference

BroadNet Inference convient aux applications dont l’usage d’OpenAI se résume au chat et à la transcription : assistants, extraction, résumé, traduction et parole en arabe. Il convient aussi aux applications qui veulent des forfaits DeepSeek V4.1 Flash pour leurs agents. Ce n’est pas la bonne cible si vous dépendez de l’état côté serveur de la Responses API, des outils intégrés, des embeddings, de la génération d’images, de la synthèse vocale, de la voix en temps réel ou de la Batch API. Déplacez ces usages vers des fournisseurs qui les proposent, ou gardez-les chez OpenAI et ne déplacez que les appels de chat. Gemma 4 VL 26B et les deux modèles de transcription fonctionnent avec le crédit de départ de $5 ; GLM 5.3, Qwen3.8 27B et DeepSeek V4.1 Flash nécessitent d’abord une recharge.

Questions fréquentes

Faut-il un autre SDK pour utiliser une API compatible OpenAI ?

Non. Gardez le paquet officiel openai et passez une autre base_url (Python) ou baseURL (Node), avec la clé du nouveau fournisseur. Les objets de requête et de réponse restent les mêmes pour les endpoints que le fournisseur prend en charge.

Une API compatible OpenAI prend-elle en charge la Responses API ?

Certaines oui ; beaucoup ne prennent en charge que Chat Completions. Vérifiez la liste des endpoints du fournisseur. BroadNet Inference documente /v1/chat/completions et /v1/audio/transcriptions : le code de la Responses API doit donc être réécrit en Chat Completions.

Que deviennent mes embeddings quand je change de fournisseur ?

Ils cassent si le nouveau fournisseur n’a pas d’endpoint d’embeddings et que vous avez changé l’URL de base de façon globale. BroadNet ne vend pas d’embeddings : gardez un client d’embeddings pointé vers votre fournisseur d’embeddings. Ne mélangez jamais dans un même index des vecteurs issus de deux modèles d’embeddings.

Faut-il envoyer max_tokens ou max_completion_tokens ?

OpenAI déclare max_tokens obsolète au profit de max_completion_tokens. Beaucoup de fournisseurs compatibles documentent plutôt max_tokens, et la documentation de BroadNet utilise max_tokens. Envoyez ce que le fournisseur documente et vérifiez dans votre test de fumée que la limite s’applique.

Les helpers de sortie structurée d’OpenAI fonctionneront-ils encore ?

Seulement si le fournisseur accepte response_format avec json_schema sur le modèle utilisé. BroadNet indique la sortie structurée pour GLM 5.3 et Qwen3.8 27B mais ne nomme pas le paramètre de requête : testez-le, et continuez à valider le résultat parsé.

Lire en MarkdownDemander à ChatGPTDemander à ClaudeDemander à Perplexity