Comment utiliser l'API GPT-5.6 : Sol, Terra et Luna

OpenAI a rendu GPT-5.6 généralement disponible le 9 juillet 2026, et l'accès à l'API est en libre-service : tout compte API peut l'appeler dès aujourd'hui, sans liste d'attente ni restriction de plan. La prévisualisation limitée qui s'est déroulée jusqu'à début juillet est de l'histoire ancienne. Ce qui a changé pour les développeurs, c'est la forme du lancement lui-même. Au lieu d'un seul modèle, vous en obtenez trois : Sol, Terra et Luna, chacun avec son propre prix, plus six niveaux d'effort de raisonnement et des contrôles explicites de mise en cache des invites.

Cela représente plus de décisions qu'un simple échange de modèle, et les choix par défaut que vous faites la première semaine ont tendance à perdurer. Ce guide explique les identifiants de modèle et quand choisir chacun d'eux, votre première requête en Python et curl, l'effort de raisonnement, la configuration de la mise en cache, la nouvelle interface de l'API Responses, et comment migrer depuis GPT-5.5 sans surprises. Si vous voulez un aperçu complet du niveau phare en premier lieu, la présentation de GPT-5.6 Sol couvre le positionnement et les benchmarks ; cet article reste pratique.

À la fin, vous aurez des appels fonctionnels vers les trois niveaux et un moyen reproductible de les comparer sur vos propres invites dans Apidog, afin que les décisions de coût et de qualité proviennent de vos données plutôt que de l'annonce de lancement.

EN BREF

Trois identifiants de modèle, une génération : gpt-5.6-sol (raisonnement le plus profond), gpt-5.6-terra (équilibré), gpt-5.6-luna (le plus rapide et le moins cher). L'alias simple gpt-5.6 redirige vers Sol.
L'accès à l'API est en libre-service pour tout compte API OpenAI. Aucune restriction ne subsiste.
Prix par million de tokens : Sol 5 $ en entrée / 30 $ en sortie, Terra 2,50 $ / 15 $, Luna 1 $ / 6 $.
L'effort de raisonnement a six niveaux, de none à max. Le mode Pro est un paramètre (reasoning.mode: "pro") sur les trois modèles, pas un modèle distinct.
La mise en cache explicite des invites est arrivée : prompt_cache_options.mode: "explicit" plus un ttl. Les écritures sont facturées à 1,25x, les lectures conservent la réduction de 90 %, et les caches vivent au moins 30 minutes.
Migrer de GPT-5.5 est une passe d'ajustement : testez un niveau d'effort inférieur et supprimez les directives de concision de vos invites.

Les trois identifiants de modèle et quand choisir chacun

GPT-5.6 rompt avec la nomenclature habituelle d'OpenAI. Le nombre est la génération ; Sol, Terra et Luna sont des niveaux de capacité durables qui progresseront à leur propre rythme, comme le détaille la couverture de lancement de MarkTechPost. Le niveau que vous standardisez aujourd'hui conservera sa signification à la prochaine génération.

ID du modèle	Niveau	Entrée / sortie par 1M de tokens	À utiliser pour
`gpt-5.6-sol`	Phare	5 $ / 30 $	Raisonnement profond, orchestration d'agents, débogage difficile
`gpt-5.6-terra`	Équilibré	2,50 $ / 15 $	Fonctionnalités produit courantes, tâches de classe GPT-5.5 à moindre coût
`gpt-5.6-luna`	Rapide	1 $ / 6 $	Classification, extraction, routage, rédaction de premier jet

Sol est le modèle phare. OpenAI rapporte qu'il atteint environ 53 au dernier examen des agents contre 46,9 pour GPT-5.5, donc considérez cela comme une affirmation du jour du lancement et vérifiez-la sur vos propres tâches. Terra est le choix pragmatique : OpenAI le positionne comme compétitif avec GPT-5.5 pour environ la moitié du coût. Luna existe pour les tâches à fort volume et sensibles à la latence, où l'économie unitaire prime sur la profondeur.

Un défaut sensé : prototypez sur Terra, passez à Sol seulement lorsque Terra échoue de manière mesurable, et redirigez les chemins à fort volume vers Luna une fois l'invite stable. La répartition des prix de GPT-5.6 explique plus en détail comment ces taux se comparent à travers les générations et les concurrents.

Un alias à connaître : gpt-5.6 sans suffixe redirige vers Sol. Ancrez les ID de niveau explicites dans le code de production afin que chaque appel indique exactement son coût.

Votre première requête

Les identifiants de modèle ci-dessous correspondent mot pour mot à la documentation développeur d'OpenAI. Vous avez besoin d'une clé API OpenAI avec la facturation activée ; rien d'autre.

Les complétions de chat fonctionnent sans changement, donc le code existant n'a besoin que d'un changement de modèle :

from openai import OpenAI

client = OpenAI()

response = client.chat.completions.create(
    model="gpt-5.6-sol",
    messages=[
        {"role": "system", "content": "You are a concise code reviewer."},
        {"role": "user", "content": "Review this for edge cases: def parse_price(raw): return float(raw.strip('$'))"}
    ]
)

print(response.choices[0].message.content)

Le même appel en curl :

curl https://api.openai.com/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -d '{
    "model": "gpt-5.6-sol",
    "messages": [
      {"role": "user", "content": "Explain idempotency keys in one paragraph."}
    ]
  }'

Pour les nouvelles constructions, ciblez plutôt l'API Responses. Chaque ajout GA y réside, et il prend un bloc de raisonnement directement :

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Summarize the trade-offs between webhooks and polling.",
    reasoning={"effort": "low"}
)

print(response.output_text)

Exécutez la même invite sur les trois niveaux avant d'écrire une autre ligne de code d'intégration. Les différences de ton, de longueur et de latence sont plus faciles à ressentir qu'à lire.

Choisir un effort de raisonnement

GPT-5.6 expose six niveaux d'effort de raisonnement : none, low, medium, high, xhigh et max.

none désactive le raisonnement. Utilisez-le lorsque la tâche est mécanique et que la latence importe plus que la profondeur : reformatage, extraction selon un schéma clair, remplissage de modèle. Luna avec none se comporte comme un modèle de complétion classique rapide, et ce jumelage est l'endroit où son tarif d'entrée de 1 $ brille.

max se situe à l'autre extrémité. Réservez-le pour les problèmes où une mauvaise réponse coûte plus cher qu'une réponse lente : bogues de concurrence subtils, revues d'architecture, planification en plusieurs étapes. Attendez-vous à des attentes plus longues et à une facture plus élevée.

La plupart des charges de travail se situent au milieu. Commencez par medium, déplacez-vous d'un niveau à la fois, et mesurez la qualité avant d'accepter le coût supplémentaire de la montée en gamme. Descendre est souvent gratuit : les propres directives de migration d'OpenAI stipulent que de nombreuses charges de travail GPT-5.5 maintiennent la qualité un niveau plus bas sur GPT-5.6.

Le mode Pro est distinct de l'effort. Définissez reasoning.mode: "pro" et le modèle priorise la qualité de la réponse sur la vitesse. Il fonctionne sur les trois niveaux et c'est un paramètre, pas un identifiant de modèle différent, il n'y a donc pas de slug spécifique au mode Pro à chercher. Les charges de travail où la qualité prime, comme les résumés juridiques ou les analyses post-incident, sont son domaine. Pour la forme et les contraintes exactes de la requête, consultez la référence de l'API OpenAI.

Configurer la mise en cache des invites

GPT-5.6 ajoute un contrôle explicite du cache. Définissez prompt_cache_options.mode sur "explicit" et vous décidez ce qui est mis en cache au lieu de vous fier à la détection automatique des préfixes :

response = client.responses.create(
    model="gpt-5.6-luna",
    input=[
        {"role": "system", "content": SUPPORT_PLAYBOOK},
        {"role": "user", "content": ticket_text}
    ],
    prompt_cache_options={"mode": "explicit"}
)

Un champ ttl sur le même objet d'options définit la durée pendant laquelle le préfixe mis en cache reste chaud ; quoi que vous demandiez, le minimum est de 30 minutes. Les valeurs ttl acceptées et les règles de placement des points d'arrêt se trouvent dans la référence de l'API OpenAI.

L'économie est simple. Les écritures de cache sont facturées à 1,25 fois le taux d'entrée non mis en cache. Les lectures de cache conservent la réduction de 90 %. La mise en cache est donc rentable dès la deuxième utilisation : deux passages non mis en cache sur un préfixe coûtent 2,0 fois son prix par token, tandis qu'une écriture plus une lecture coûtent 1,35 fois.

Un exemple concret. Supposons qu'un bot d'assistance envoie un playbook de 40 000 tokens à chaque appel Luna. Sans cache, ce préfixe coûte 0,04 $ par appel au taux d'entrée de 1 $ par million de tokens de Luna. Avec une mise en cache explicite, le premier appel coûte 0,05 $ pour l'écriture, et chaque lecture dans le TTL coûte 0,004 $. Sur une rafale de 100 appels, cela représente 0,45 $ au lieu de 4,00 $, soit environ 89 % de réduction sur la partie statique de votre facture. La durée de vie minimale de 30 minutes signifie qu'un trafic en rafale avec des pauses de moins d'une demi-heure continue également de bénéficier de lectures bon marché.

Règle générale : toute invite avec un grand préfixe statique réutilisé au moins deux fois dans le TTL doit être exécutée en mode explicite.

Nouveautés de l'API Responses en disponibilité générale

Trois ajouts ont été livrés avec la disponibilité générale, tous dans l'API Responses :

Appel d'outils programmatique. Au lieu de la danse aller-retour où le modèle émet un appel d'outil, attend votre résultat, puis émet le suivant, le modèle écrit du JavaScript qui orchestre vos outils. Ce code s'exécute dans un environnement d'exécution V8 isolé sans accès réseau, il peut donc boucler, brancher et combiner les résultats d'outils sans que votre serveur ne transmette des messages.
Multi-agent, en bêta. Une requête peut répartir le travail entre des sous-agents qui s'exécutent en parallèle, utile lorsqu'une tâche se divise en parties indépendantes.
Raisonnement persistant. Le contexte de raisonnement est transmis entre les tours via reasoning.context, de sorte qu'un agent multi-tours ne reconstruit pas sa chaîne de pensée à partir de zéro à chaque appel.

Il existe également de nouveaux paramètres de détail de la vision, original et auto, qui préservent les dimensions originales de l'image. Les formes de requête et les paramètres pour tous ceux-ci se trouvent dans la référence de l'API d'OpenAI ; les mécanismes ci-dessus sont ce sur quoi il faut baser la conception.

Migration depuis GPT-5.5

Les directives d'OpenAI sont claires : traitez la migration comme une passe d'ajustement, et pas seulement un changement de slug de modèle. Si votre intégration suit le flux de travail de notre guide de l'API GPT-5.5, trois ajustements sont importants.

Premièrement, testez votre effort de raisonnement actuel et un niveau inférieur. GPT-5.6 maintient souvent la qualité un cran en dessous, ce qui représente une réduction directe des coûts sur le même trafic.

Deuxièmement, attendez-vous à des réponses plus courtes. GPT-5.6 produit une sortie nettement plus concise avec moins d'introductions génériques. Si vos invites contiennent des directives comme "soyez concis" ou "sautez le préambule", supprimez-les et re-testez, car des instructions de concision empilées peuvent désormais aller trop loin. L'article de Simon Willison du jour du lancement est une lecture indépendante utile sur le comportement de la famille en pratique.

Troisièmement, surveillez l'utilisation des tokens mis en cache dans vos réponses pendant que vous ajustez, et évaluez un ensemble de tâches représentatives avant de basculer le trafic de production. Un résultat comparable sur Terra à la moitié du prix de GPT-5.5 est le résultat à vérifier en premier.

Tester l'API dans Apidog

Curl prouve que le point de terminaison fonctionne. Choisir entre trois niveaux nécessite quelque chose de reproductible. Téléchargez Apidog et configurez un petit banc de comparaison :

Créez un environnement avec votre OPENAI_API_KEY plus trois variables : MODEL_SOL=gpt-5.6-sol, MODEL_TERRA=gpt-5.6-terra, MODEL_LUNA=gpt-5.6-luna.
Créez une requête POST vers l'API et référencez {{MODEL_SOL}} dans le corps, puis dupliquez-la deux fois et remplacez par les autres variables.
Envoyez la même invite de forme de production à travers les trois et lisez les réponses côte à côte.
Vérifiez le bloc d'utilisation dans chaque réponse. Multipliez le nombre de tokens par le taux de chaque niveau et vous obtenez une projection de coût par requête basée sur vos propres invites, et non sur le benchmark de quelqu'un d'autre.

Le même montage s'avère utile lors de l'ajustement de l'effort. Changez le niveau d'effort sur une requête sauvegardée, renvoyez-la, et observez le mouvement des tokens de sortie ; ce nombre multiplié par le taux par token est votre courbe qualité-coût, rendue visible requête par requête.

FAQ

L'API GPT-5.6 est-elle disponible pour tout le monde ?

Oui. Depuis le 9 juillet 2026, tout compte API OpenAI peut appeler les trois modèles en libre-service. La restriction de prévisualisation avant le lancement a été levée avant la disponibilité générale, et l'accès à l'API ne dépend pas de votre plan ChatGPT. Les niveaux de plan ne façonnent que le produit de chat, où les utilisateurs gratuits et Go obtiennent Terra et les plans payants débloquent le sélecteur complet de modèles.

Quelle est la fenêtre contextuelle et la date de coupure des connaissances de GPT-5.6 ?

Selon la documentation préliminaire, la famille dispose d'une fenêtre contextuelle de 1 million de tokens, d'une sortie maximale de 128K, et d'une date de coupure des connaissances au 16 février 2026. La page des modèles d'OpenAI est la source de référence ; considérez ces chiffres comme rapportés jusqu'à ce que vous les confirmiez pour votre compte.

Quelle est la différence entre le mode Pro et Ultra ?

Le mode Pro est un paramètre d'API (reasoning.mode: "pro") qui fonctionne sur les trois modèles et privilégie la qualité de la réponse à la vitesse. Ultra est un paramètre multi-agents qui exécute quatre agents en parallèle par défaut, et il est disponible dans ChatGPT Work sur les plans Pro et Entreprise ainsi que Codex à partir de Plus. La description du mode ultra de GPT-5.6 explique quand la dépense supplémentaire délibérée de tokens en vaut la peine.

Dois-je construire sur les complétions de chat ou l'API Responses ?

Le code existant des complétions de chat continue de fonctionner avec un simple échange d'identifiant de modèle, il n'y a donc pas de réécriture forcée. Les nouvelles constructions devraient cibler l'API Responses : l'appel d'outils programmatique, le multi-agent et le raisonnement persistant y ont tous été livrés, et la documentation de GPT-5.6 d'OpenAI est axée sur elle.

Où cela vous mène

Vous n'avez pas besoin d'un projet de migration pour commencer. Choisissez Terra, exécutez-y une vraie invite de votre produit avec un effort medium, puis descendez d'un niveau et comparez. Connectez la mise en cache explicite si vos invites partagent un grand préfixe statique ; les 89 % d'économie de l'exemple ci-dessus sont typiques de ce qu'une grande invite système peut offrir. Ce n'est qu'alors que vous déciderez où Sol et Luna ont leur place dans votre pile.

Gardez également le banc d'essai de comparaison à trois niveaux. Sol, Terra et Luna progresseront à leurs propres rythmes, de sorte que la prochaine version sera une réexécution des requêtes sauvegardées plutôt qu'un projet de recherche. Apidog conserve ces requêtes, environnements et nombres de tokens en un seul endroit, ce qui transforme chaque futur lancement de modèle en un après-midi de tests au lieu d'une conjecture.

button