---
title: "Migrer depuis l’API OpenAI : diffs de code et tests | BroadRouter"
description: "Le code à modifier pour passer d’OpenAI à une API compatible OpenAI : client, Responses vers Chat Completions, outils, streaming, embeddings et test de fumée."
url: https://broadrouter.com/fr/blog/migrate-from-openai-api-code-walkthrough/
lang: fr
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Traduit de l’anglais avec l’aide de l’IA. [Lire l’original en anglais](https://broadrouter.com/blog/migrate-from-openai-api-code-walkthrough/) (mis à jour le 2026-11-15).

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

Par l’équipe BroadNet Inference · 6 min de lecture · Publié 2026-11-15

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.

## À retenir

-   Pour du code Chat Completions, le changement tient en trois valeurs : base\_url, api\_key et model. Les deux SDK officiels lisent aussi OPENAI\_BASE\_URL et OPENAI\_API\_KEY dans l’environnement.
-   Définir OPENAI\_BASE\_URL déplace tous les appels, embeddings compris. Si le nouveau fournisseur n’a pas d’endpoint d’embeddings, donnez aux embeddings leur propre client.
-   Le code de la Responses API doit être réécrit : input vers messages, instructions vers un message système, text.format vers response\_format, et des définitions d’outils plates vers des définitions imbriquées.
-   BroadNet Inference documente /v1/chat/completions, /v1/audio/transcriptions et GET /v1/models, sans endpoint d’embeddings, de fichiers ni de lots. Sa documentation indique les outils et la sortie structurée pour GLM 5.3 et Qwen3.8 27B.
-   Testez avant de basculer : un chat simple, l’usage en streaming, un budget de raisonnement et une clé invalide, plus un appel d’outil si vous utilisez des outils.

**Sur cette page**

1.  Qu’est-ce qui change dans la configuration du client ?
2.  Et si mon code utilise la Responses API ?
3.  Comment changent les appels d’outils ?
4.  Et la sortie structurée ?
5.  Que deviennent les embeddings ?
6.  Comment change le code de streaming ?
7.  La gestion des erreurs et les retries changent-ils ?
8.  Quels paramètres se comportent différemment ?
9.  Comment tester la bascule ?
10.  Qu’est-ce qui casse le plus souvent ?
11.  La place de BroadNet Inference

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](https://broadrouter.com/fr/blog/openai-compatible-api-migration-checklist/), 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](https://broadrouter.com/fr/blog/openai-compatible-api-base-urls/).

## 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**

```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**

```javascript
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**

```bash
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 :

```python
# 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` :

```python
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](https://broadrouter.com/fr/models/glm-5.3/) et [Qwen3.8 27B](https://broadrouter.com/fr/models/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](https://broadrouter.com/fr/blog/tool-calling-open-models/) 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](https://broadrouter.com/fr/blog/structured-output-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](https://broadrouter.com/fr/glossary/embeddings/). Gardez deux clients :

```python
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](https://broadrouter.com/tools/embedding-cost-calculator/) 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](https://broadrouter.com/fr/guides/arabic-speech-to-text-api/)).

## 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.

```javascript
// 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](https://broadrouter.com/fr/guides/streaming-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](https://broadrouter.com/fr/guides/errors-and-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](https://broadrouter.com/fr/guides/reasoning-tokens-empty-response/)) |
| `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.

```python
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](https://broadrouter.com/fr/blog/evaluate-llm-before-switching/) montre comment. L’[outil de migration d’OpenAI vers BroadNet](https://broadrouter.com/tools/openai-to-broadnet-migration/) 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](https://broadrouter.com/fr/blog/handle-llm-api-429-rate-limits/)).

## 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](https://broadrouter.com/fr/models/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.

Outils gratuits sur ce sujet (en anglais)

-   [OpenAI to BroadNet migration helper](https://broadrouter.com/tools/openai-to-broadnet-migration/) Paste OpenAI SDK code; get base URL, key and model edits, a diff and the checks that remain.
-   [max\_tokens calculator for reasoning models](https://broadrouter.com/tools/reasoning-token-budget/) Answer length + reasoning budget + margin = a max\_tokens that does not cut the answer off.
-   [JSON schema generator for LLM structured output](https://broadrouter.com/tools/json-schema-generator/) Sample JSON to strict schema, Pydantic, Zod and a ready request.
-   [LLM JSON output validator](https://broadrouter.com/tools/llm-json-output-validator/) Parse errors by line and column, safe repairs, cut-off detection and JSON Schema checks for model output.

[Outils gratuits (en anglais)](https://broadrouter.com/tools/)

## Termes de cet article

[Embeddings (plongements vectoriels)](https://broadrouter.com/fr/glossary/embeddings/)

Les embeddings sont des listes de nombres à virgule flottante (des vecteurs) qu’un modèle produit pour représenter un texte, une image ou une autre entrée. Des entrées de sens proche obtiennent des vecteurs voisins : la distance entre vecteurs permet de classer des résultats de recherche, de regrouper des documents ou de trouver des éléments apparentés.

[Appel d’outils (tool calling, function calling)](https://broadrouter.com/fr/glossary/tool-calling/)

L’appel d’outils, aussi appelé function calling, est une fonctionnalité des API LLM dans laquelle le modèle renvoie une demande structurée d’exécution d’une fonction définie par le développeur, avec des arguments JSON. L’application exécute la fonction et renvoie le résultat ; le modèle n’exécute jamais de code lui-même.

[API Chat Completions](https://broadrouter.com/fr/glossary/chat-completions-api/)

L’API Chat Completions est l’endpoint HTTP d’OpenAI, POST /v1/chat/completions, qui reçoit un nom de modèle et une liste de messages associés à un rôle, et renvoie le message suivant du modèle. Sa forme de requête et de réponse est devenue le format commun que reprennent les fournisseurs et SDK compatibles OpenAI.

[Streaming](https://broadrouter.com/fr/glossary/streaming/)

Le streaming est une manière de renvoyer la réponse d’un modèle de langage par petits chunks pendant sa génération, plutôt qu’en un seul bloc à la fin. Les API compatibles OpenAI streament via des server-sent events quand la requête règle stream sur true.

[URL de base (base URL)](https://broadrouter.com/fr/glossary/base-url/)

L’URL de base est l’adresse racine fixe d’une API, comme https://api.example.com/v1, que le client place devant chaque chemin d’endpoint, comme /chat/completions. Dans les SDK compatibles OpenAI, changer l’URL de base, avec la clé d’API et l’ID du modèle, oriente le même code vers un autre fournisseur.

[API batch (traitement par lots)](https://broadrouter.com/fr/glossary/batch-api/)

Une API batch est un endpoint LLM asynchrone qui accepte de nombreuses requêtes d’un coup, généralement sous forme de fichier, les traite dans une fenêtre définie plutôt qu’immédiatement et renvoie les résultats ensemble. Des fournisseurs comme OpenAI et Anthropic facturent les requêtes batch avec une remise par rapport à leurs API standard.

[Débit (throughput)](https://broadrouter.com/fr/glossary/throughput/)

Le débit (throughput), dans le service de LLM, est la quantité totale de travail qu’un système accomplit par unité de temps sur toutes les requêtes simultanées, généralement mesurée en tokens de sortie par seconde ou en requêtes par seconde. Il se distingue de la vitesse par flux, c’est-à-dire la vitesse à laquelle une seule requête reçoit ses tokens.

[Paiement à l’usage (pay-as-you-go)](https://broadrouter.com/fr/glossary/pay-as-you-go/)

Le paiement à l’usage (pay-as-you-go) est un modèle tarifaire où vous ne payez que ce que vous consommez, mesuré par unité, comme les tokens, les requêtes ou les minutes d’audio, sans abonnement ni engagement minimal. La plupart des API LLM facturent ainsi, à partir d’un solde prépayé ou d’une facture périodique.

## 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 ensuite

-   [Passer à une API compatible OpenAI : la checklist de migration](https://broadrouter.com/fr/blog/openai-compatible-api-migration-checklist/)
-   [URL de base des API compatibles OpenAI : 14 fournisseurs vérifiés](https://broadrouter.com/fr/blog/openai-compatible-api-base-urls/)
-   [Appel d’outils et modèles ouverts : schémas, parallélisme, relances](https://broadrouter.com/fr/blog/tool-calling-open-models/)
-   [Mode JSON ou json\_schema : une sortie structurée qui tient](https://broadrouter.com/fr/blog/structured-output-json-schema/)
-   [Comment évaluer un LLM avant de changer de fournisseur](https://broadrouter.com/fr/blog/evaluate-llm-before-switching/)
-   [Matériel GPU et serving de BroadNet, tels que BroadNet les décrit](https://broadrouter.com/fr/blog/broadnet-gpu-fleet-and-serving/)
-   [Mettre en cache les réponses d’API LLM : un cache exact en Python](https://broadrouter.com/fr/blog/cache-llm-responses-cut-cost/)
-   [Guide : Utiliser le SDK Python d’OpenAI avec BroadNet Inference](https://broadrouter.com/fr/guides/openai-python-sdk/)
-   [Guide : Utiliser le SDK Node.js d’OpenAI avec BroadNet Inference](https://broadrouter.com/fr/guides/openai-node-sdk/)
-   [Guide : Première requête à BroadNet Inference avec curl](https://broadrouter.com/fr/guides/curl-quickstart/)
-   [Guide : Pourquoi un modèle de raisonnement renvoie une réponse vide](https://broadrouter.com/fr/guides/reasoning-tokens-empty-response/)

Essayez-le sur votre vraie charge de travail. Les nouveaux comptes démarrent avec USD 5 de crédit pour Gemma et transcription. DeepSeek, GLM et Qwen3.8 nécessitent une recharge.

[Commencer](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=fr-blog-migrate-from-openai-api-code-walkthrough&utm_content=page-cta) ·

**Sources**

-   [Référence de l’API de BroadNet Inference : endpoints, identifiants de modèles, capacités, usage en streaming, erreurs (vérifiée le 2026-11-15) (en anglais)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=fr-blog-migrate-from-openai-api-code-walkthrough&utm_content=sources)
-   [README d’openai-python : Responses est l’API principale, Chat Completions est pris en charge sans limite de durée, retries (vérifié le 2026-11-15)](https://github.com/openai/openai-python)
-   [Code source du client openai-node : baseURL vaut OPENAI\_BASE\_URL par défaut (vérifié le 2026-11-15)](https://github.com/openai/openai-node/blob/master/src/client.ts)
-   [OpenAI, migrer vers la Responses API : différences sur la sortie structurée, les outils et le stockage (vérifié le 2026-11-15)](https://developers.openai.com/api/docs/guides/migrate-to-responses)
-   [Guide du function calling d’OpenAI : forme des outils dans les deux API (vérifié le 2026-11-15)](https://developers.openai.com/api/docs/guides/function-calling)
-   [Référence Chat Completions d’OpenAI : max\_tokens obsolète au profit de max\_completion\_tokens (vérifiée le 2026-11-15)](https://developers.openai.com/api/reference/resources/chat/subresources/completions/methods/create)
