Comment utiliser l'API GPT-5.5

GPT-5.5 a été lancé le 23 avril 2026, et la nouvelle pour les développeurs est simple : OpenAI a ouvert le modèle au sein de ChatGPT et Codex le même jour, et s'est engagé à rendre disponibles les API Responses et Chat Completions « très bientôt ». Ce guide couvre les deux aspects : comment appeler GPT-5.5 dès que les clés fonctionnent, et comment les premiers testeurs l'utilisent aujourd'hui via le chemin de connexion Codex.

Vous obtiendrez les structures d'endpoints, l'authentification, des exemples Python et Node, le tableau complet des paramètres, le calcul des prix en mode de réflexion, la gestion des erreurs, et un flux de travail de test dans Apidog qui économise des crédits lorsque vous itérez.

Pour une vue d'ensemble du modèle au niveau produit, consultez Qu'est-ce que GPT-5.5. Pour un chemin purement gratuit, consultez Comment utiliser l'API GPT-5.5 gratuitement.

En bref

• GPT-5.5 est disponible sur les endpoints Responses et Chat Completions ; l'ID du modèle est gpt-5.5. La version Pro est gpt-5.5-pro.
• La tarification de l'API est de 5 $ / M d'entrée et de 30 $ / M de sortie ; la version Pro est de 30 $ / M d'entrée et de 180 $ / M de sortie.
• La fenêtre contextuelle est de 1 M de tokens dans l'API et de 400 K dans l'interface CLI Codex.
• Jusqu'à la fin du déploiement général de l'API, les développeurs peuvent utiliser GPT-5.5 via Codex en se connectant avec un compte ChatGPT.
• Utilisez Apidog pour pré-construire la collection ; la forme de la requête correspond à GPT-5.4 avec un nouvel ID de modèle et un bloc reasoning étendu.

Prérequis

Avant d'envoyer la première requête, préparez quatre éléments :

• Un compte développeur OpenAI avec un niveau facturable. Un abonnement ChatGPT Plus ou Pro est distinct de la facturation de l'API ; vous avez besoin des deux si vous souhaitez un accès à l'interface utilisateur et un accès programmatique.
• Une clé API avec accès à la famille de modèles GPT-5. Les clés spécifiques au projet sont fortement recommandées par rapport aux clés utilisateur pour toute charge de travail en production.
• La version du SDK qui prend en charge gpt-5.5. Sur Python, c'est openai>=2.1.0 ; sur Node, c'est openai@5.1.0 ou plus récent.
• Un client API capable de rejouer des requêtes sans inonder le terminal. curl fonctionne pour un seul appel ; après cela, passez à Apidog ou similaire.

Exportez votre clé une fois :

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

Endpoint et authentification

GPT-5.5 utilise les deux mêmes endpoints que le reste de la famille GPT-5.

POST https://api.openai.com/v1/responses
POST https://api.openai.com/v1/chat/completions

L'API Responses est la surface plus récente d'OpenAI, consciente des outils, et c'est là que le mode de réflexion, la recherche web et l'utilisation de l'ordinateur s'intègrent proprement. Chat Completions fonctionne toujours et prend en charge la plupart des intégrations héritées.

L'authentification se fait par un jeton bearer. Chaque requête prend un corps JSON avec l'ID du modèle, le prompt ou le tableau de messages, et les paramètres que vous souhaitez.

curl https://api.openai.com/v1/responses \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5.5",
    "input": "Summarize the last 10 releases of the openai/codex repo in three bullets.",
    "reasoning": { "effort": "medium" }
  }'

Si l'appel réussit, vous obtenez un objet JSON avec un tableau output de messages et un bloc usage décomposé en tokens d'entrée, de sortie et de raisonnement. Les échecs renvoient l'enveloppe OpenAI standard avec un code et un message lisible par l'homme ; le tableau d'erreurs à la fin de ce guide couvre ceux que vous rencontrerez en premier.

Paramètres de requête

Chaque champ dans le corps correspond soit à un coût, soit à un comportement. Voici la carte complète pour gpt-5.5.

Les trois champs qui influencent le plus le coût sont reasoning.effort, max_output_tokens et tools. Les exécutions de style "Réflexion" avec reasoning.effort: "high" ou "xhigh" peuvent facilement multiplier par 3 à 8 le nombre de tokens de sortie d'une exécution low.

Exemple Python

La structure du SDK pour GPT-5.5 suit l'API Responses 5.4 ; la seule différence est l'ID du modèle et la plage plus étendue de reasoning.effort.

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5.5",
    input=[
        {
            "role": "system",
            "content": "You are a senior Go engineer. Answer in terse, runnable code.",
        },
        {
            "role": "user",
            "content": (
                "Write a worker pool with bounded concurrency and a context "
                "cancellation path. No third-party deps."
            ),
        },
    ],
    reasoning={"effort": "medium"},
    max_output_tokens=4000,
)

print(response.output_text)
print(response.usage.model_dump())

Deux points à noter :

• response.output_text aplatit le tableau output pour vous. Si vous avez besoin des événements structurés (appels d'outils, traces de raisonnement, citations), lisez response.output directement.
• usage renvoie désormais input_tokens, output_tokens et reasoning_tokens comme compteurs séparés. La facturation est basée sur les trois.

Exemple Node

import OpenAI from "openai";

const client = new OpenAI();

const response = await client.responses.create({
  model: "gpt-5.5",
  input: [
    { role: "system", content: "You are a careful reviewer." },
    {
      role: "user",
      content:
        "Review this migration and flag any operation that would lock a write-heavy table for more than 200 ms.",
    },
  ],
  reasoning: { effort: "high" },
  tools: [{ type: "file_search" }],
  max_output_tokens: 6000,
});

console.log(response.output_text);
console.log(response.usage);

Définissez reasoning.effort sur high lorsque la tâche est de type révision et que le coût d'un problème manqué est supérieur au coût de quelques centimes supplémentaires en tokens de raisonnement.

Mode de réflexion

Le mode de réflexion de GPT-5.5 n'est pas un ID de modèle différent ; il s'agit du modèle standard gpt-5.5 exécuté avec reasoning.effort défini sur high ou xhigh, associé à un budget max_output_tokens plus long. L'interface utilisateur de ChatGPT d'OpenAI l'expose comme un interrupteur ; sur l'API, vous le contrôlez par requête.

Deux règles empiriques :

• Utilisez medium par défaut. Cela couvre la plupart des travaux agentiques, du débogage multi-fichiers et de la génération de documents. Les coûts restent proches de ceux de GPT-5.4.
• Réservez high et xhigh pour la recherche, les révisions critiques en termes de correction et les longues chaînes d'outils. Prévoyez 3 à 8 fois le nombre de tokens de sortie et chronométrez la réponse plutôt que de supposer qu'elle sera renvoyée en moins de 30 secondes.

Si votre requête implique computer_use ou de longues chaînes de recherche web, l'effort de niveau "Réflexion" vaut l'investissement ; la réduction des hallucinations citée par OpenAI dans le billet de lancement se manifeste principalement dans ces flux de travail.

Sortie structurée

La sortie JSON stricte est la valeur par défaut sur GPT-5.5. Passez un schéma et le SDK refusera de renvoyer du JSON mal formé.

response = client.responses.create(
    model="gpt-5.5",
    input="Extract the title, speaker, and start time from this transcript chunk.",
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "session_extract",
            "strict": True,
            "schema": {
                "type": "object",
                "required": ["title", "speaker", "start_time"],
                "properties": {
                    "title": {"type": "string"},
                    "speaker": {"type": "string"},
                    "start_time": {"type": "string", "format": "date-time"},
                },
            },
        },
    },
)

Pour toute pipeline qui alimente du code en aval, définissez toujours un schéma. Cela ne coûte rien au niveau des tokens et supprime la boucle de réessai que vous écririez autrement autour d'une sortie mal formée.

Utilisation d'outils et agents

L'API Responses expose cinq types d'outils propriétaires :

• web_search — recherche en temps réel, désormais avec des citations par résultat.
• file_search — recherche vectorielle sur les fichiers téléchargés.
• code_interpreter — Python en bac à sable.
• computer_use — souris, clavier et navigateur via la pile Operator.
• function — vos propres rappels.

L'amélioration de GPT-5.5 par rapport à la version 5.4 ici ne réside pas dans la liste des outils ; c'est la propension du modèle à les enchaîner sans supervision. Lors des tests effectués avec la suite de reproduction de The Decoder, GPT-5.5 a complété 11 % de chaînes d'outils multi-étapes supplémentaires sans intervention de l'utilisateur par rapport à la version 5.4 avec le même prompt.

Gestion des erreurs et réessais

Attendez-vous à rencontrer quatre codes d'erreur suffisamment souvent pour les gérer par leur nom.

Les tokens de raisonnement sont comptabilisés dans la fenêtre contextuelle. Un appel avec reasoning.effort: "xhigh" sur une entrée de 900 K tokens atteindra 400 pour un dépassement de contexte même si votre message utilisateur est court.

Flux de travail de test avec Apidog

Les appels GPT-5.5 sont suffisamment coûteux pour que vous ne vouliez pas découvrir un bug de schéma en relançant le prompt 20 fois. Le flux de travail qui gaspille le moins de tokens :

1. Construisez la requête une fois dans Apidog, enregistrez-la comme entrée de collection, et étiquetez l'environnement (clé dev, staging, prod).
2. Utilisez le serveur de maquette intégré pour rejouer la dernière réponse réelle pendant que vous itérez sur le code en aval.
3. Passez à la clé en direct uniquement lorsque le schéma est stable.

Apidog propose également une intégration Claude Code et Cursor, de sorte que la même collection est accessible depuis n'importe quel agent de niveau éditeur que vous utilisez. Consultez notre guide pratique Apidog dans VS Code et la comparaison Apidog vs. Postman pour la configuration complète.

Appeler GPT-5.5 avant que l'API ne soit générale

Jusqu'à ce qu'OpenAI termine le déploiement de l'API Responses, le chemin pratique pour les développeurs qui souhaitent tester GPT-5.5 est le flux de connexion Codex. Le guide gratuit Codex explique comment installer l'interface CLI, s'authentifier avec un compte ChatGPT et sélectionner le modèle.

FAQ

Existe-t-il un gpt-5.5-mini ? Pas au lancement. OpenAI a conservé gpt-5.4-mini comme SKU optimisé en termes de coût.

Quelle est la fenêtre contextuelle ? 1 M de tokens dans l'API. 400 K dans l'interface CLI Codex. Les deux incluent les tokens de raisonnement.

Dois-je réécrire mon code GPT-5.4 ? Non. Échangez l'ID du modèle, élargissez max_output_tokens si vous souhaitez une sortie de niveau "Réflexion", et réajustez reasoning.effort pour votre charge de travail.

Comment réduire les coûts ? Trois leviers : Batch (50 % de réduction), Flex (50 % de réduction, file d'attente plus lente) et des schémas stricts pour éliminer les boucles de réessai. Le calcul complet des coûts se trouve dans la répartition des prix de GPT-5.5.

Où puis-je surveiller l'annonce de la disponibilité générale de l'API ? La communauté des développeurs OpenAI et la page de tarification de l'API OpenAI sont les signaux publics les plus rapides.