GPT-6.2 Astra et Sol dans Codex : tarifs API, configuration et migration

GPT-6.2 Astra et Sol sont disponibles dans Codex, ChatGPT Work et l’API OpenAI. Découvrez leurs identifiants, changez de modèle dans Codex, calculez les coûts API et migrez les paramètres de raisonnement et les appels d’outils.

Sommaire
GPT-6.2 Astra et Sol dans Codex : tarifs API, configuration et migration

Si vous utilisez Codex ou développez des agents de programmation avec l’API OpenAI, vous pouvez désormais utiliser GPT-6.2 Astra ou GPT-6.2 Sol. Les deux modèles ont été lancés le 17 novembre 2026. Leurs identifiants API sont gpt-6.2-astra et gpt-6.2-sol. Commencez par Sol pour le développement courant et les tâches d’agents. Choisissez Astra pour les implémentations complexes, les tests et les raisonnements exigeants.

La migration impose plusieurs changements. Les deux modèles refusent le niveau de raisonnement none. Les appels d’outils nécessitent la Responses API. Plusieurs paramètres habituels d’échantillonnage et de log-probabilité ne sont pas pris en charge. Les requêtes dépassant 272K tokens en entrée sont également facturées à des tarifs supérieurs, y compris pour les écritures dans le cache.

Quel modèle GPT-6.2 choisir pour programmer ?

Commencez par GPT-6.2 Sol pour le développement quotidien. Choisissez GPT-6.2 Astra pour les modifications complexes de bases de code existantes, le débogage difficile et les tâches où de meilleurs résultats peuvent réduire le coût des vérifications et des corrections.

OpenAI présente Astra comme son modèle de pointe pour les travaux professionnels exigeants. Sol vise le développement quotidien et les flux de travail avec des agents. Un modèle plus performant peut coûter moins cher par tâche terminée s’il utilise moins de tokens ou nécessite moins de corrections. Ce résultat dépend toutefois de votre charge de travail.

ModèleIdentifiant APIPremier choix pourEntrée Standard / entrée en cache / sortie par million de tokens
GPT-6.2 Solgpt-6.2-solDéveloppement courant, agents et tâches sensibles au coût$2 / $0.10 / $10
GPT-6.2 Astragpt-6.2-astraImplémentations complexes, débogage et raisonnement exigeant$8 / $0.40 / $40

Les deux modèles disposent d’une fenêtre de contexte API de 1,050,000 tokens. L’entrée maximale est de 922,000 tokens et la sortie maximale de 128,000 tokens.

Codex propose un paramètre distinct, model_context_window, dans config.toml pour demander un contexte plus long. La documentation indique que cette configuration peut exploiter jusqu’à un million de tokens de contexte pour chaque modèle. La limite de contexte de l’API et celle configurée pour une session Codex sont deux paramètres différents.

Que montrent réellement les benchmarks de programmation ?

L’annonce d’OpenAI présente deux comparaisons qui répondent à des questions différentes.

Dans FrontierCode 2.0 de Cognition, l’écart entre les scores de Sol et d’Astra était inférieur ou égal à 0.5 point lorsque les deux modèles fonctionnaient en mode max. Sol coûtait environ cinq fois moins cher qu’Astra. FrontierCode évalue si les modifications apportées à de véritables bases de code respectent les critères de fusion des responsables de maintenance. Cette comparaison est donc particulièrement pertinente pour choisir un modèle destiné au travail sur des dépôts.

Dans Agents’ Last Exam, Astra a obtenu 5.5 points de plus que Claude Fable 5.2. OpenAI indique que le coût d’Astra représentait environ 5% de celui de Fable pour cette évaluation. Cependant, le classement publié de Fable 5.2 exclut neuf tâches qui utilisaient un modèle de secours. Considérez ce résultat comme une comparaison publiée par OpenAI, et non comme un rapport de coûts garanti pour votre agent de programmation.

OpenAI rapporte également que les premiers testeurs ont observé un style de code plus propre, des tests mieux ciblés et moins de cycles de révision. Ces observations justifient d’évaluer Astra sur des modifications complexes qui nécessitent implémentation et tests. Elles ne démontrent pas une amélioration universelle pour tous les langages, dépôts ou environnements de programmation.

Les premières réactions des développeurs sont partagées. Simon Willison a publié une démonstration utilisant Three.js et OpenStreetMap avec les deux modèles. Theo a exprimé une préférence pour le comportement d’un autre modèle, sans fournir de tâche reproductible ni d’évaluation. Ces publications illustrent des attentes différentes, pas des résultats de benchmarks comparables.

Avant de choisir, exécutez la même tâche de dépôt avec les deux modèles. Gardez le prompt, le contexte, les outils, le niveau de raisonnement et les critères d’acceptation identiques. Comparez les modifications acceptées, la couverture des tests, les cycles de correction, les tokens de sortie et le coût total de l’API. Conservez Sol si elle satisfait vos critères de révision. Passez à Astra lorsque son gain de qualité change réellement le résultat.

Combien coûtent GPT-6.2 Astra et Sol avec l’API ?

Les tarifs API Standard sont calculés par million de tokens de texte. L’entrée, l’entrée en cache, les écritures dans le cache et la sortie constituent des catégories de facturation distinctes. Le tarif de l’entrée en cache ne comprend pas l’écriture dans le cache.

Élément facturéGPT-6.2 SolGPT-6.2 Astra
Entrée$2.00$8.00
Entrée en cache$0.10$0.40
Écriture dans le cache, conservation de 30 minutes$2.50$10.00
Écriture dans le cache, conservation de 12 heures$5.00$20.00
Sortie$10.00$40.00

Ce sont les tarifs Standard par million de tokens pour les requêtes à contexte court, selon la documentation consultée le 18 novembre 2026. Les tarifs d’entrée et de sortie d’Astra sont inférieurs de 20% à ceux de GPT-6 Astra. Son tarif d’entrée en cache est inférieur de 60%. Sol conserve les tarifs publiés de GPT-6.1 Sol.

Que se passe-t-il au-delà de 272K tokens en entrée ?

Pour une requête contenant plus de 272K tokens en entrée, OpenAI applique les tarifs de contexte long à l’ensemble de la requête :

  • L’entrée coûte deux fois le tarif de contexte court.
  • L’entrée en cache coûte également deux fois ce tarif.
  • Les écritures dans le cache coûtent aussi deux fois ce tarif.
  • La sortie coûte 1.5 fois le tarif de contexte court.

Les tarifs obtenus sont les suivants :

Élément facturé en contexte longGPT-6.2 SolGPT-6.2 Astra
Entrée$4.00$16.00
Entrée en cache$0.20$0.80
Écriture dans le cache, conservation de 30 minutes$5.00$20.00
Écriture dans le cache, conservation de 12 heures$10.00$40.00
Sortie$15.00$60.00

Prenons une requête avec 300,000 tokens en entrée et 10,000 tokens en sortie, sans entrée en cache. Aux tarifs Standard, le coût estimé est le suivant :

  • Sol : 0.3 × $4 + 0.01 × $15 = $1.35
  • Astra : 0.3 × $16 + 0.01 × $60 = $5.40

Ces estimations appliquent les tarifs de contexte long à toute la requête. Elles excluent les écritures dans le cache, les autres frais et les multiplicateurs des niveaux de service. Si la requête contient une entrée en cache, calculez cette partie avec le tarif correspondant.

Quel effet Batch, Fast et Ultrafast ont-ils sur la facture ?

Les fiches des modèles documentent trois options de traitement :

Option de traitementPrix par rapport à StandardQuand l’envisager
Batch0.5×Pour les tâches pouvant être exécutées de manière asynchrone
Fast2×Lorsque la rapidité justifie le coût supplémentaire
Ultrafast3× jusqu’au 28 février 2027 ; 6× à partir du 1er mars 2027Pour les charges éligibles nécessitant le niveau de traitement le plus élevé

Le changement de tarif Ultrafast entre en vigueur le 1er mars 2027, à l’heure du Pacifique. Il modifie le multiplicateur de traitement, pas les tarifs de base des tokens du modèle.

Ultrafast prend uniquement en charge la résidence des données aux États-Unis. Standard, Fast et Batch prennent en charge les résidences des données aux États-Unis et dans l’Union européenne. Ne choisissez pas Ultrafast pour une charge de travail exigeant une résidence dans l’UE.

Par exemple, une requête Astra à contexte court en mode Ultrafast coûte trois fois le tarif Standard jusqu’au 28 février 2027. Les tarifs d’entrée, d’entrée en cache et de sortie deviennent respectivement $24, $1.20 et $120 par million de tokens.

À partir du 1er mars 2027, le multiplicateur de six fois porte ces tarifs à $48, $2.40 et $240. Les écritures dans le cache subissent le même multiplicateur. Appliquez le même calcul aux tarifs Standard de Sol.

Un niveau de traitement plus rapide peut multiplier les coûts d’entrée, d’entrée en cache, d’écriture dans le cache et de sortie. Il ne réduit pas automatiquement le nombre de tokens consommés par votre application.

Comment passer à GPT-6.2 dans Codex ?

Vous pouvez choisir un modèle au démarrage de Codex, le modifier pendant une session interactive ou définir un modèle par défaut dans config.toml. Les exemples utilisent Sol. Pour Astra, remplacez son identifiant par gpt-6.2-astra.

Démarrer Codex avec un modèle précis

Dans votre terminal, exécutez :

codex --model gpt-6.2-sol

L’alias -m fonctionne également. Pour une tâche non interactive, transmettez le modèle à codex exec :

codex exec -m gpt-6.2-sol "Review the current changes"

Ces commandes sélectionnent un modèle pour cette exécution uniquement. Elles ne modifient pas votre modèle par défaut permanent.

Changer de modèle pendant une session interactive

Lorsque Codex fonctionne, saisissez :

/model

Dans le sélecteur, choisissez GPT-6.2 Sol ou GPT-6.2 Astra. Vous pouvez également y modifier le niveau de raisonnement. Cette option est utile lorsqu’une tâche courante devient un problème d’implémentation complexe.

Définir le modèle par défaut dans config.toml

Pour utiliser Sol par défaut, configurez :

model = "gpt-6.2-sol"

Pour Astra, utilisez :

model = "gpt-6.2-astra"

La référence des modèles Codex documente ces commandes de sélection. Si vous utilisez un fournisseur d’API personnalisé, suivez ses instructions de configuration. Un identifiant de modèle ne configure à lui seul ni l’adresse du point de terminaison ni l’authentification.

Comment migrer une intégration API ?

Définissez model sur gpt-6.2-astra ou gpt-6.2-sol, puis vérifiez le niveau de raisonnement, les appels d’outils, les paramètres non pris en charge et le cache des prompts. Le guide officiel de migration GPT-6.2 détaille ces changements.

Modifier le niveau de raisonnement

Pour une nouvelle intégration, commencez avec medium. Si votre requête actuelle utilise none ou minimal, remplacez cette valeur par low.

Le nom du champ dépend du point de terminaison :

  • Responses API : reasoning.effort
  • Chat Completions : reasoning_effort

Les deux modèles refusent le niveau de raisonnement none. Ne conservez pas cette ancienne valeur pendant la migration.

Pour Responses, le corps minimal d’une requête ressemble à ceci :

{
  "model": "gpt-6.2-sol",
  "reasoning": {
    "effort": "medium"
  },
  "input": "Explain what this function does."
}

Pour Chat Completions, utilisez plutôt reasoning_effort :

{
  "model": "gpt-6.2-sol",
  "reasoning_effort": "medium"
}

Envoyer une requête complète avec Responses API

L’exemple Bash suivant utilise votre clé API OpenAI au moyen d’une variable d’environnement. Créez d’abord une clé dans le tableau de bord de l’API OpenAI, puis saisissez-la lorsque le terminal vous la demande.

read -rs OPENAI_API_KEY && export OPENAI_API_KEY
response=$(curl -sS https://api.openai.com/v1/responses \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -d '{
    "model": "gpt-6.2-sol",
    "reasoning": {
      "effort": "medium"
    },
    "input": "Reply with exactly: GPT-6.2 API is working."
  }')
printf '%s\n' "$response" | jq -e '.status == "completed"' >/dev/null &&
  printf '%s\n' "$response" | jq -r '.output[] | select(.type == "message") | .content[] | select(.type == "output_text") | .text'

Cette requête envoie du texte via v1/responses et utilise l’authentification Bearer. La dernière commande vérifie que le statut de la réponse est completed, puis récupère le texte produit par le modèle. En cas de réussite, le terminal affiche le message de confirmation demandé.

Cet exemple s’appuie sur la documentation et n’a pas été exécuté. Si la requête échoue, examinez la réponse HTTP et le corps de l’erreur. Un paramètre refusé indique généralement qu’un ancien champ est encore présent. Si le modèle est indisponible ou si le compte n’a pas les autorisations nécessaires, vérifiez votre organisation API, l’accès au modèle et la facturation. Une connexion réussie à Codex avec un abonnement ne prouve pas que la facturation ou l’accès à l’API sont configurés.

Migrer les appels d’outils vers Responses API

Les deux modèles prennent en charge Responses API et Chat Completions. Cependant, les appels d’outils nécessitent Responses API.

Si votre intégration utilise des fonctions ou des outils, migrez le flux des requêtes vers v1/responses. La compatibilité avec Chat Completions ne garantit pas des fonctionnalités équivalentes pour les appels d’outils.

Pour les requêtes simples sans outils, Chat Completions reste un point de terminaison pris en charge. Distinguez clairement les deux cas dans votre code afin de ne pas dépendre d’une voie non prise en charge lorsque vous ajouterez des outils.

Supprimer les paramètres non pris en charge

Supprimez les champs incompatibles pendant la migration :

Type de requêteParamètres à supprimer
Chat Completionstemperature, top_p, logprobs, top_logprobs
Responsestemperature, top_p, top_logprobs ; supprimer message.output_text.logprobs de include

Ne réutilisez pas intégralement un ancien corps de requête en changeant uniquement l’identifiant du modèle. Les paramètres incompatibles peuvent faire échouer la nouvelle requête.

Mettre à jour la configuration du cache des prompts

Si vous migrez depuis GPT-5.5 ou une version antérieure, remplacez prompt_cache_retention par prompt_cache_options.ttl avec la valeur "30m".

Conservez les préfixes des prompts sans modification entre les tours. Ajoutez les nouvelles instructions à la fin au lieu de modifier le contenu précédent de la conversation. GPT-6.2 peut supprimer des éléments de raisonnement lorsqu’il détecte une modification de l’historique, une rétrogradation du modèle, un changement d’utilisateur final ou un changement d’organisation. La perte de ces éléments peut dégrader les réponses et pousser le modèle à répéter un travail déjà effectué.

Des préfixes stables permettent également de conserver l’éligibilité des entrées précédentes au cache des prompts. Cela peut réduire les coûts d’entrée répétés et la latence lorsque votre application envoie le même prompt système ou le même préfixe de conversation.

Vérifier les exigences de conservation et de résidence des données

Les deux modèles prennent en charge Zero Data Retention (ZDR) pour les organisations approuvées, sur les points de terminaison et fonctionnalités éligibles. Lorsque ZDR est activé, Responses API traite store comme false.

Les deux modèles prennent en charge la résidence des données aux États-Unis et dans l’Union européenne avec Standard, Fast et Batch. Ultrafast prend uniquement en charge la résidence aux États-Unis. Avant le déploiement, vérifiez que votre organisation, votre point de terminaison et votre niveau de traitement respectent vos exigences.

Quelle méthode d’accès choisir ?

Choisissez l’accès hébergé si vous souhaitez travailler dans Codex ou ChatGPT Work d’OpenAI. Choisissez l’API si vous développez une application ou un agent et avez besoin de contrôler directement les requêtes.

MéthodeConditions nécessairesQuand la choisir
ChatGPT WorkPlus, Pro, Business, Enterprise ou Edu. Les administrateurs Enterprise et Edu doivent activer les modèles dans les paramètres de l’espace de travail.Pour utiliser Astra ou Sol dans l’environnement Work hébergé.
CodexUn abonnement ChatGPT éligible et un client Codex compatible.Pour utiliser les modèles dans l’application Codex ou la CLI.
OpenAI APIUne organisation API, une clé API, la facturation API ou des crédits API éligibles, et un point de terminaison pris en charge.Pour développer une application ou un agent avec un contrôle direct de l’API.
Attendre la réinitialisation du quota d’abonnementUn abonnement éligible et un accès au forfait après la réinitialisation.Pour continuer à utiliser Codex ou Work sans transférer la charge vers la facturation API.
Passer par une passerelle API tierceUn compte distinct auprès de la passerelle, sa propre clé API et sa facturation, ainsi qu’une prise en charge documentée du modèle et de l’outil choisis.Pour disposer d’une autre méthode d’accès ou de paiement de l’API.

ChatGPT Work et Codex n’ont pas les mêmes conditions d’accès selon les forfaits et les clients. Business est documenté pour ChatGPT Work. Avant de planifier un déploiement, consultez la référence actuelle des modèles Codex et vérifiez les clients compatibles avec votre compte.

L’accès à Ultrafast dépend également de l’abonnement :

  • Pro 500 permet d’utiliser Ultrafast avec Astra et Sol.
  • Pro 200 permet d’utiliser Ultrafast avec Sol.
  • Les espaces de travail Enterprise et Edu éligibles peuvent utiliser Ultrafast après son activation par un administrateur.

Ne supposez pas que Pro 200 inclut Ultrafast pour Astra. Le modèle et le niveau de traitement doivent tous deux être éligibles.

Les abonnements ChatGPT et la facturation API sont distincts. Une clé API ne donne pas accès aux fonctionnalités de l’abonnement, et un abonnement ChatGPT ne paie pas automatiquement les requêtes API. Les abonnés Pro et Business éligibles peuvent obtenir des crédits API distincts, sous réserve des conditions d’activation et d’organisation. Consultez le guide de facturation OpenAI avant d’établir le budget d’une intégration en production.

Peut-on utiliser une passerelle API tierce ?

Une passerelle constitue une méthode d’accès distincte. Elle ne prolonge pas votre abonnement ChatGPT. Avant de changer de fournisseur, vérifiez son catalogue de modèles actuel et la documentation de configuration de votre outil.

Dans le catalogue BetterToken récupéré le 18 novembre 2026, ni gpt-6.2-astra ni gpt-6.2-sol n’apparaissaient. La même réponse répertoriait gpt-6-astra. Il s’agit d’une observation datée du catalogue, pas d’une garantie sur la disponibilité future. Vous pouvez évaluer séparément le modèle précédent si ses capacités répondent à vos besoins.

Pour l’intégration Codex documentée, BetterToken utilise le point de terminaison compatible OpenAI https://www.bettertoken.ai/v1 et Responses API. Son guide de configuration indique model_provider = "bettertoken", wire_api = "responses" et une authentification par clé API via auth.json. Vous devez créer votre propre compte et votre propre clé API. Consultez les instructions de configuration d’un fournisseur personnalisé dans Codex pour obtenir la configuration complète.

Cette solution fournit un accès API avec paiement à l’usage, pas un abonnement ChatGPT ou Codex. Choisissez-la lorsque le modèle nécessaire figure dans le catalogue actuel et que la configuration documentée du fournisseur répond à votre flux de travail.

Que tester avant de basculer le trafic de production ?

Effectuez une évaluation contrôlée avant de remplacer le modèle actuel de votre agent de production.

Choisissez une tâche représentative d’un dépôt et définissez des critères d’acceptation clairs. Exécutez-la avec Sol et Astra en conservant le même commit de départ, le même prompt, les mêmes autorisations d’outils, le même niveau de raisonnement et les mêmes limites d’exécution. Vérifiez que chaque modèle produit un correctif vérifiable et réussit les mêmes tests.

Consignez les éléments suivants pour chaque exécution :

  • La modification demandée a-t-elle été réalisée ?
  • Les tests générés couvrent-ils les principaux cas d’échec ?
  • Combien de cycles de correction manuelle ont été nécessaires ?
  • Les nombres de tokens en entrée, en entrée de cache, en écriture de cache et en sortie.
  • La requête a-t-elle dépassé le seuil de contexte long de 272K ?
  • Le niveau de traitement utilisé et le coût total.

Choisissez Sol si elle satisfait vos critères d’acceptation à un coût total inférieur. Choisissez Astra si ses améliorations réduisent les échecs, le travail de révision ou le risque de modifications incorrectes.

Testez également les scénarios d’échec de la migration. Vérifiez que les requêtes n’utilisent plus le niveau de raisonnement none, que les requêtes avec outils utilisent Responses API et que les paramètres non pris en charge ont été supprimés. Testez séparément une requête à contexte long, car ses tarifs supérieurs s’appliquent à toute la requête dès que l’entrée dépasse 272K.

Pour les flux de travail avec agents, conservez une trace visible des obstacles. OpenAI indique que ses évaluations ont montré une tendance accrue des nouveaux modèles à omettre des obstacles dans deux tests, par exemple un fichier manquant ou un outil de recherche indisponible. OpenAI précise avoir ajouté des instructions dans Codex pour réduire ces omissions et poursuivre l’étude de ce comportement. Votre agent doit malgré tout signaler explicitement les appels d’outils échoués et les tâches inachevées.

Pour aller plus loin, la comparaison GPT-6.1 Sol, GPT-6 Astra et Claude Opus 5.5 présente la génération précédente. La comparaison Coding Agent Index v2.1 explique l’effet du niveau de raisonnement sur les résultats des agents de programmation. Si vous choisissez une interface Codex, consultez aussi la comparaison entre Codex CLI, l’application de bureau et l’extension VS Code.

GPT-6.2 Sol est le premier modèle à tester pour le développement courant et les tâches d’agents. Astra est le candidat suivant pour les implémentations et les tests complexes. Avant de modifier le trafic de production, comparez le coût complet des tâches et vérifiez les exigences de migration de l’API.

Prêt à optimiser votre workflow LLM ?

Connectez vos modèles via une API unique, gérez les clés et maîtrisez vos dépenses d’IA.

Commencer gratuitement