DEV Community

Cover image for Comment utiliser l'API GPT-5.5
Antoine Laurent
Antoine Laurent

Posted on • Originally published at apidog.com

Comment utiliser l'API GPT-5.5

GPT-5.5 a été lancé le 23 avril 2026. Pour les développeurs, la nouveauté clé : OpenAI a ouvert le modèle dans ChatGPT et Codex dès le premier jour, et promet l'accès aux endpoints API Responses et Chat Completions « très bientôt ». Ce guide explique comment appeler GPT-5.5 dès que les clés sont actives, et comment l'utiliser aujourd'hui via Codex.

Essayez Apidog dès aujourd'hui

Vous trouverez ici la structure des endpoints, l’authentification, des exemples concrets en Python et Node.js, le tableau complet des paramètres, le calcul des coûts en mode réflexion, la gestion des erreurs, et un workflow de test optimisé dans Apidog pour économiser vos crédits lors des itérations.

Pour une vue d’ensemble du modèle côté produit, consultez Qu'est-ce que GPT-5.5. Pour une méthode gratuite, lisez Comment utiliser l'API GPT-5.5 gratuitement.

En bref

  • Endpoints : Responses et Chat Completions. ID de modèle : gpt-5.5. Version Pro : gpt-5.5-pro.
  • Tarification API : 5 $ / M tokens entrée, 30 $ / M tokens sortie. Pro : 30 $ / M entrée, 180 $ / M sortie.
  • Fenêtre contextuelle : 1 M tokens (API), 400 K (CLI Codex).
  • Tant que l’API n’est pas ouverte à tous, utilisez GPT-5.5 via Codex en vous connectant avec un compte ChatGPT.
  • Utilisez Apidog pour préconstruire votre collection. La requête ressemble à GPT-5.4, mais avec un nouvel ID de modèle et un bloc reasoning étendu.

Prérequis

Avant d’envoyer votre première requête, préparez :

  • Compte développeur OpenAI avec facturation activée. Un abonnement ChatGPT Plus/Pro ne remplace pas la facturation API.
  • Clé API avec accès à GPT-5. Privilégiez les clés projet pour la production.
  • SDK compatible gpt-5.5 : Python openai>=2.1.0, Node openai@5.1.0 ou plus récent.
  • Client API capable de rejouer les requêtes (curl pour le premier appel, puis outil type Apidog pour l’itération).

Exportez la clé une fois :

export OPENAI_API_KEY="sk-proj-..."
Enter fullscreen mode Exit fullscreen mode

Endpoint et authentification

GPT-5.5 s’utilise sur les mêmes endpoints que GPT-5 :

POST https://api.openai.com/v1/responses
POST https://api.openai.com/v1/chat/completions
Enter fullscreen mode Exit fullscreen mode

L’API Responses est la plus récente, supporte le mode réflexion, la recherche web et l’usage de l’ordinateur. Chat Completions reste compatible avec les intégrations historiques.

Authentification via Bearer token. Chaque requête inclut un JSON avec l’ID du modèle, le prompt ou tableau de messages, et les paramètres.

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" }
  }'
Enter fullscreen mode Exit fullscreen mode

Réponse : un objet JSON avec un tableau output et un bloc usage détaillant les tokens (entrée, sortie, raisonnement). Les erreurs renvoient un code et un message lisible ; voir la section gestion des erreurs.

Paramètres de requête

Chaque champ du body contrôle coût ou comportement. Carte complète pour gpt-5.5 :

Paramètre Type Valeurs Notes
model string gpt-5.5, gpt-5.5-pro Obligatoire. Pro = coût x6.
input / messages string/array prompt ou tableau de chat Obligatoire. input pour Responses, messages pour Chat Completions.
reasoning.effort string none, low, medium, high, xhigh Défaut : low. xhigh = "Réflexion" (coût tokens élevé).
max_output_tokens int 1 – 128000 Limite stricte de sortie (hors tokens de raisonnement).
tools array Function, web_search, file_search, computer_use, code_interpreter Définitions d’outils ; le modèle les enchaîne dynamiquement.
tool_choice string/object auto, none, ou outil nommé Force un outil précis si besoin.
response_format object { "type": "json_schema", "schema": {...} } Sortie structurée ; strict par défaut.
stream bool true / false Events serveur. Tokens de raisonnement en events séparés.
user string libre Pour détection d’abus ; passer un ID utilisateur haché.
metadata object 16 paires clé-valeur max Apparaît dans le dashboard OpenAI.
seed int 32 bits Déterminisme doux.
temperature number 0 – 2 Ignoré si reasoning.effort >= medium.

Les champs influant le plus sur le coût : reasoning.effort, max_output_tokens, tools. Les modes "Réflexion" (high ou xhigh) peuvent multiplier par 3 à 8 le coût par rapport à low.

Exemple Python

Utilisation du SDK Python (structure identique à GPT-5.4, seul l’ID change et la plage reasoning.effort s’étend) :

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())
Enter fullscreen mode Exit fullscreen mode

Points clés :

  • response.output_text aplatit le tableau output. Pour des events structurés (appels outils, traces raisonnement, citations), lisez response.output.
  • usage fournit maintenant input_tokens, output_tokens, reasoning_tokens. La facturation est basée sur ces 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);
Enter fullscreen mode Exit fullscreen mode

Définissez reasoning.effort: "high" pour les tâches de revue critique où un bug non détecté coûte plus cher que quelques centimes de tokens supplémentaires.

Mode de réflexion

Le mode de réflexion n'est pas un modèle distinct, mais une configuration : utilisez gpt-5.5 avec reasoning.effort: "high" ou "xhigh" + un max_output_tokens élevé. L’UI ChatGPT expose un switch ; en API, c’est vous qui le gérez.

Bonnes pratiques :

  • Par défaut, utilisez medium : couvre la plupart des tâches agentiques, débogage multi-fichiers, génération de docs.
  • Réservez high et xhigh pour recherche, révisions critiques, longues chaînes d’outils. Prévoyez de 3 à 8x plus de tokens, et surveillez le temps de réponse.

Pour des tâches complexes (computer_use, longues chaînes web), l’effort "Réflexion" réduit les hallucinations et améliore la fiabilité, comme documenté par OpenAI dans leur billet de lancement.

Sortie structurée

Le JSON strict est par défaut sur GPT-5.5. Passez un schéma pour garantir la structure :

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"},
                },
            },
        },
    },
)
Enter fullscreen mode Exit fullscreen mode

Pour toute pipeline downstream, définissez toujours un schéma pour éviter les boucles de retry sur JSON mal formé.

Utilisation d’outils et agents

L’API Responses expose 5 types d’outils :

  • web_search — recherche temps réel, avec citations.
  • file_search — recherche vectorielle sur fichiers uploadés.
  • code_interpreter — exécution Python sandboxée.
  • computer_use — souris, clavier et navigateur via Operator.
  • function — rappels custom.

L’avantage de GPT-5.5 : meilleure aptitude à chaîner et exploiter ces outils sans supervision. Lors des tests (The Decoder), GPT-5.5 a complété 11% de chaînes multi-étapes de plus que la 5.4, à prompt égal.

Gestion des erreurs et réessais

Quatre erreurs à traiter explicitement :

Code Signification Réessayer ?
429 rate_limit_exceeded Limite minute/jour atteinte Oui, backoff exponentiel + jitter
400 context_length_exceeded Entrée + sortie + raisonnement > 1M tokens Non, raccourcir l’entrée
500 server_error Erreur transitoire OpenAI Oui, jusqu’à 3 tentatives
403 policy_violation Rejet pour violation de politique Non, réécrire le prompt

Les tokens de raisonnement comptent dans la fenêtre contextuelle. Un appel reasoning.effort: "xhigh" sur 900K tokens d’entrée dépassera 1M avec peu de sortie.

Flux de travail de test avec Apidog

Tester GPT-5.5 coûte cher : évitez de brûler 20 prompts pour un bug de schéma. Voici le workflow le plus efficient :

  1. Construisez la requête une fois dans Apidog, enregistrez-la dans une collection, taggez l’environnement (dev, staging, prod).
  2. Utilisez le mock server intégré pour rejouer la dernière réponse réelle pendant vos itérations backend/front.
  3. Passez en clé live uniquement lorsque le schéma est validé.

Apidog propose aussi une intégration Claude Code et Cursor : la même collection est accessible depuis votre éditeur. Lisez le guide Apidog dans VS Code et la comparaison Apidog vs. Postman pour la config complète.

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

Tant que l’API Responses est en déploiement progressif, le chemin pour tester GPT-5.5 est via Codex. Le guide Codex gratuit explique comment installer la CLI, s’authentifier avec ChatGPT et sélectionner le modèle.

FAQ

Existe-t-il un gpt-5.5-mini ?

Non, pas au lancement. OpenAI maintient gpt-5.4-mini comme version optimisée coût.

Quelle est la fenêtre contextuelle ?

1M tokens (API), 400K (CLI Codex), tokens de raisonnement inclus.

Dois-je réécrire mon code GPT-5.4 ?

Non. Remplacez l’ID de modèle, augmentez max_output_tokens pour la réflexion, ajustez reasoning.effort selon la charge.

Comment réduire les coûts ?

Trois leviers : Batch (50% de réduction), Flex (50% avec une file plus lente), schémas stricts pour éviter les retries. Le calcul détaillé est disponible dans la répartition des prix GPT-5.5.

Où surveiller l’annonce de disponibilité générale de l’API ?

Suivez la communauté développeurs OpenAI et la page de tarification OpenAI.
Enter fullscreen mode Exit fullscreen mode

Top comments (0)