GPT-Image 2.6 Flare et Sunburst sont disponiblesÀ partir de $0.025 par image

GPT-6.2 Astra vs Sol : prix, vitesse et coût par tâche

Trois tâches de code identiques, deux modèles, une seule API : jusqu'où tient le moins cher et ce que le modèle phare apporte sur le travail difficile.

Kiki, OmniaKey COO10 minutes de lecture
Sur cette page

Le duel GPT-6.2 Astra vs Sol se joue d'abord sur le prix : Astra facture $8 par million de tokens d'entrée et $40 par million de sortie, soit quatre fois les $2 et $10 de Sol. Sur trois petites tâches de code lancées le 19 nov 2026, les deux ont passé toutes les vérifications ; aux tarifs Standard d'OpenAI, Sol a coûté environ le quart.

Sol est le modèle par lequel commencer sur un travail court et bien cadré. L'argument d'Astra, ce sont les tâches plus difficiles et plus ouvertes : dans les tests de code indépendants, il mène avec le même libellé medium, de 2.5 points sur Terminal-Bench 4.0 et de 5.2 sur FrontierCode. Le gain dépend de ce que ces points évitent comme travail à refaire : testez les tâches complexes que Sol rate avant de payer pour Astra.

Code courant, gros volume

GPT-6.2 Sol

A passé nos trois petites tâches pour environ le quart du coût d'Astra aux tarifs Standard d'OpenAI. $2 en entrée et $10 en sortie par million de tokens.

Travail difficile et ouvert

GPT-6.2 Astra

En tête des tests de code indépendants avec le même libellé medium. $8 en entrée et $40 en sortie par million de tokens.

GPT-6.2 Astra vs Sol : qu'est-ce qui change ?

La page d'Astra, la page de Sol et la page des tarifs d'OpenAI annoncent la même fenêtre de contexte, la même limite de sortie, les mêmes niveaux de raisonnement et les mêmes limites de requêtes. Ce qui change vraiment, c'est l'ID du modèle, le prix par token et la date d'arrêt des connaissances.

ÉlémentAstraSol
ID du modèlegpt-6.2-astragpt-6.2-sol
Sortie17 nov 202617 nov 2026
Fenêtre de contexte1,050,000 tokens1,050,000 tokens
Entrée maximale922,000 tokens922,000 tokens
Sortie maximale128,000 tokens128,000 tokens
Fin des connaissances18 mai 20261 juin 2026
Niveaux de raisonnementlow à maxlow à max
Entrée$8$2
Entrée en cache$0.40$0.10
Écriture de cache, 30 min$10$2.50
Sortie$40$10
Sortie au-delà de 272K d'entrée$60$15

Les tarifs Standard d'Astra valent exactement le quadruple de ceux de Sol sur chaque ligne, y compris l'écriture de cache et les lignes de contexte long.

Les deux modèles sont sortis dans la même entrée de journal du 17 nov 2026. L'annonce de lancement d'OpenAI indique que les utilisateurs Plus, Pro, Enterprise et Edu disposent des deux dans ChatGPT Work et Codex ; dans les espaces Enterprise et Edu, un administrateur doit les activer. Côté API, les deux ID tournent sur les mêmes endpoints, et sur les offres Pro, Pro 200 démarre avec Sol tandis que Pro 500 peut utiliser les deux.

Deux détails passent facilement inaperçus. Les deux endpoints, Responses et Chat Completions, fonctionnent avec les deux ID ; l'appel d'outils demande l'API Responses. Les deux modèles prennent du texte et des images en entrée et renvoient du texte, donc aucun ne produit d'audio ni de vidéo. Les limites de requêtes sont identiques à chaque palier, de 5,000 requêtes et 1 million de tokens par minute en Build à 15,000 et 40 millions en Grow.

Chaque modèle a aussi son article : le détail de la sortie de GPT-6.2 Astra et le point complet sur GPT-6.2 Sol.

Combien coûte une requête aux tarifs d'OpenAI ?

$0.16 sur Astra et $0.04 sur Sol pour un prompt de 10,000 tokens et 2,000 tokens de sortie, aux tarifs Standard d'OpenAI.

Le calcul pour Astra : 10,000 × $8 ÷ 1,000,000 = $0.08 d'entrée et 2,000 × $40 ÷ 1,000,000 = $0.08 de sortie. Pour Sol : 10,000 × $2 ÷ 1,000,000 = $0.02 plus 2,000 × $10 ÷ 1,000,000 = $0.02. Cent requêtes de cette forme coûtent $16 sur Astra et $4 sur Sol.

Les tokens de raisonnement comptent comme des tokens de sortie et n'ont pas de ligne tarifaire à part : monter l'effort augmente la dépense parce que la sortie s'allonge, pas parce qu'un autre compteur s'enclenche. Les prompts longs gardent le même écart. Au-delà de 272,000 tokens d'entrée, OpenAI double les tarifs d'entrée et de cache et facture 1.5 fois le tarif de sortie courte sur toute la requête. Avec 300,000 tokens d'entrée et 2,000 de sortie, Astra paie 300,000 × $16 ÷ 1,000,000 = $4.80 plus 2,000 × $60 ÷ 1,000,000 = $0.12, soit $4.92. Sol paie $1.20 plus $0.03, soit $1.23. Sol coûte exactement le quart. Le traitement par lots divise par deux les tarifs des deux modèles, l'écart tient donc là aussi.

Que s'est-il passé sur nos trois petites tâches de code ?

Les deux modèles ont passé toutes les vérifications des trois tâches. Astra a été plus rapide sur les deux tâches Python, Sol sur celle en SQL.

Nous avons envoyé chaque prompt une fois à chaque modèle via l'endpoint Responses d'OmniaKey le 19 nov 2026, avec un raisonnement medium, une limite de 4,096 tokens de sortie, le streaming et aucun outil. Nous avons alterné l'ordre des modèles et fait aucune reprise, soit six appels au total. OmniaKey commercialise l'accès aux deux modèles et les tests sont passés par lui. Chaque dollar de cette section est recalculé à partir des tokens rapportés aux tarifs Standard d'OpenAI, et non d'une facture OmniaKey.

Les tâches étaient un sélecteur de dernier événement, une union d'intervalles et une requête de remboursements. Chacune a tourné sur des cas fixes plus 100 cas pseudo-aléatoires déterministes de graine 20261119 : 104 cas pour le dernier événement, 106 pour les intervalles et 102 pour le SQL. Ces chiffres sont des cas de test, pas des exécutions distinctes du modèle. Comportement attendu : un seul événement retenu par ID, aucune minute d'intervalle comptée deux fois, et des remboursements déduits une seule fois par paiement.

Les trois prompts, exactement tels qu'envoyés :

Prompt 1 : derniers événements

Return ONLY Python 3 code defining total_paid(events). Do not import modules or print. Each event is a dict with id (string), version (integer), status (string) and cents (integer). Select the event with the largest version per id; when versions tie, the later item in the input wins. Return the sum of cents only for selected events whose status is "paid". Input may be empty. Do not mutate the list or its dicts. The algorithm must run in O(n) time and support negative cents. Example: [{"id":"a","version":2,"status":"paid","cents":50},{"id":"a","version":1,"status":"paid","cents":200},{"id":"b","version":1,"status":"void","cents":20}] returns 50. Do not include tests or explanations.

Prompt 2 : union d'intervalles

Return ONLY Python 3 code defining union_minutes(intervals). Do not import modules or print. intervals is a list of two-integer [start,end] pairs representing half-open ranges in minutes, with start <= end. Values can be negative and pairs can be unsorted. Return the total length of their union. Adjacent, overlapping, nested and duplicate intervals must not be double-counted. Zero-length ranges add nothing. Empty input returns 0. Do not mutate the list or any pair. Use O(n log n) time and O(n) extra space or better. Example: [[5,10],[1,6],[10,12],[3,3]] returns 11. Do not include tests or explanations.

Prompt 3 : remboursements en SQL

Return ONLY one SQLite SELECT query, optionally with WITH common table expressions. No explanation or Markdown. Tables: payments(id INTEGER PRIMARY KEY, customer_id INTEGER NOT NULL, amount_cents INTEGER NOT NULL, status TEXT NOT NULL); refunds(id INTEGER PRIMARY KEY, payment_id INTEGER NOT NULL, amount_cents INTEGER NOT NULL, status TEXT NOT NULL). Return customer_id, net_cents for each customer with at least one payment whose status is 'paid', including customers whose net is zero or negative. net_cents is the sum of their paid payment amounts minus only refunds with status 'succeeded' attached to those paid payments. Exclude unpaid payments and refunds on them. A payment can have zero or multiple refunds. Do not multiply payment amounts when joining refunds. Sort by customer_id ascending. Use only these two tables.

TâcheAstraSol
Dernier événement par ID104/104, 4.2 s104/104, 5.0 s
Union d'intervalles106/106, 4.4 s106/106, 6.5 s
Remboursements SQL102/102, 6.0 s102/102, 4.9 s
Total3 tâches, 14.6 s3 tâches, 16.4 s

Les tokens derrière ces coûts, et le coût aux tarifs Standard officiels :

TâcheEntréeSortie AstraSortie Sol
Dernier événement par ID4,5588193
Union d'intervalles4,53281149
Remboursements SQL4,550113128
Total13,640275370
TâcheAstraSol
Dernier événement par ID$0.0397$0.0100
Union d'intervalles$0.0395$0.0106
Remboursements SQL$0.0409$0.0104
Trois appels par modèle$0.1201$0.0310

Chaque requête a rapporté environ 4,380 tokens d'instructions au-delà du prompt visible, à l'identique pour les deux modèles. Nous avons gardé les 13,640 tokens d'entrée dans le calcul au lieu d'estimer à partir de la longueur du prompt. Aucun succès ni aucune écriture de cache n'est revenu. Sol a consommé 10, 47 et 13 tokens de raisonnement dans ses totaux de sortie ; Astra n'en a rapporté aucun.

Le code s'est comporté pareil des deux côtés. Chacun garde la version la plus haute par ID et tranche une égalité avec l'élément le plus tardif, aucun ne modifie l'entrée, et les deux additionnent les remboursements réussis avant de joindre les paiements, pour que plusieurs remboursements ne multiplient pas un paiement.

Cela fait six appels au total : lisez les temps comme une observation chacun, pas comme un classement de vitesse. Les taux de réussite montrent que les deux modèles terminent des tâches bornées en un seul tour ; ils disent peu d'une longue session d'agent avec dépôt, outils et reprises.

Où les tests indépendants montrent-ils une différence ?

Artificial Analysis place Astra en tête des deux tests de code avec le même libellé medium : 2.5 points sur Terminal-Bench 4.0 et 5.2 points sur FrontierCode.

MesureAstraSol
Intelligence Index5753
Terminal-Bench 4.058.6%56.1%
FrontierCode-AA2.046.6%41.4%
Temps par tâche4.5 min3.3 min
Coût par tâche$1.62$0.41

Ce sont les chiffres actuels du comparatif d'Artificial Analysis, relevés le 19 nov 2026. Son Intelligence Index v5.0.1 couvre neuf évaluations, le code pesant 25% du score. La page de comparaison est un instantané en direct et n'affiche pas de date d'exécution séparée : prenez ces chiffres comme actuels plutôt que figés. Elle libelle les lignes des deux modèles medium, ce qui est le réglage d'OpenAI ; le libellé seul ne prouve pas que les deux modèles ont dépensé les mêmes tokens. Ces tests sont des tâches longues de type agent, d'où un coût en dollars par tâche, là où notre passage en un seul tour se compte en cents.

À l'effort max, la même page donne 62 à Astra et 57 à Sol sur l'indice, avec 13.9 et 8.7 minutes par tâche et $4.00 et $1.01 par tâche. Astra en high et Sol en max atteignent tous deux 60.1% sur Terminal-Bench 4.0. Le score FrontierCode d'Astra est plus élevé en xhigh (49.0%) qu'en max (45.4%) : monter le réglage n'améliore pas chaque score. Comparer Astra en max à Sol en low flatterait Astra ; aligner les libellés reste la comparaison la plus propre, même si un libellé identique ne signifie pas que les deux modèles ont dépensé les mêmes tokens.

Quel effort de raisonnement choisir ?

Commencez par medium sur l'un ou l'autre. C'est le réglage derrière les scores indépendants ci-dessus, et le guide de choix de modèle d'OpenAI recommande Sol en medium pour la plupart des usages de l'API.

Les deux modèles acceptent low, medium, high, xhigh et max, et les deux refusent none. OpenAI conseille de démarrer une nouvelle intégration en medium et d'utiliser low à la place de none ou minimal. Les réglages plus hauts écrivent en général plus de tokens de sortie et ont pris plus de temps en moyenne dans les exécutions publiées, mais ils n'augmentent pas chaque score. Les niveaux hauts servent aux tâches qui demandent plus de vérifications, pas à chaque appel.

La liste d'OpenAI par type de tâche est un bon point de départ. Elle place Sol en medium pour corriger des bugs et ajouter des fonctions dans du code existant, Sol en extra high pour les tâches en plusieurs étapes qui demandent des tests et des retouches, et Astra en extra high pour les problèmes ouverts où il faut peser des compromis. Ces notes sont des estimations, et le guide ne donne aucun score derrière elles.

Quel modèle pour le code au quotidien ?

Commencez par Sol. Passez à Astra quand vos propres tâches difficiles échouent encore et encore sur Sol, car l'avance d'Astra dans les tests indépendants se compte en quelques points alors que son prix par token est quatre fois celui de Sol.

Sur un travail courant et bien cadré, comme les trois tâches ci-dessus, Sol a égalé Astra vérification par vérification pour environ le quart du coût. Dans les tests indépendants, l'avance d'Astra au libellé medium est de 2.5 points sur Terminal-Bench 4.0 sur 100 et de 5.2 points sur FrontierCode.

Mettez le prix en face du travail évité. À 10,000 tokens d'entrée et 2,000 de sortie, 100 appels à Astra coûtent $12 de plus que 100 appels à Sol. Comparez cela au coût d'une reprise, d'une passe de relecture ou d'une mauvaise réponse ; seules vos propres tâches peuvent le chiffrer.

Une façon concrète de le mesurer : prenez 20 tâches complexes récentes où Sol a eu besoin d'un second passage, lancez-les sur Astra en high ou xhigh et comparez la dépense supplémentaire au travail qu'elle supprime. Si Astra ne change que des réponses que vous auriez acceptées de toute façon, gardez Sol.

Comment essayer les deux avec la même API ?

Pointez le SDK OpenAI vers l'URL de base d'OmniaKey https://api.omniakey.com/v1, gardez la clé dans OMNIAKEY_API_KEY et changez une seule chaîne pour passer d'un modèle à l'autre. Les deux familles d'endpoints fonctionnent avec les deux ID ; utilisez Responses si vous prévoyez d'appeler des outils.

python
import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["OMNIAKEY_API_KEY"],
    base_url="https://api.omniakey.com/v1",
)

prompt = (
    "Return ONLY Python 3 code defining union_minutes(intervals). Do not import "
    "modules or print. intervals is a list of two-integer [start,end] pairs "
    "representing half-open ranges in minutes, with start <= end. Values can be "
    "negative and pairs can be unsorted. Return the total length of their union. "
    "Adjacent, overlapping, nested and duplicate intervals must not be "
    "double-counted. Zero-length ranges add nothing. Empty input returns 0. Do not "
    "mutate the list or any pair. Use O(n log n) time and O(n) extra space or better. "
    "Example: [[5,10],[1,6],[10,12],[3,3]] returns 11. Do not include tests or "
    "explanations."
)

response = client.responses.create(
    model="gpt-6.2-sol",  # or "gpt-6.2-astra"
    reasoning={"effort": "medium"},
    max_output_tokens=4096,
    input=prompt,
    stream=True,
)
for event in response:
    if event.type == "response.output_text.delta":
        print(event.delta, end="")

C'est la forme de requête utilisée pour les trois tâches, avec le prompt d'union d'intervalles ci-dessus en entier. Le bloc usage de la réponse rapporte les tokens d'entrée et de sortie, et le total de sortie inclut les tokens de raisonnement.

Les deux endpoints fonctionnent avec les deux ID. Prenez Responses quand vous avez besoin d'outils ; Chat Completions sert les requêtes sans outils. L'ancien guide de configuration GPT-6 Astra couvre le même endpoint, Codex et les corrections d'erreurs ; remplacez le nom par gpt-6.2-astra ou gpt-6.2-sol là où le modèle est nommé.

Les tarifs actuels d'OmniaKey pour les deux figurent sur la page du modèle GPT-6.2 Astra et sur la page du modèle GPT-6.2 Sol.

Questions fréquentes

GPT-6.2 Sol suffit-il pour coder ?

Sur nos trois petites tâches, il a égalé Astra vérification par vérification. Artificial Analysis place encore Astra 2.5 points devant sur Terminal-Bench 4.0 au libellé medium : Sol est donc un bon choix par défaut et Astra la couverture pour le travail plus dur.

Combien GPT-6.2 Sol coûte-t-il de moins qu'Astra ?

Sol coûte le quart, soit 75% de moins sur chaque tarif Standard : $2 en entrée et $10 en sortie par million de tokens contre $8 et $40. Nos trois tâches ressortent à 3.7 à 4.0 fois d'écart, et 100 requêtes de 10,000 en entrée et 2,000 en sortie coûtent $4 contre $16.

Quel niveau d'effort choisir pour GPT-6.2 ?

Medium sur l'un ou l'autre. Les deux refusent none, et OpenAI recommande medium pour une nouvelle intégration. Montez-le pour un travail en plusieurs étapes qui demande des tests et des retouches. Les réglages hauts ne sont pas automatiquement plus lents ni meilleurs : le score FrontierCode d'Astra est plus élevé en xhigh qu'en max.

Les deux modèles acceptent-ils des images ou appellent-ils des outils ?

Les deux acceptent du texte et des images et renvoient du texte ; l'audio et la vidéo ne sont pas pris en charge. Les deux endpoints fonctionnent, et l'appel d'outils exige l'API Responses.

Sources vérifiées

Tarifs et limites vérifiés le 19 nov 2026.

Journal des mises à jour

  • 19 nov 2026 : première version. Trois tâches passées par OmniaKey le jour même ; tarifs, limites et scores indépendants vérifiés ce jour-là.

Modèles cités dans cet article

GPT-6.2 AstraGPT-6.2 Solcomparatif de modèlestarifs APIcode

Articles similaires

Articles récents

Guides populaires