OpenAI Ultrarapide : 6x plus rapide, 6x plus cher. Quand est-ce rentable ?

OpenAI Ultrafast est un niveau de service, pas un nouveau modèle. Ajoutez service_tier: "ultrafast" à une requête API de Réponses pour gpt-6-astra et OpenAI génère des jetons jusqu'à 6 fois plus vite dans l'API (jusqu'à 8 fois, soit 300 jetons par seconde, dans Codex). Il coûte 6 fois le Standard : 60,00 $ en entrée et 300,00 $ en sortie par million de jetons, contre 10,00 $ et 50,00 $. L'ID du modèle ne change pas, donc les réponses sont plus rapides, pas plus intelligentes. Il est rentable lorsqu'une personne ou une étape limitée par la latence attend de longues sorties, et presque jamais pour les tâches par lots ou en arrière-plan.

OpenAI a rendu Ultrafast généralement disponible sur GPT-6 Astra lors du DevDay le 29 septembre 2026 (voir tout le reste du DevDay). Cet article couvre la disponibilité, la requête, les prix, les limites de débit et un modèle de seuil de rentabilité que vous pouvez réexécuter avec vos propres chiffres. Pour le modèle lui-même, lisez le guide de l'API GPT-6 Astra. Vous mesurerez les deux niveaux dans Apidog avant de changer.

OpenAI Ultrafast en un coup d'œil

Sources : guide du mode Ultrafast et page de tarification d'OpenAI.

Ce qu'est Ultrafast, et qui peut l'utiliser

Le récapitulatif du DevDay d'OpenAI présente Ultrafast comme son niveau de vitesse premium. Selon le guide, GPT-6 Astra Ultrafast est accessible à tous les utilisateurs de l'API avec des limites de débit par défaut basses, et les organisations disposant d'une équipe de compte OpenAI peuvent en demander davantage. Le guide mentionne également un accès anticipé pour GPT-5.6 Sol via les équipes de compte (OpenAI a prévisualisé pour la première fois Ultrafast sur GPT-5.6 Sol le 13 août), tandis que le récapitulatif nomme GPT-6.1 Sol comme le prochain. Aucun des deux n'a de prix Ultrafast publié.

Dans ChatGPT, Ultrafast Astra fonctionne dans ChatGPT Work et Codex sur Pro 500 et Enterprise. Cet abonnement couvre les applications, pas l'API : les scripts, les tâches d'intégration continue (CI) et les agents que vous construisez paient toujours par jeton avec une clé API.

Lisez attentivement la revendication de vitesse. Elle concerne la génération de jetons, et elle précise « jusqu'à ». Le chiffre de 300 jetons par seconde est pour Codex ; la revendication de l'API est jusqu'à 6x. OpenAI ne publie pas de chiffre de temps avant le premier jeton (TTFT) pour Ultrafast, et un nombre de jetons par seconde ne vous dit rien sur le temps que vous attendez pour le premier jeton.

Comment activer service_tier ultrafast

Définissez model sur gpt-6-astra et service_tier sur ultrafast pour chaque requête. Via HTTP, d'après la documentation d'OpenAI :

curl https://api.openai.com/v1/responses \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-6-astra",
    "input": "Explain why the sky is blue in one sentence.",
    "service_tier": "ultrafast"
  }'

OpenAI recommande fortement les WebSockets, en particulier pour les agents qui effectuent de nombreux appels d'outils en succession rapide, car la surcharge réseau par requête peut annuler le gain. Voici l'exemple Python de la documentation, qui diffuse deux tours sur une seule connexion :

from openai import OpenAI

client = OpenAI()
previous_response_id: str | None = None
prompts = [
    "Explain why the sky is blue in one sentence.",
    "Now explain why sunsets look red.",
]

with client.responses.connect() as connection:
    for prompt in prompts:
        connection.response.create(
            model="gpt-6-astra",
            service_tier="ultrafast",
            previous_response_id=previous_response_id,
            input=prompt,
        )
        for event in connection:
            if event.type == "response.output_text.delta":
                print(event.delta, end="", flush=True)
            elif event.type == "response.completed":
                previous_response_id = event.response.id
                print()
                break
            elif event.type in {"response.failed", "response.incomplete", "error"}:
                raise RuntimeError(event.to_json())
        else:
            raise RuntimeError("Connection closed before the response finished.")

Installez avec `pip install --upgrade "openai[realtime]"` et définissez `OPENAI_API_KEY`. Notre guide du mode WebSocket d'OpenAI couvre les limites de connexion et les reconnexions.

Tarification Ultrafast par rapport à Standard, Fast et Batch

Prix par million de jetons pour gpt-6-astra avec un contexte court (272K jetons d'entrée ou moins) :

Au-delà de 272K jetons d'entrée, Ultrafast passe à 120,00 $ en entrée, 12,00 $ en cache, 150,00 $ pour l'écriture en cache et 450,00 $ en sortie. Fast est l'ancien traitement Prioritaire, renommé le 30 juillet 2026. Notez que chaque colonne d'entrée est également multipliée, de sorte que les longues invites paient 6x sur les jetons que la revendication de vitesse ne vise pas.

Limites de débit et résidence des données

Les limites Ultrafast par défaut de GPT-6 Astra sont de 500 000 jetons par minute pour les Niveaux d'utilisation 1 à 3, 1 000 000 pour le Niveau 4 et 5 000 000 pour le Niveau 5. Ultrafast prend en charge uniquement la résidence des données aux États-Unis et le traitement global. Si votre contrat achemine le trafic via un point d'accès (endpoint) de l'UE ou d'une autre région, Ultrafast n'est pas disponible pour ce projet.

Quand Ultrafast est rentable : un modèle de seuil de rentabilité

Ceci est une arithmétique illustrative basée sur les prix catalogue, et non un benchmark. La seule donnée de vitesse est un substitut : supposez que votre propre mesure montre qu'Astra Standard diffuse 40 jetons de sortie par seconde sur votre invite. Remplacez par votre chiffre.

Une réponse destinée à l'utilisateur : 5 000 jetons d'entrée non mis en cache, 2 000 jetons de sortie.

• Standard : 0,05 $ en entrée + 0,10 $ en sortie = 0,15 $.
• Ultrafast : 0,30 $ + 0,60 $ = 0,90 $, soit 0,75 $ de plus.
• Temps de génération : 2 000 / 40 = 50 secondes en Standard, environ 8,3 secondes à pleine vitesse (6x). Vous économisez environ 41,7 secondes.
• Coût par seconde économisée : 0,75 $ / 41,7 = 0,018 $, soit 64,80 $ par heure d'attente supprimée.

Si votre accélération mesurée est inférieure au plafond, chaque seconde économisée coûte plus cher :

Une boucle d'agent : 20 étapes, chacune avec 20 000 jetons d'entrée (18 000 mis en cache, 2 000 nouveaux) et 500 jetons de sortie, ignorant les frais d'écriture en cache.

• Standard : 0,018 $ mis en cache + 0,020 $ nouvelle entrée + 0,025 $ sortie = 0,063 $ par étape, 1,26 $ par exécution.
• Ultrafast : 7,56 $ par exécution, soit 6,30 $ de plus.
• Temps de génération : 250 secondes en Standard, environ 41,7 à 6x. Vous économisez environ 208 secondes.
• Coût par seconde économisée : environ 0,030 $, soit 109,00 $ par heure.

L'agent achète des secondes à un taux moins avantageux car la majeure partie de sa facture est due à l'entrée, qui bénéficie du prix 6x sans l'accélération de la génération. Pour la sortie seule à une vitesse de 6x, chaque seconde économisée coûte environ 0,0003 $ multiplié par vos jetons de sortie Standard par seconde ; l'entrée ne fait qu'augmenter ce coût.

La question est donc concrète : une personne, ou quelque chose ayant une valeur monétaire, est-elle bloquée pendant ces secondes, et cette attente vaut-elle plus de 65,00 $ à 110,00 $ par heure ? Un ingénieur bloqué sur votre agent de codage interne, ou un client fixant un indicateur de chargement dans un flux payant, peut franchir ce seuil. Une tâche cron ne le peut pas.

Quand Ultrafast n'est pas rentable

• Personne n'attend. Les évaluations nocturnes, les rattrapages et les rapports appartiennent à l'API Batch ou à Flex, à 5,00 $ en entrée et 25,00 $ en sortie, soit un douzième du tarif Ultrafast.
• Agents en arrière-plan. Si un agent s'exécute sans surveillance et signale une fois terminé, le fait de finir trois minutes plus tôt change rarement le résultat.
• Sorties courtes. Une classification de 50 jetons a peu de temps de génération à réduire ; la configuration de la connexion et l'attente du premier jeton dominent, surtout via HTTP.
• Longues invites. Les appels avec beaucoup d'entrée paient 6x sur les jetons que la revendication de vitesse ne couvre pas, et au-delà de 272K jetons d'entrée, les tarifs montent à 120,00 $ et 450,00 $.
• Traitement régional. Pas de points d'accès (endpoints) de l'UE.
• Appels limités par le TTFT. Notre analyse de la latence de GPT-6 Sol a montré que lors de longues exécutions de raisonnement, la majeure partie du temps d'exécution s'écoulait avant le premier jeton visible. Si votre latence se situe là, mesurez si Ultrafast la réduit avant de payer pour cela.

Mesurez le TTFT et le temps total dans Apidog avant de basculer

Remplacez le substitut par vos propres chiffres en une dizaine de minutes.

1. Créez un environnement dans Apidog avec OPENAI_API_KEY. Ajoutez une requête POST à https://api.openai.com/v1/responses avec l'en-tête Authorization: Bearer {{OPENAI_API_KEY}} et ce corps :

{
  "model": "gpt-6-astra",
  "input": "<votre véritable invite de production>",
  "service_tier": "ultrafast",
  "stream": true
}

2. Dupliquez la requête et supprimez service_tier pour la base de référence Standard. Gardez l'invite identique.
3. Envoyez les deux. Apidog affiche le flux d'événements server-sent événement par événement. Notez quand le premier response.output_text.delta arrive (TTFT) et quand le flux se termine (temps total), et conservez le bloc usage de l'événement final response.completed pour le coût.
4. Répétez chaque variante au moins 10 fois et comparez les médianes et p95, pas les exécutions uniques.
5. Pour les boucles d'agents, testez le chemin WebSocket : ouvrez une requête WebSocket dans Apidog vers wss://api.openai.com/v1/responses avec le même en-tête, envoyez un message response.create avec les mêmes champs moins stream, puis un deuxième tour avec previous_response_id. La comparaison WebSocket vs SSE explique pourquoi la connexion ouverte est importante.

Les secondes économisées correspondent au temps total médian en Standard moins le temps médian en Ultrafast. Évaluez le coût des jetons usage aux deux tarifs, divisez, et comparez le résultat avec ce que l'attente vous coûte.

FAQ

Qu'est-ce qu'OpenAI Ultrafast ? Un niveau de service de l'API de Réponses qui génère des jetons jusqu'à 6 fois plus vite dans l'API pour 6 fois le prix Standard. Vous l'activez par requête avec service_tier: "ultrafast".

Ultrafast est-il un modèle plus intelligent ? Non. Vous appelez le même ID de modèle gpt-6-astra ; le niveau modifie la vitesse et le prix, pas le modèle.

Combien coûte GPT-6 Astra Ultrafast ? 60,00 $ en entrée, 6,00 $ en entrée mise en cache, 75,00 $ pour l'écriture en cache et 300,00 $ en sortie par million de jetons avec un contexte court, contre 10,00 $, 1,00 $, 12,50 $ et 50,00 $ en Standard.

D'où vient le chiffre de « 300 jetons par seconde » ? C'est le chiffre d'OpenAI pour Ultrafast dans Codex, où il revendique jusqu'à 8x. La revendication de l'API est jusqu'à 6x.

GPT-6.1 Sol prend-il en charge Ultrafast ? Pas encore. OpenAI affirme que cela arrivera bientôt ; le récapitulatif du DevDay 2026 suit ce qui est en ligne.

Étape suivante

Choisissez votre requête utilisateur la plus lente, exécutez-la en Standard et en Ultrafast dix fois chacune, et comparez les secondes médianes économisées au coût supplémentaire. Téléchargez Apidog pour conserver les deux variantes, leurs chronométrages et leurs chiffres d'utilisation dans un seul projet.