GPT-6.1 Terra : prix API, Codex et comparaison avec Sol

Choisissez GPT-6.1 Terra pour des modifications de code ciblées et des actions répétables dans les applications, faciles à vérifier. Réservez GPT-6.1 Sol ou GPT-6 Astra aux bugs difficiles à diagnostiquer et aux changements complexes dans plusieurs parties du code. Au 2026-10-27, ses tarifs API Standard sont de $1 par million de tokens en entrée et $5 par million en sortie.

Ces tarifs d’entrée et de sortie représentent la moitié des tarifs Standard actuels de Sol. Le coût d’une tâche terminée dépend aussi du raisonnement, des nouvelles tentatives, des écritures en cache et de la longueur du contexte.

Quand choisir Terra plutôt que Sol ?

Choisissez Terra si vous pouvez vérifier facilement le résultat et corriger les erreurs à faible coût. Un correctif localisé, une mise à jour de test ou une tâche répétable dans une application constituent de bons points de départ.

Selon OpenAI, GPT-6.1 Terra atteint 50.3% sur Terminal-Bench 4.0 au niveau de raisonnement maximal. Le score publié de GPT-5.6 Terra est de 21.5%. Pour les tâches de programmation les plus complexes, l’annonce de lancement recommande toujours Sol ou Astra.

Les résultats indépendants montrent pourquoi le prix par token ne suffit pas. Au 2026-10-27, Artificial Analysis publie ces résultats de Codex :

Modèle dans Codex	Effort de raisonnement	Coding Agent Index v2.0	Coût API moyen par tâche	Durée moyenne de l’agent
GPT-6.1 Terra	xhigh	48	$0.69	16.4 minutes
GPT-6.1 Terra	max	48	$1.24	26.1 minutes
GPT-6.1 Sol	max	54	$1.50	23.7 minutes
GPT-6 Astra	max	55	$7.04	24.8 minutes

L’indice associe trois benchmarks aux méthodes de notation différentes. Ses points ne représentent pas un pourcentage universel de réussite des tâches. La méthodologie calcule le coût API à partir des tentatives, en incluant les lectures et écritures en cache applicables.

Dans cette suite de tests, Terra à max coûte moins que Sol à max, mais prend plus de temps et obtient moins de points. Terra à xhigh obtient le même score arrondi que Terra à max, à moindre coût. Testez ce réglage avant de supposer que max offre le meilleur rapport qualité-prix.

OpenAI annonce un coût par tâche environ neuf fois inférieur à celui d’Opus sur Agents’ Last Exam. L’accélération annoncée de plus de trois fois face à Sol et Astra concerne aussi cette évaluation de contrôle d’applications. Ces résultats n’établissent pas le même avantage en programmation.

Pour un bug difficile en production, commencez avec Sol. Pour un travail répétitif assorti d’un test fiable ou d’un état final visible, essayez Terra en premier.

Utiliser GPT-6.1 Terra dans Codex

Utilisez Codex CLI 0.159.0 ou une version plus récente et sélectionnez explicitement gpt-6.1-terra. La documentation officielle des modèles indique cette version minimale et la commande de lancement.

Au 2026-10-27, Terra est disponible dans Work et Codex avec les offres Plus, Pro, Business, Enterprise et Edu. La mise à jour officielle du produit cite explicitement Business. Terra n’est pas disponible dans Chat.

L’accès Enterprise dépend de la disponibilité dans l’espace de travail et des contrôles de l’administrateur. Terra ne prend pas en charge la résidence d’inférence aux Émirats arabes unis (UAE).

Sur macOS ou Linux, ouvrez le répertoire de votre dépôt dans Bash. Le dépôt officiel de Codex documente cet installateur :

curl -fsSL https://chatgpt.com/codex/install.sh | sh
codex --version
codex login
codex login status
codex -m gpt-6.1-terra

Vérifiez que la version est au moins 0.159.0. Terminez la connexion dans le navigateur avec un compte ChatGPT autorisé à utiliser le modèle.

Dans la session, utilisez /status pour vérifier le modèle actif. Utilisez /model pour sélectionner un effort de raisonnement disponible. Ces commandes figurent dans la référence de la CLI.

Pour vérifier l’accès, demandez à Codex de trouver la commande de test du dépôt et d’expliquer un test existant. Une réponse terminée vérifie davantage qu’une connexion réussie à elle seule.

Si Terra est indisponible, vérifiez la version de la CLI, l’éligibilité du compte et les contrôles de l’espace de travail. Examinez aussi le fournisseur dans ~/.codex/config.toml et les fichiers .codex/config.toml des projets approuvés. L’option -m sélectionne un modèle ; elle ne remplace pas votre configuration du fournisseur.

La connexion ChatGPT utilise l’accès de l’abonnement. La connexion par clé API facture plutôt le compte OpenAI Platform. Terra peut permettre plus de tâches avec le même quota, mais les prix API ne déterminent pas un nombre fixe de tâches incluses.

Terra prend aussi en charge le mode Fast de Codex, là où il est disponible, via /fast. Il consomme les limites incluses dans l’abonnement à 2.5× Standard. Les crédits achetés et l’usage Enterprise payé à la consommation sont facturés à 2× Standard.

Appeler Terra via Responses API

Utilisez Responses API pour une application ou un agent. Terra exige cette interface pour les appels d’outils.

La référence du modèle indique les spécifications suivantes au 2026-10-27 :

Paramètre	Valeur documentée
ID du modèle dans l’API	`gpt-6.1-terra`
`reasoning.effort`	`none`, `low`, `medium`, `high`, `xhigh`, `max`
Raisonnement par défaut dans l’API	`medium`
Fenêtre de contexte	1,050,000 tokens
Sortie maximale	128,000 tokens
Date limite des connaissances	2026-06-01
Entrée et sortie	Texte et images en entrée ; texte en sortie
Interface d’appel d’outils	Responses API

La fenêtre de contexte de l’API ne détermine pas le contexte utilisable dans Codex. Codex obtient ses limites et d’autres réglages via son catalogue de modèles. Vérifiez le contexte affiché dans la session avant de prévoir une tâche de programmation avec un million de tokens.

Pour tester l’API directement, il faut une clé OpenAI Platform, une facturation API active, Bash, une version récente de curl et jq. Collez votre clé lorsque read attend une saisie, puis appuyez sur Entrée :

set -o pipefail
read -rs OPENAI_API_KEY && export OPENAI_API_KEY

curl --silent --show-error --fail-with-body \
  https://api.openai.com/v1/responses \
  --header "Authorization: Bearer ${OPENAI_API_KEY}" \
  --header "Content-Type: application/json" \
  --data '{
    "model": "gpt-6.1-terra",
    "reasoning": {"effort": "medium"},
    "service_tier": "default",
    "max_output_tokens": 4096,
    "prompt_cache_options": {"mode": "explicit"},
    "store": false,
    "input": "Fix this Python function so empty input returns None, then provide two pytest tests: def first(xs): return xs[0]"
  }' |
  jq '{
    id, model, status, service_tier,
    text: ([.output[]? | select(.type == "message")
      | .content[]? | select(.type == "output_text") | .text] | join("\n")),
    usage, error, incomplete_details
  }'

L’exemple respecte le format de requête de Responses. Le filtre extrait le texte des éléments de message du tableau output de la réponse.

Une réponse réussie affiche status égal à completed. text contient le code et les tests générés, tandis que usage contient les comptes de tokens. La requête est synchrone : aucune interrogation périodique de son état n’est nécessaire.

L’exemple sélectionne explicitement le traitement Standard. Il choisit aussi le cache explicite sans points de coupure, appelés breakpoints. Cela empêche les écritures en cache pour cette requête.

Si le résultat est incomplet, examinez incomplete_details. Le plafond de sortie inclut les tokens de raisonnement. Un plafond trop bas peut donc être atteint avant la fin de la réponse. Pour les erreurs HTTP, consultez le code d’erreur documenté. L’authentification, les crédits épuisés et les limites de débit nécessitent des corrections différentes.

Pour piloter des applications, ajoutez l’environnement d’exécution décrit dans le guide de contrôle de l’ordinateur. Votre application doit exécuter les actions autorisées et renvoyer des captures d’écran actualisées. La requête de texte ci-dessus ne pilote ni navigateur ni bureau.

Calculer le prix de l’API GPT-6.1 Terra

Calculez chaque requête à partir de l’entrée ordinaire, des lectures de cache, des écritures en cache et de la sortie facturée. Compter seulement le texte visible sous-estime l’usage d’un modèle de raisonnement.

Voici les prix directs d’OpenAI Standard en USD par million de tokens, vérifiés le 2026-10-27 :

Catégorie de tokens	Requêtes avec au plus 272,000 tokens d’entrée	Requêtes avec plus de 272,000 tokens d’entrée
Entrée ordinaire	$1.00	$2.00
Lectures d’entrée en cache	$0.05	$0.10
Écritures en cache, conservation de 30 minutes	$1.25	$2.50
Écritures en cache, conservation de 12 heures	$2.50	$5.00
Sortie	$5.00	$7.50

Les règles tarifaires du modèle appliquent le supplément de contexte long à toute la requête. Les lectures et écritures en cache reçoivent aussi le multiplicateur de l’entrée.

Prenons une estimation pour une requête avec 100,000 tokens d’entrée ordinaire et 10,000 tokens de sortie facturée :

(100,000 × $1.00 + 10,000 × $5.00) / 1,000,000 = $0.15

Avec les tarifs de Sol à $2 en entrée et $10 en sortie, le même volume de tokens coûte $0.30. La comparaison suppose des comptes identiques ; une vraie tâche de programmation peut consommer des quantités différentes.

Ces exemples supposent Standard, sans supplément régional ni frais additionnels d’outils ou d’hébergement. Les taxes et les frais de passerelle sont séparés. La sortie facturée inclut les tokens de raisonnement.

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

Dépasser 272,000 tokens d’entrée change les tarifs de toute la requête. L’augmentation ne se limite pas aux tokens qui dépassent le seuil.

Pour une requête estimée à 300,000 tokens d’entrée ordinaire et 10,000 tokens de sortie facturée :

(300,000 × $2.00 + 10,000 × $7.50) / 1,000,000 = $0.675

Le tarif d’entrée double, tandis que celui de sortie augmente de 50%. Vérifiez chaque requête séparément dans une longue session de l’agent. L’historique accumulé peut franchir le seuil même si la dernière instruction est courte.

Conservez seulement le contexte nécessaire à l’étape suivante. Comparez les comptes de tokens et la qualité du résultat avant d’augmenter le contexte disponible.

Comment comptabiliser les écritures en cache ?

Traitez les écritures en cache comme une catégorie d’entrée distincte. Leur tarif inclut déjà le traitement de ces tokens ; ne rajoutez pas les frais d’entrée ordinaire.

Le guide de mise en cache des prompts décrit ces champs :

usage.input_tokens : entrée totale.
usage.input_tokens_details.cached_tokens : lectures de cache facturées.
usage.input_tokens_details.cache_write_tokens : écritures en cache facturées.

L’entrée ordinaire correspond à l’entrée totale moins les lectures et les écritures. Pour des durées de conservation différentes, utilisez cache_write_tokens_details.ttl_30m_tokens et ttl_12h_tokens.

Une requête écrivant 100,000 tokens dans un cache de 30 minutes et produisant 10,000 tokens de sortie coûte, selon l’estimation :

(100,000 × $1.25 + 10,000 × $5.00) / 1,000,000 = $0.175

Une requête ultérieure lisant 100,000 tokens du cache avec la même sortie coûte $0.055. Cette économie suppose que le préfixe corresponde et remplisse les conditions de réutilisation.

Pour un contexte réutilisable, définissez prompt_cache_options.ttl sur "30m" ou "12h". Si le contexte change et ne sera pas réutilisé, des points de coupure explicites peuvent éviter des écritures inutiles.

Quand Batch, Flex et Fast changent-ils la facture ?

Utilisez le traitement à tarif réduit pour les travaux qui peuvent attendre. Gardez Standard pour la programmation interactive, sauf si le gain de vitesse justifie le supplément.

Au 2026-10-27 :

Batch : les prix par token sont 50% inférieurs à Standard. La Batch API utilise des travaux asynchrones avec une fenêtre d’exécution de 24 heures.
Flex : les prix par token sont 50% inférieurs à Standard. Définissez service_tier sur "flex" pour un traitement plus lent avec une possible indisponibilité des ressources.
Fast : les prix par token sont de 2× Standard. Définissez service_tier sur "fast" et vérifiez le niveau renvoyé, comme l’explique le guide Fast.

Le traitement régional ajoute 10% là où il est disponible. Ces frais API sont distincts des multiplicateurs appliqués au quota d’abonnement Codex.

Utiliser OpenRouter avec son ID de modèle et ses frais

Utilisez OpenRouter s’il convient à votre routage et à votre facturation actuels. La présence de Terra y est vérifiée, mais son ID et la gestion de l’état conversationnel diffèrent de l’accès direct à OpenAI.

Au 2026-10-27, le catalogue OpenRouter confirme la présence de Terra. Voici les identifiants et les adresses des deux accès :

Accès	ID du modèle	URL complète de Responses
OpenAI direct	`gpt-6.1-terra`	`https://api.openai.com/v1/responses`
OpenRouter	`openai/gpt-6.1-terra`	`https://openrouter.ai/api/v1/responses`

Utilisez votre propre clé du fournisseur choisi avec l’authentification Bearer. Pour un client SDK OpenRouter, l’URL de base est https://openrouter.ai/api/v1.

OpenRouter affiche, par million de tokens, $1 en entrée, $5 en sortie, $0.05 pour les lectures de cache et $1.25 pour les écritures. Son catalogue définit séparément des tarifs supérieurs au-delà de 272,000 tokens de prompt : respectivement $2, $7.50, $0.10 et $2.50.

L’interface Responses d’OpenRouter est sans état. Envoyez l’historique de conversation à chaque requête. Définir store: true ou un previous_response_id différent de null renvoie HTTP 400.

Incluez les frais de recharge dans vos estimations de dépenses. OpenRouter Standard facture 5.5% lors de l’achat de crédits. Les achats par carte ont des frais minimaux de $0.80.

Par exemple, $100 de crédits Standard coûtent $105.50 avant les taxes applicables. 100 requêtes à $0.15 comme dans l’exemple précédent consomment $15 de crédits de modèle. En répartissant proportionnellement les frais de recharge, on obtient :

100 × $0.15 × 1.055 = $15.825, soit environ $15.83.

C’est une estimation des dépenses avec une part des frais affectée à cet usage. Les frais sont payés lors de la recharge, pas à chaque requête. Un achat de $10 déclenche le minimum de $0.80. Appliquer la même répartition à 5.5% serait donc incorrect.

Avant de migrer un agent existant, vérifiez sa gestion de l’état et les outils nécessaires. Une requête de texte compatible ne prouve pas la compatibilité de chaque outil dans sa boucle.

Confier à Terra des tâches faciles à valider

Commencez par transférer à Terra un type de tâche bien délimité, puis mesurez le résultat complet. Gardez votre modèle actuel pour les travaux qui demandent de réinterpréter les besoins ou d’intégrer des changements à plusieurs reprises.

Pour une régression d’interface, laissez Sol définir le comportement défaillant et le critère d’acceptation. Donnez à Terra le composant concerné, la commande de test pertinente et le rendu attendu. Faites relire le correctif par Sol et confiez-lui les changements qui touchent plusieurs composants.

Cette répartition est une recommandation de travail fondée sur les résultats de programmation. Les benchmarks cités n’ont pas testé un coordinateur Sol associé à des sous-agents Terra.

Mesurez toutes les dépenses d’inférence : première tentative, nouvelles tentatives et revue par le modèle. Divisez cette somme par le nombre de résultats acceptés et suivez séparément le temps de revue humaine. Notez aussi si la première tentative a réussi et la durée de la tâche entière.

Le tarif réduit de Terra n’aide que si ces totaux s’améliorent. Si Sol doit régulièrement reprendre un type de tâche, confiez-le directement à Sol. Pour les actions répétables dans les applications, exigez un état final visible que votre application vérifie avant d’accepter la tâche comme terminée.