GPT-6 Astra pour développeurs : API, tarification, contexte 1M et migration depuis GPT-5.6 Sol

GPT-6 Astra : guide pratique de l’API, des coûts et de la migration

OpenAI a lancé GPT-6 Astra le 3 septembre 2026, d'abord auprès d'un nombre limité d'organisations, puis dans les jours suivants pour tous les utilisateurs de ChatGPT Plus, Pro, Business et Enterprise, ainsi que sur l'API OpenAI, Microsoft Azure et AWS Bedrock. Son ID est gpt-6-astra. Il dispose d'une fenêtre contextuelle de 1 050 000 jetons et OpenAI le présente comme son « meilleur modèle pour l'ingénierie logicielle à ce jour ». C'est également le premier modèle classé Critique par OpenAI pour ses capacités de cybersécurité, ce qui influence son comportement dans l'API.

Essayez Apidog dès aujourd'hui

Ce guide couvre l'ID du modèle, les points d'accès, la première requête, les cinq niveaux d'effort de raisonnement, les tarifs — y compris les contextes longs et le mode Rapide — ainsi que les changements qui peuvent casser une intégration GPT-5.6 Sol. L'objectif : déterminer avec vos propres données si Astra justifie un prix 2,5 fois supérieur au tarif promotionnel de Sol.

La page du modèle OpenAI reste la référence pour les chiffres. Pour une expérience pratique de deux jours, consultez notre prise en main de GPT-6 Astra.

En bref

• ID : gpt-6-astra, un seul instantané. Disponible avec Chat Completions, Responses et Batch. Pas de Realtime, d'Assistants ni de fine-tuning.
• Contexte : 1 050 000 jetons ; sortie maximale : 128 000 jetons ; connaissances arrêtées au 30 avril 2026. Entrée texte et image, sortie texte.
• Tarification standard : 10 $ en entrée, 1 $ en lecture de cache, 12,50 $ en écriture de cache et 50 $ en sortie par million de jetons.
• Au-delà de 272 000 jetons d'entrée, les tarifs passent à 20 $ / 2 $ / 75 $. Batch et Flex coûtent moitié moins ; le mode Rapide coûte deux fois plus.
• Effort de raisonnement : low, medium, high, xhigh et max. none et minimal ont disparu.
• Migration depuis Sol : temperature, top_p et logprobs sont supprimés ; prompt_cache_retention devient prompt_cache_options.ttl.
• GPT-5.6 Sol reste à 4 $ en entrée et 20 $ en sortie au minimum jusqu'au 21 novembre 2026. Astra coûte donc 2,5 fois plus cher sur ces deux postes.

GPT-6 Astra en un coup d’œil

Élément	Valeur
ID du modèle	gpt-6-astra
Fenêtre contextuelle	1 050 000 jetons
Sortie maximale	128 000 jetons
Coupure des connaissances	30 avril 2026
Modalités	Entrée : texte, image. Sortie : texte
Points d'accès	Chat Completions, Responses, Batch
Non supporté	Realtime, Assistants, fine-tuning
Fonctionnalités	Streaming, sorties structurées, appel de fonction, recherche de fichiers, recherche web, mise en cache de prompts, entrée d'images
Outils intégrés	Utilisation d'ordinateur, recherche web, recherche de fichiers, interpréteur de code, génération d'images
Effort de raisonnement	low, medium, high, xhigh, max
Limites de débit — Tier 5	15 000 RPM, 40 000 000 TPM
Également disponible sur	Microsoft Azure, AWS Bedrock ; OpenRouter sous openai/gpt-6-astra
Gestion des données	Rétention nulle pour les clients API éligibles

Dans les espaces de travail d'entreprise, Astra est désactivé par défaut : un administrateur doit l'activer. Sur ChatGPT, son utilisation est décomptée de l'allocation existante. Les forfaits Pro, Business et Enterprise reçoivent également GPT-6 Astra Pro.

Votre première requête

L'API Responses est l'interface principale d'Astra et elle est obligatoire pour utiliser les outils. Voici un appel Python minimal :

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-6-astra",
    reasoning={"effort": "medium"},
    input=[
        {"role": "developer", "content": "You are a senior API engineer. Bias towards action. Ask only when the answer would change the result."},
        {"role": "user", "content": "Review this OpenAPI operation for auth and validation gaps, then propose three test cases."},
    ],
)

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

La même requête avec curl :

curl https://api.openai.com/v1/responses \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-6-astra",
    "reasoning": {"effort": "medium"},
    "input": "Review this OpenAPI operation for auth and validation gaps, then propose three test cases."
  }'

Chat Completions reste disponible pour le texte brut : changez le point d'accès et la structure du message, puis supprimez temperature et top_p. Dès que vous avez besoin d'un appel de fonction ou d'un outil intégré, utilisez Responses. Consultez le guide de l'API Responses pour les détails de format.

Le message du développeur est particulièrement important avec Astra. Les directives de modèle d'OpenAI indiquent qu'il demande plus facilement des éclaircissements que ses prédécesseurs. Demandez-lui donc de privilégier l'action. Il est aussi plus sensible aux instructions présentes dans les compétences et les fichiers joints : précisez que les instructions de l'utilisateur prévalent en cas de conflit.

Enfin, Astra privilégie par défaut les listes et les tableaux. Demandez explicitement de la prose lorsque votre interface l'exige.

Effort de raisonnement : cinq niveaux, pas de none

GPT-5.6 exposait six niveaux, de none à max. Astra en propose cinq :

low, medium, high, xhigh, max

Si votre intégration utilise actuellement none ou minimal, OpenAI recommande de passer à low et d'évaluer le résultat. Les autres réglages restent inchangés.

Cette suppression concerne la partie la moins coûteuse des charges de travail. Luna à none était l'option rapide de complétion classique de la famille GPT-5.6 ; Astra n'a pas d'équivalent direct. Astra reste un modèle de raisonnement quel que soit le réglage. Pour les opérations mécaniques, routez plutôt les requêtes vers GPT-5.6 Terra ou Luna et réservez Astra aux tâches difficiles.

À l'autre extrémité, max correspond au niveau utilisé pour les benchmarks de lancement — OpenAI indique que les scores sont maximaux à cet effort. Artificial Analysis a mesuré un temps jusqu'au premier jeton supérieur à sept minutes dans ce mode. Prévoyez donc un budget de latence avant de prévoir un budget de jetons.

Ce que coûte GPT-6 Astra

Tarifs par million de jetons, selon la page de tarification d'OpenAI :

Niveau	Entrée	Entrée en cache	Sortie
Standard	10,00 $	1,00 $	50,00 $
Standard, contexte long — plus de 272K jetons d'entrée	20,00 $	2,00 $	75,00 $
Batch / Flex	5,00 $	0,50 $	25,00 $
Batch, contexte long	10,00 $	1,00 $	37,50 $
Mode Rapide	20,00 $	2,00 $	100,00 $
Mode Rapide, contexte long	40,00 $	4,00 $	150,00 $

Les écritures en cache coûtent 12,50 $ par million de jetons. Le mode Rapide promet « jusqu'à 2 fois la vitesse de traitement standard pour 2 fois le prix standard ».

Comparaison avec GPT-5.6

Modèle	Entrée	Entrée en cache	Sortie
GPT-5.6 Sol — promotion jusqu'au 21 novembre 2026 au moins	4,00 $	0,40 $	20,00 $
GPT-5.6 Terra	2,00 $	0,20 $	12,00 $
GPT-5.6 Luna	0,20 $	0,02 $	1,20 $

Consultez les détails de la baisse promotionnelle de GPT-5.6 Sol. Le prix catalogue de Sol est de 5 $ en entrée et 30 $ en sortie. Le tarif promotionnel de 4 $ et 20 $ est en vigueur depuis le 21 août et doit le rester au moins jusqu'au 21 novembre.

Comparé au tarif promotionnel, Astra coûte 2,5 fois plus cher en entrée et en sortie. Comparé au tarif catalogue de Sol, le rapport est de 2x en entrée et 1,67x en sortie.

Exemple de coût

Prenons une exécution d'agent qui :

• lit une fois un instantané de code de 200 000 jetons ;
• réutilise ce préfixe mis en cache sur 30 appels ;
• génère 60 000 jetons de sortie au total.

Résultat :

• Astra : 2,00 $ pour la première lecture, puis 29 lectures en cache à 0,20 $ chacune, soit 5,80 $, plus 3,00 $ de sortie. Total : environ 10,80 $.
• Sol en promotion : 0,80 $ pour la première lecture, 2,32 $ pour les lectures en cache et 1,20 $ de sortie. Total : environ 4,32 $.

Le ratio reste de 2,5x. L'argument d'OpenAI — à vérifier sur votre trafic — est qu'Astra termine les tâches avec moins d'appels et moins de jetons de sortie. Sur Terminal-Bench 4.0, OpenAI revendique un coût par tâche environ 9 % inférieur à Sol malgré son tarif supérieur. Astra utiliserait aussi environ 65 % moins de jetons de sortie que Claude Opus 5 sur Agents' Last Exam.

Si ces résultats se vérifient pour votre charge, le coût par tâche peut devenir équivalent. Sinon, vous paierez effectivement 2,5 fois plus.

Deux leviers réduisent la facture :

1. Surveillez le seuil de 272K jetons : le dépasser double les tarifs d'entrée et de cache.
2. Réduisez les sorties d'outils, mettez en cache le préfixe statique et utilisez Batch pour les tâches qui peuvent attendre.

Migration depuis GPT-5.6 Sol : ce qui ne fonctionne plus

OpenAI fournit une liste courte mais importante. Appliquez-la explicitement dans votre code client.

1. Les paramètres d'échantillonnage ont disparu. Supprimez temperature, top_p et top_logprobs. Avec Chat Completions, supprimez également logprobs. Avec Responses, retirez message.output_text.logprobs de include. Ne comptez pas sur le fait que l'API ignore ces champs.
2. L'effort minimal est low. Remplacez tous les réglages none ou minimal par low.
3. La rétention du cache a changé de structure. Remplacez prompt_cache_retention par prompt_cache_options.ttl, avec la valeur "30m". Le mode de mise en cache explicite configuré pour GPT-5.6 est sinon conservé.
4. Les outils nécessitent Responses. Chat Completions reste adapté au texte, mais les appels de fonction et les outils intégrés utilisent l'API Responses.
5. Les prompts doivent favoriser l'action. Ajoutez une instruction équivalente à « bias towards action », indiquez que les instructions de l'utilisateur priment sur les fichiers de compétences et demandez de la prose lorsque votre interface l'attend.

Les sorties structurées et les définitions de fonctions ne sont pas concernées par cette liste : un schéma fonctionnant avec Sol devrait fonctionner avec Astra.

Le changement comportemental le plus visible est souvent la demande de clarification. Une requête Sol qui s'exécutait jusqu'au bout peut s'arrêter avec une question. Anticipez ce cas dans le message du développeur pour réduire les interruptions.

Astra vaut-il 2,5 fois le prix de Sol ?

Pour les agents et les contextes longs, les résultats de lancement sont favorables à Astra. Les chiffres ci-dessous proviennent d'OpenAI et correspondent au meilleur effort de chaque modèle.

Benchmark	GPT-6 Astra	GPT-5.6 Sol	Claude Fable 5.1
Terminal-Bench 4.0	57,9 %	37,3 %	55,8 %
DeepSWE v1.1	74,1 %	72,7 %	67,4 %
FrontierCode 1.1 Extended	64,5 %	60,6 %	63,6 %
Tâches internes de migration de base de données	63,9 %	42,7 %	57,8 %
OSWorld 2.0	72,6 %	65,7 %	—
MRCR v2, 8-aiguilles, 512K à 1M	96,3 %	73,8 %	—
GPQA Diamond	96,0 %	94,6 %	93,7 %
Examen final de l'humanité, avec outils	57,2 %	—	65,0 %

Les écarts les plus utiles pour les développeurs sont ceux de Terminal-Bench et de la migration de bases de données : 20 points de plus que Sol sur le travail de terminal agentique, ainsi qu'une meilleure récupération dans les contextes longs. La fenêtre d'un million de jetons est donc utilisable, et pas seulement théorique.

L'écart de DeepSWE reste faible. Claude Fable 5.1 domine encore l'Examen final de l'humanité de près de huit points : Astra n'est pas supérieur partout. Sur l'indice indépendant d'Artificial Analysis, Astra se classe deuxième parmi 202 modèles. Consultez aussi notre analyse des benchmarks de Fable 5.1.

Sol reste pertinent pour :

• les appels courts et à fort volume ;
• les tâches où le tarif 2,5x est déterminant ;
• les cas nécessitant une latence proche du niveau none.

Astra est plus adapté aux :

• longues exécutions d'agents ;
• dépôts de code entiers placés dans le contexte ;
• tâches d'utilisation d'ordinateur ;
• scénarios où Sol dérive ou abandonne.

Testez la migration avant le déploiement

La migration peut se faire en une après-midi, mais elle doit être mesurée.

Dans Apidog, stockez l'ID du modèle dans une variable d'environnement. Vous pourrez ainsi exécuter la même requête enregistrée avec gpt-5.6-sol et gpt-6-astra en changeant une seule valeur.

Ajoutez des assertions sur :

• usage.input_tokens ;
• usage.output_tokens ;
• le nombre de jetons lus depuis le cache ;
• le temps d'exécution ;
• le coût total par tâche.

Envoyez ensuite un ensemble représentatif de tâches aux deux modèles et comparez les totaux. Vous obtiendrez une réponse basée sur votre trafic plutôt que sur les seuls benchmarks de lancement.

Ajoutez également deux tests de régression :

1. Envoyez une requête contenant encore temperature et observez le comportement de l'API en environnement de test.
2. Vérifiez qu'une requête longue reste sous 272K jetons d'entrée : dépasser ce seuil double les tarifs applicables.

Vous pouvez télécharger Apidog si nécessaire. Le guide de l'API GPT-5.6 présente une configuration similaire pour la génération précédente.

FAQ

Quel est l'ID du modèle GPT-6 Astra ?

gpt-6-astra, avec un seul instantané. Il est également disponible sur Azure et AWS Bedrock, ainsi que sur OpenRouter sous openai/gpt-6-astra.

GPT-6 Astra prend-il en charge le fine-tuning ou l'API Realtime ?

Non. Les points d'accès pris en charge sont Chat Completions, Responses et Batch. Realtime, Assistants et fine-tuning ne sont pas pris en charge.

Quelle est la fenêtre contextuelle et la sortie maximale ?

La fenêtre contextuelle est de 1 050 000 jetons d'entrée et la sortie maximale de 128 000 jetons. Au-delà de 272K jetons d'entrée, le tarif de contexte long s'applique.

Pourquoi ma requête échoue-t-elle après le passage de Sol à Astra ?

Vérifiez en priorité :

• un temperature ou top_p encore présent ;
• un niveau d'effort none ou minimal ;
• l'ancien champ prompt_cache_retention.

Astra ne prend plus en charge ces paramètres.

Une requête peut-elle s'arrêter d'elle-même ?

Oui. OpenAI exécute un moniteur de désalignement sur les requêtes utilisant des outils. Dans l'API, une tâche signalée s'arrête au lieu de se mettre en pause pour examen. Les longues exécutions d'agents sont les plus exposées : rendez-les donc réexécutables.

L'article consacré au seuil cyber critique détaille les garde-fous à l'origine de ce comportement.

Ce qu'il faut faire cette semaine

1. Déplacez une charge de travail agentique vers gpt-6-astra avec l'API Responses.
2. Supprimez les paramètres d'échantillonnage.
3. Définissez reasoning.effort sur medium.
4. Mesurez les jetons, le coût et le temps réel par rapport à Sol, avec les mêmes entrées.
5. Si le coût par tâche est équivalent ou inférieur, migrez progressivement le reste.

Vous aurez ainsi un chiffre basé sur votre propre charge de travail — une information plus utile que n'importe quel tableau de lancement.

Références

• Tarif promotionnel de GPT-5.6 Sol
• Page du modèle GPT-6 Astra
• Prise en main de GPT-6 Astra
• Guide de l'API Responses
• Directives des modèles OpenAI
• GPT-5.6 Terra
• Artificial Analysis — GPT-6 Astra
• Tarification de l'API OpenAI
• Guide de l'API GPT-5.6
• Analyse des benchmarks de Fable 5.1
• Apidog
• Télécharger Apidog
• Seuil cyber critique de GPT-6 Astra