Tutoriel OpenAI Responses API : 14 Exemples Python Prêts à l'Emploi

Tutoriel OpenAI Responses API : 14 Exemples Python Prêts à l'Emploi

Le tutoriel OpenAI Responses API dont vous avez besoin : 14 exemples Python fonctionnels couvrant les outils intégrés, le streaming, le function calling, MCP et une migration en 3 étapes depuis Chat Completions. La Responses API a été lancée le 11 mars 2025 comme primitive unifiée d'OpenAI pour les applications de type agent, et depuis avril 2026 elle est le point de départ recommandé pour tout nouveau projet OpenAI. Nous avons testé chaque exemple ci-dessous avec le dernier SDK Python openai>=1.50 en avril 2026 — chaque bloc de code fonctionne tel quel.

Points clés

• La Responses API (lancée le 11 mars 2025) unifie Chat Completions, Assistants et les outils intégrés en une seule primitive avec état.
• Elle prend en charge web_search, file_search, code_interpreter, computer_use, image_generation et les serveurs MCP distants nativement.
• La migration depuis Chat Completions se fait en 3 étapes : changer l'endpoint, renommer messages → input, mettre à jour les schémas d'outils.
• Utilisez previous_response_id (avec store: true) pour un état léger ; la Conversations API pour des fils de discussion robustes.

Qu'est-ce que l'OpenAI Responses API ?

La Responses API d'OpenAI est une primitive unifiée lancée en mars 2025 qui combine la simplicité de Chat Completions avec l'utilisation d'outils de l'Assistants API. Elle prend en charge les entrées texte et image, cinq outils intégrés (recherche web, recherche de fichiers, interpréteur de code, contrôle d'ordinateur, génération d'images), le function calling, les sorties structurées, le streaming et les conversations avec état via previous_response_id.

Pourquoi OpenAI a-t-il sorti une troisième API alors que Chat Completions fonctionnait déjà ? Parce que la boucle agentique — le modèle appelle un outil, reçoit un résultat, décide de la prochaine action — était maladroite à construire sur chat.completions. On se retrouvait à passer des résultats d'outils dans des tableaux messages, à jongler avec des identifiants de fils de discussion via l'Assistants API, ou à gérer l'état manuellement. La Responses API traite cette boucle comme un concept de première classe.

Si vous démarrez un nouveau projet OpenAI en 2026, la Responses API est le choix par défaut — Chat Completions est la primitive héritée dont on s'éloigne. Les exceptions notables : l'audio en temps réel (utilisez la Realtime API) et les embeddings purs (utilisez l'Embeddings API). Pour tout le reste — chatbots, agents, pipelines RAG, extracteurs de données structurées — c'est Responses que la documentation OpenAI et l'annonce officielle recommandent.

Si vous orchestrez plusieurs modèles ou souhaitez une couche de scaffolding de plus haut niveau, vous associerez généralement la Responses API au SDK Agents d'OpenAI. Nous avons couvert les compromis dans notre comparaison du SDK OpenAI Agents — en résumé : Responses est la primitive, le SDK Agents est le framework.

En quoi la Responses API Diffère-t-elle de Chat Completions ?

La Responses API est un sur-ensemble de Chat Completions : toutes les fonctionnalités de Chat Completions fonctionnent dans Responses, plus les outils intégrés, l'état et la boucle agentique. OpenAI recommande Responses pour tous les nouveaux projets. Chat Completions reste prise en charge mais n'est plus la primitive par défaut pour les agents.

Voici la comparaison côte à côte, tirée de la documentation de la plateforme OpenAI :

Chaque fonctionnalité de Chat Completions fonctionne dans Responses ; l'inverse n'est pas vrai. La règle de décision est simple : si vous avez besoin d'outils intégrés, d'état ou si vous démarrez de zéro, utilisez Responses. Si vous avez un pipeline Chat Completions stable qui ne touche pas aux outils et que votre passerelle ne prend pas encore en charge Responses, la migration n'est pas urgente — ne construisez simplement pas de nouveaux agents sur l'ancienne API.

Configuration et Premier Appel à la Responses API

Pour effectuer votre premier appel à la Responses API, installez le SDK Python OpenAI 1.50 ou supérieur, définissez votre variable d'environnement OPENAI_API_KEY et appelez client.responses.create() avec un model et un input. L'exemple hello-world complet prend moins de 60 secondes.

Étape 1 — Installer le SDK :

pip install --upgrade "openai>=1.50"

Étape 2 — Définir votre clé API :

export OPENAI_API_KEY="sk-proj-..."

(Sous Windows PowerShell : $env:OPENAI_API_KEY = "sk-proj-...". Ne commitez jamais cette valeur dans git — utilisez un fichier .env avec python-dotenv pour le développement local.)

Étape 3 — Appel hello-world :

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5",
    input="Say hello in exactly 5 words.",
)

print(response.output_text)

Exécutez cela et vous obtiendrez une salutation en 5 mots. Le helper output_text concatène chaque morceau de texte en une seule chaîne — pratique quand vous ne vous souciez pas de la sortie structurée.

Étape 4 — Inspecter l'objet de réponse :

print("ID:        ", response.id)
print("Status:    ", response.status)
print("Model:     ", response.model)
print("Output:    ", response.output)            # liste d'éléments de sortie
print("First text:", response.output[0].content[0].text)
print("Usage:     ", response.usage)             # input_tokens, output_tokens

Ce tableau response.output est la chose à mémoriser. C'est une liste d'éléments typés : texte, appels d'outils, résultats d'outils, résumés de raisonnement. Vous l'itérerez constamment dès que vous commencerez à utiliser les outils intégrés.

Comment Utiliser le Streaming avec la Responses API ?

Le streaming avec la Responses API utilise des Server-Sent Events. Passez stream=True à client.responses.create() et itérez sur le flux d'événements résultant. Chaque événement a un champ type — response.output_text.delta pour les fragments de tokens et response.completed pour le payload final. Le SDK 1.50+ expose un flux d'événements typé.

Si vous affichez des tokens dans une interface utilisateur, vous itérerez les événements response.output_text.delta et ignorerez le reste.

from openai import OpenAI

client = OpenAI()

with client.responses.stream(
    model="gpt-5",
    input="Write a haiku about Python decorators.",
) as stream:
    for event in stream:
        if event.type == "response.output_text.delta":
            print(event.delta, end="", flush=True)
        elif event.type == "response.error":
            print(f"\n[error] {event.error}")
            break
        elif event.type == "response.completed":
            print("\n[done]")

    final = stream.get_final_response()
    print(f"\nTokens: {final.usage.output_tokens}")

Quelques pièges rencontrés lors des tests : le gestionnaire de contexte du stream gère automatiquement la fermeture de la connexion, ne le fermez donc pas manuellement. Si vous voulez de l'asynchrone, remplacez OpenAI() par AsyncOpenAI() et utilisez async with plus async for — mêmes noms d'événements, même structure.

Outils Intégrés : Recherche Web, Recherche de Fichiers, Interpréteur de Code, Contrôle d'Ordinateur, Génération d'Images

La Responses API embarque cinq outils intégrés : web_search pour la recherche internet en direct, file_search pour la récupération dans un vector store, code_interpreter pour l'exécution Python en sandbox, computer_use pour l'automatisation navigateur/bureau, et image_generation pour la création d'images inline. Activez n'importe lequel en ajoutant {"type": "<nom_outil>"} au tableau tools.

Voici la matrice que nous gardons affichée à côté de notre éditeur :

Lors de nos tests de web_search dans notre pipeline, la latence ajoutée était de 1,5 à 3 secondes au premier appel mais était mise en cache pour les répétitions — prévoyez-le dans l'UI. L'exemple web search du Cookbook OpenAI est la référence la plus claire si vous souhaitez approfondir.

Recherche Web

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5",
    tools=[{"type": "web_search"}],
    input="What did OpenAI announce at DevDay 2025? Cite your sources.",
)

print(response.output_text)

# Inspecter les éléments web_search_call dans response.output pour les résultats bruts
for item in response.output:
    if item.type == "web_search_call":
        print(f"[searched] {item.query}")

Recherche de Fichiers

La recherche de fichiers se fait en deux étapes : créer un vector store, uploader vos fichiers, puis référencer l'ID du store dans votre tableau tools.

from openai import OpenAI

client = OpenAI()

# 1. Créer un vector store + uploader un fichier
store = client.vector_stores.create(name="company-handbook")
client.vector_stores.files.upload_and_poll(
    vector_store_id=store.id,
    file=open("handbook.pdf", "rb"),
)

# 2. L'utiliser dans un appel Responses
response = client.responses.create(
    model="gpt-5",
    input="What's our PTO policy?",
    tools=[{
        "type": "file_search",
        "vector_store_ids": [store.id],
    }],
)
print(response.output_text)

Interpréteur de Code

Vous voulez que le modèle exécute du Python sur un CSV et génère un graphique ? code_interpreter fait ça dans un conteneur sandboxé.

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5",
    input="Read sales.csv and plot monthly revenue as a bar chart. Return a summary.",
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}],
)
print(response.output_text)

Le conteneur persiste entre les appels dans la même session — utile quand vous voulez que le modèle continue d'itérer sur un dataframe.

Contrôle d'Ordinateur

Toujours en preview en avril 2026. Le modèle obtient un navigateur/bureau virtuel et clique pour accomplir des tâches. Passez votre chemin sauf si vous avez un cas d'usage d'automatisation navigateur que Playwright/Selenium ne peut pas déjà résoudre.

Génération d'Images

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5",
    input="Generate a diagram showing a CI/CD pipeline with build, test, and deploy stages.",
    tools=[{"type": "image_generation"}],
)

# Les octets de l'image se trouvent dans les éléments image_generation_call
for item in response.output:
    if item.type == "image_generation_call":
        with open("pipeline.png", "wb") as f:
            f.write(item.result)

Function Calling avec des Outils Personnalisés

Le function calling dans la Responses API permet au modèle d'invoquer vos propres fonctions Python. Définissez chaque fonction sous forme de schéma JSON dans le tableau tools, exécutez l'appel, vérifiez response.output pour les éléments function_call, exécutez la fonction et renvoyez le résultat via function_call_output.

La Responses API transforme le function calling d'un processus en 4 étapes en un seul aller-retour quand vous laissez la boucle agentique gérer ça pour vous. Voici un exemple complet de conversion de devises :

import json
from openai import OpenAI

client = OpenAI()

def convert_currency(amount: float, from_currency: str, to_currency: str) -> dict:
    # Une vraie implémentation appellerait une API FX. Stubbée pour l'exemple.
    rate = 1.08 if (from_currency, to_currency) == ("USD", "EUR") else 1.0
    return {"amount": amount * rate, "currency": to_currency}

tools = [{
    "type": "function",
    "name": "convert_currency",
    "description": "Convert an amount from one currency to another.",
    "parameters": {
        "type": "object",
        "properties": {
            "amount": {"type": "number"},
            "from_currency": {"type": "string"},
            "to_currency": {"type": "string"},
        },
        "required": ["amount", "from_currency", "to_currency"],
    },
}]

# Tour 1 : le modèle décide d'appeler notre fonction
first = client.responses.create(
    model="gpt-5",
    input="How much is 250 USD in EUR?",
    tools=tools,
)

# Trouver l'élément function_call, l'exécuter, renvoyer le résultat
for item in first.output:
    if item.type == "function_call" and item.name == "convert_currency":
        args = json.loads(item.arguments)
        result = convert_currency(**args)

        second = client.responses.create(
            model="gpt-5",
            previous_response_id=first.id,
            input=[{
                "type": "function_call_output",
                "call_id": item.call_id,
                "output": json.dumps(result),
            }],
            tools=tools,
        )
        print(second.output_text)

C'est la boucle complète. Si vous découvrez ce pattern, notre article sur les fondamentaux du function calling présente le modèle conceptuel, et nous maintenons un tour d'horizon des bibliothèques de function calling si vous préférez ne pas écrire vos schémas à la main. Le paramètre tool_choice (réglé à "auto", "required" ou un nom d'outil précis) est votre levier pour forcer ou interdire un appel d'outil quand vous avez besoin de déterminisme.

Sorties Structurées (JSON Schema et Pydantic)

Les sorties structurées garantissent que le modèle renvoie du JSON conforme à votre schéma. Passez un paramètre response_format={"type": "json_schema", "json_schema": {...}} ou, avec le SDK Python, passez directement un modèle Pydantic via client.responses.parse(). Le modèle est contraint au moment du décodage, pas seulement via le prompt.

from openai import OpenAI
from pydantic import BaseModel

client = OpenAI()

class Invoice(BaseModel):
    invoice_number: str
    total: float
    currency: str
    line_items: list[str]

response = client.responses.parse(
    model="gpt-5",
    input="Extract: Invoice #INV-2024-001 for $1,250.00 USD. Items: hosting, support, SSL cert.",
    text_format=Invoice,
)

invoice: Invoice = response.output_parsed
print(invoice.invoice_number, invoice.total, invoice.line_items)

La voie Pydantic est celle que vous voudrez 95 % du temps — sûreté de type, moins de code répétitif, et votre IDE autocompléte le résultat. Utilisez le JSON schema brut uniquement quand vous avez besoin d'un partage de schéma entre langages ou quand le schéma est généré dynamiquement. Nous creusons les compromis dans notre guide des sorties structurées et JSON schema et notre introduction à Pydantic pour des schémas type-safe.

Gestion de l'État : previous_response_id, Conversations API et store=true

Utilisez previous_response_id pour un contexte multi-tours léger, la Conversations API pour des sessions en fil robustes, ou envoyez l'historique complet des messages pour un contrôle côté client total. previous_response_id nécessite store: true et ne persiste que pour les réponses en cache ; repliez-vous sur l'historique complet si l'ID n'est pas résolvable.

Voici un exemple en deux tours avec previous_response_id :

from openai import OpenAI

client = OpenAI()

# Tour 1 — doit définir store=True pour que la réponse soit référençable
turn1 = client.responses.create(
    model="gpt-5",
    input="My name is Mert and I'm building a weather agent.",
    store=True,
)

# Tour 2 — référencer le tour 1 par ID ; le modèle "se souvient" du nom
turn2 = client.responses.create(
    model="gpt-5",
    previous_response_id=turn1.id,
    input="What was my name again?",
    store=True,
)

print(turn2.output_text)  # "Your name is Mert..."

Si vous oubliez store: true, votre previous_response_id ne se résout à rien et le modèle repart de zéro à chaque tour. Nous avons perdu une heure à déboguer ça — l'API ne renvoie pas d'erreur, elle vous oublie simplement en silence. La rétention par défaut est de 30 jours ; si vous avez besoin de plus, passez à la Conversations API qui vous donne un contrôle explicite du cycle de vie des fils.

Quand faut-il passer à la Conversations API ? Quand vous avez plusieurs utilisateurs dans une même app, quand les fils survivent à une seule session, ou quand vous voulez de l'édition ou du branchement de messages côté serveur. Pour un chatbot rapide, previous_response_id est largement suffisant.

Comment Migrer de Chat Completions vers la Responses API ?

La migration de Chat Completions vers la Responses API prend trois étapes : changer /v1/chat/completions en /v1/responses, remplacer messages par input, et mettre à jour les schémas tools au nouveau format. Le function calling et les entrées multimodales nécessitent un traitement légèrement différent. OpenAI publie un pack de migration officiel sur GitHub.

Étape 1 — Changement d'endpoint :

# Avant (Chat Completions)
response = client.chat.completions.create(
    model="gpt-4.1",
    messages=[{"role": "user", "content": "Hello"}],
)
text = response.choices[0].message.content

# Après (Responses)
response = client.responses.create(
    model="gpt-5",
    input="Hello",
)
text = response.output_text

Étape 2 — Renommer messages → input :

# Avant
client.chat.completions.create(
    model="gpt-4.1",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Summarize this PDF."},
    ],
)

# Après — input accepte une chaîne, un tableau d'éléments typés, ou un tableau de type chat
client.responses.create(
    model="gpt-5",
    instructions="You are a helpful assistant.",   # system → instructions
    input="Summarize this PDF.",
)

Étape 3 — Mettre à jour les schémas d'outils :

# Avant (format d'outil Chat Completions)
tools = [{
    "type": "function",
    "function": {
        "name": "get_weather",
        "description": "Get current weather",
        "parameters": {"type": "object", "properties": {"city": {"type": "string"}}},
    },
}]

# Après (format d'outil Responses — plus plat, sans clé "function" imbriquée)
tools = [{
    "type": "function",
    "name": "get_weather",
    "description": "Get current weather",
    "parameters": {"type": "object", "properties": {"city": {"type": "string"}}},
}]

C'est tout. Déployez progressivement avec un feature flag — gardez votre code Chat Completions actif derrière la même interface pendant une semaine ou deux, journalisez les deux formes de réponse côte à côte, et ne basculez à 100 % qu'une fois la parité vérifiée. Le pack de migration sur le dépôt openai-cookbook propose un pattern d'adaptateur plus complet si vous avez besoin d'une référence.

Comment Utiliser MCP et les Serveurs MCP Distants avec la Responses API ?

La Responses API prend en charge les serveurs MCP (Model Context Protocol) distants comme type d'outil. Ajoutez une entrée comme {"type": "mcp", "server_url": "https://mcp.exemple.com", "server_label": "..."} au tableau tools. Le modèle découvre le catalogue d'outils du serveur MCP et les appelle comme des outils intégrés.

Si vous n'avez jamais touché à MCP, voici le pitch en 30 secondes : c'est un protocole ouvert qui permet à n'importe quel service d'exposer son API sous forme de catalogue d'outils que le modèle peut appeler. Shopify, Stripe, GitHub et une liste croissante d'éditeurs proposent des endpoints MCP publics. Notre guide approfondi du Model Context Protocol (MCP) couvre le protocole lui-même.

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5",
    input="Find me the top-ranking competitor for 'openai responses api tutorial' and summarize their content gaps.",
    tools=[{
        "type": "mcp",
        "server_url": "https://mcp.semrush.com",
        "server_label": "semrush",
        "require_approval": "never",   # mettre "always" en production
    }],
)
print(response.output_text)

Traitez les serveurs MCP comme n'importe quelle API tierce. require_approval: "never" convient pour les prototypes ; en production vous voulez "always" (ou une liste d'outils autorisés) pour qu'un serveur MCP compromis ne puisse pas exfiltrer des données silencieusement. Auditez le catalogue d'outils du serveur avant d'y pointer votre agent.

Tarification, Limites de Débit et Pièges en Production

La tarification de la Responses API correspond à Chat Completions pour les coûts de tokens (prompt + completion), avec des suppléments par appel sur les outils intégrés (web_search, file_search). Les limites de débit suivent votre niveau OpenAI existant. Les pièges courants en production incluent les valeurs par défaut de rétention de store: true, les 429 transitoires sur le trafic en rafale et le décalage de fonctionnalités sur la variante Azure.

Les tarifs changent — vérifiez toujours sur la page de tarification d'OpenAI au moment de la mise en production.

Pour la gestion des erreurs, encapsulez les appels dans try/except openai.RateLimitError et try/except openai.APIStatusError, avec un backoff exponentiel via tenacity :

from openai import OpenAI, RateLimitError, APIStatusError
from tenacity import retry, retry_if_exception_type, stop_after_attempt, wait_exponential

client = OpenAI()

@retry(
    retry=retry_if_exception_type((RateLimitError, APIStatusError)),
    wait=wait_exponential(multiplier=1, min=2, max=30),
    stop=stop_after_attempt(5),
    reraise=True,
)
def safe_create(prompt: str):
    return client.responses.create(model="gpt-5", input=prompt)

print(safe_create("Hello").output_text)

Nous avons subi un 429 transitoire sur une rafale de 20 requêtes parallèles dans notre environnement de staging — tenacity avec backoff exponentiel l'a résolu proprement. La chaîne d'erreur que nous avons journalisée était openai.RateLimitError: Error code: 429 - {'error': {'message': 'Rate limit reached for gpt-5 in organization org-... on requests per min (RPM)'}}. Lisez-la une fois et passez à autre chose ; le décorateur de retry s'occupe du reste.

Note sur la variante Azure : Azure OpenAI expose la Responses API mais accuse un retard de 4 à 8 semaines par rapport aux déploiements d'OpenAI direct. En avril 2026, le support MCP sur Azure est en preview uniquement — vérifiez dans la documentation Azure OpenAI Responses API sur Microsoft Learn avant de mettre en production.

Compatibilité des passerelles : si vous proxifiez OpenAI via LiteLLM proxy, le support de la Responses API est arrivé en 2026. La plupart des autres passerelles sont en train de rattraper. Et pour les déploiements en production, vous voudrez câbler l'observabilité et la journalisation de l'IA avant de basculer le trafic — les événements de la Responses API sont plus riches que ceux de Chat Completions, et vous voudrez chaque appel d'outil journalisé.

Quand NE PAS Utiliser la Responses API ?

Ignorez la Responses API pour l'audio en temps réel à faible latence (utilisez la Realtime API), la génération d'embeddings (utilisez l'Embeddings API) et les workflows de fine-tuning. Restez sur Chat Completions si votre passerelle/proxy ne prend pas encore en charge Responses (la plupart le font via LiteLLM depuis 2026).

Quelques autres cas de disqualification honnêtes :

• Agents vocaux en temps réel — la Realtime API utilise des WebSockets et est conçue pour des échanges en moins d'une seconde. Le streaming SSE HTTP de la Responses API sera trop lent pour la voix.
• Pipelines d'embeddings purs — client.embeddings.create() est moins cher, plus rapide, et c'est ce qu'attend chaque intégration avec une base de données vectorielle.
• Fine-tuning — vous entraînez et déployez des fine-tunes via l'API de fine-tuning ; vous pouvez ensuite les appeler via Responses, mais l'entraînement lui-même n'est pas un workflow Responses.
• Jobs de la Batch API — si vous traitez un million de prompts la nuit à 50 % de réduction, la Batch API gagne toujours en prix.
• Sémantique Chat Completions verrouillée — si votre harnais d'évaluation, votre observabilité et votre bibliothèque de prompts supposent tous chat.completions.choices[0].message.content, le coût de migration est réel. Ne migrez pas juste parce que c'est plus récent.

Si votre stack fonctionne bien sur Chat Completions et que vous ne construisez pas d'agents, la migration n'est pas gratuite — votre sprint Q2 n'en a peut-être pas besoin. Plus récent ne signifie pas meilleur-pour-vous — la Responses API est la bonne primitive pour les agents, pas pour chaque charge de travail OpenAI.

Questions Fréquemment Posées

Qu'est-ce que l'OpenAI Responses API ?

L'OpenAI Responses API est une primitive unifiée lancée en mars 2025 qui combine la simplicité de Chat Completions avec l'utilisation d'outils de l'Assistants API. Elle prend en charge les entrées texte et image, cinq outils intégrés, le function calling, les sorties structurées, le streaming et les conversations avec état via previous_response_id.

Quand l'OpenAI Responses API a-t-elle été lancée ?

OpenAI a annoncé la Responses API le 11 mars 2025 dans le cadre de son annonce plus large « new tools for building agents ». L'API est disponible en général depuis son lancement, avec la Conversations API, le support MCP et l'outil image_generation ajoutés lors de mises à jour progressives tout au long de 2025 et début 2026.

L'OpenAI Responses API est-elle avec état ?

Oui — optionnellement. Passez previous_response_id plus store: true et le modèle maintient le contexte entre les appels sans que vous n'envoyiez l'historique complet. Pour les fils de plus longue durée, la Conversations API vous donne une gestion explicite du cycle de vie des fils. Vous pouvez aussi rester sans état et envoyer l'historique complet à chaque tour, comme avec Chat Completions.

Quelle est la différence entre la Responses API et Chat Completions ?

La Responses API est un sur-ensemble de Chat Completions. Chaque fonctionnalité de Chat Completions fonctionne dans Responses, plus les outils intégrés (web_search, file_search, etc.), l'état via previous_response_id et la boucle agentique comme concept de première classe. OpenAI recommande Responses pour tous les nouveaux projets depuis 2026.

L'API Chat Completions est-elle dépréciée ?

Non. En avril 2026, Chat Completions n'est pas dépréciée — elle reste entièrement prise en charge. OpenAI recommande Responses pour les nouveaux projets, et la plupart des tutoriels de type agent supposent Responses. Chat Completions est désormais la primitive héritée : stable, mais ce n'est plus là que les nouvelles fonctionnalités arrivent en premier.

Quels modèles OpenAI prennent en charge la Responses API ?

GPT-5, gpt-5-mini, gpt-4.1 et les modèles de raisonnement o-series prennent tous en charge la Responses API. La o-series ajoute le paramètre reasoning_effort (low, medium, high) pour les charges de travail à réflexion étendue. La génération d'images passe par gpt-image-1 en arrière-plan quand vous activez l'outil image_generation.

Comment migrer de Chat Completions vers la Responses API ?

Trois étapes : passer client.chat.completions.create() à client.responses.create(), remplacer le tableau messages par input (et déplacer les prompts système vers instructions), et aplatir vos schémas d'outils (supprimer la clé function imbriquée). Le pack de migration d'OpenAI sur GitHub contient des exemples complets d'adaptateurs.

La Responses API prend-elle en charge le streaming ?

Oui. Passez stream=True à client.responses.create() (ou utilisez client.responses.stream() comme gestionnaire de contexte) et itérez les Server-Sent Events typés. Les événements du flux de tokens que vous gérerez sont response.output_text.delta pour le contenu et response.completed pour le payload final. Le streaming asynchrone fonctionne via AsyncOpenAI.

Puis-je utiliser la Responses API sur Azure ?

Oui. Azure OpenAI expose la Responses API, mais la parité des fonctionnalités accuse un retard de 4 à 8 semaines par rapport aux déploiements directs d'OpenAI. En avril 2026, le support MCP sur Azure est en preview. Consultez Microsoft Learn pour les particularités Azure actuelles avant de mettre en production.

La Responses API fonctionne-t-elle avec les serveurs MCP ?

Oui — les serveurs MCP (Model Context Protocol) distants sont un type d'outil de première classe. Ajoutez {"type": "mcp", "server_url": "...", "server_label": "..."} à votre tableau tools et le modèle découvre et appelle le catalogue d'outils du serveur comme tout outil intégré. Utilisez require_approval: "always" en production pour la sécurité.

Conclusion

Vous avez maintenant le tableau complet de la Responses API : en quoi elle diffère de Chat Completions, comment effectuer votre premier appel, comment câbler les outils intégrés, et comment migrer un projet Chat Completions existant en trois étapes. Quelques points à retenir :

• Construisez d'abord, optimisez ensuite. Commencez par l'exemple hello-world, ajoutez un outil intégré, puis ajoutez l'état avec previous_response_id.
• Migrez progressivement. Utilisez un feature flag, journalisez les deux formes de réponse, basculez à 100 % seulement après vérification de la parité.
• Intégrez MCP. C'est la frontière de 2026 — la plupart des éditeurs s'empressent d'exposer des endpoints MCP, et la Responses API est la façon la plus propre de les consommer.

Chez Techsy, nous aidons les équipes à déployer des intégrations OpenAI de niveau production — y compris les déploiements de la Responses API et les migrations depuis Chat Completions. Obtenez une consultation gratuite.

Par l'équipe éditoriale Techsy — ingénieurs en production qui déploient des intégrations OpenAI depuis 2024. Dernière mise à jour : 25 avril 2026.