Tarifs de l'API OpenAI (octobre 2026) : GPT-6, GPT-5.6 et chaque tarif par token expliqué

Tarifs de l'API OpenAI (octobre 2026) : GPT-6, GPT-5.6 et chaque tarif par token expliqué

En octobre 2026, les tarifs de l'API OpenAI vont de 0,10 $ par million de tokens d'entrée et 0,50 $ par million de tokens de sortie pour gpt-6-luna jusqu'à 10 $ en entrée et 50 $ en sortie pour le modèle phare gpt-6-astra, avec gpt-6.1-sol au milieu à 2 $ en entrée et 10 $ en sortie. Batch et Flex divisent ces tarifs par deux, le mode Fast les double, et toute requête de plus de 272K tokens d'entrée passe à un tarif contexte long plus élevé. Tous les chiffres ci-dessous proviennent de la page officielle des tarifs de l'API d'OpenAI, consultée le 21 octobre 2026.

Ce guide s'adresse aux indie hackers et petites équipes qui paient eux-mêmes la facture. Il couvre les lignes actuelles GPT-6 et GPT-5.6, les niveaux de traitement qui changent votre coût réel, la nouvelle tarification d'écriture en cache, les frais d'outils et de médias, une estimation mensuelle chiffrée, du code de calcul des coûts à copier, et la comparaison de prix d'OpenAI avec Claude, Gemini et DeepSeek.

Tarifs de l'API OpenAI en un coup d'œil

Question	Réponse (au 21 oct. 2026)
Modèle le moins cher de la famille actuelle	gpt-6-luna : 0,10 $ entrée / 0,01 $ en cache / 0,50 $ sortie par 1M tokens
Choix équilibré par défaut	gpt-6.1-sol : 2,00 $ entrée / 0,10 $ en cache / 10,00 $ sortie
Modèle haut de gamme	gpt-6-astra : 10,00 $ entrée / 1,00 $ en cache / 50,00 $ sortie
Seuil de contexte long	Au-delà de 272K tokens d'entrée, colonne contexte long
Batch et Flex	50 % des tarifs Standard
Mode Fast (ex-Priority)	2x les tarifs Standard
Ultrafast	6x les tarifs Standard (Astra et 6.1 Sol uniquement)
Résidence régionale des données	+10 % pour les modèles sortis à partir du 5 mars 2026
Outil de recherche web	10 $ par 1 000 appels, plus les tokens du contenu de recherche

Source : tarifs de l'API OpenAI, 21 octobre 2026. OpenAI précise que le traitement Priority a été renommé mode Fast le 30 juillet 2026.

Prix de GPT-6 et GPT-5.6 par million de tokens

Le tableau présente les tarifs Standard. « Court » signifie jusqu'à 272K tokens d'entrée ; « Long », plus de 272K. La page des modèles d'OpenAI positionne Astra pour le raisonnement complexe et le code, 6.1 Sol comme équilibre entre intelligence et coût, et Luna pour les charges volumineuses sensibles au coût.

Modèle	Entrée (court)	Entrée en cache	Sortie (court)	Entrée (long)	Sortie (long)
gpt-6-astra	10,00 $	1,00 $	50,00 $	20,00 $	75,00 $
gpt-6.1-sol	2,00 $	0,10 $	10,00 $	4,00 $	15,00 $
gpt-6-sol	2,00 $	0,20 $	10,00 $	4,00 $	15,00 $
gpt-6-luna	0,10 $	0,01 $	0,50 $	0,20 $	0,75 $
gpt-5.6-sol	4,00 $	0,40 $	20,00 $	8,00 $	30,00 $
gpt-5.6-terra	2,00 $	0,20 $	12,00 $	4,00 $	18,00 $
gpt-5.6-luna	0,20 $	0,02 $	1,20 $	0,40 $	1,80 $
gpt-5.5	5,00 $	0,50 $	30,00 $	10,00 $	45,00 $
gpt-5.4	2,50 $	0,25 $	15,00 $	5,00 $	22,50 $

Source : tarifs de l'API OpenAI, niveau Standard, 21 octobre 2026.

Trois points ressortent quand on lit les lignes côte à côte :

• gpt-6.1-sol et gpt-6-sol coûtent le même prix par token, mais 6.1 Sol a un prix d'entrée en cache deux fois plus bas (0,10 $ contre 0,20 $). Si votre application renvoie un long prompt système, 6.1 Sol est le Sol le moins cher en trafic réel.
• Plus ancien ne veut pas dire moins cher. gpt-5.6-sol coûte deux fois plus que gpt-6.1-sol en entrée comme en sortie, et gpt-5.5 coûte 2,5 fois plus en entrée. OpenAI indique que le tarif promotionnel de GPT-5.6 Sol est disponible au moins jusqu'au 21 novembre 2026 : revérifiez-le avant de budgéter au-delà.
• Les longs prompts changent de catégorie de prix. Dépasser 272K tokens d'entrée double l'entrée sur toutes les lignes GPT-6 et augmente la sortie de 50 %. Le retrieval ou le découpage qui maintient les requêtes sous 272K est souvent la plus grosse économie sur les charges riches en documents.

Modèles plus anciens et plus petits encore listés

Modèle	Entrée	Entrée en cache	Sortie
gpt-5.4-mini	0,75 $	0,075 $	4,50 $
gpt-5.4-nano	0,20 $	0,02 $	1,25 $
gpt-5-mini	0,25 $	0,025 $	2,00 $
gpt-5-nano	0,05 $	0,005 $	0,40 $
gpt-4.1	2,00 $	0,50 $	8,00 $
gpt-4o-mini	0,15 $	0,075 $	0,60 $
o3	2,00 $	0,50 $	8,00 $
o4-mini	1,10 $	0,275 $	4,40 $

Source : tarifs de l'API OpenAI, 21 octobre 2026. gpt-5-nano affiche le prix par token le plus bas de la page, mais testez la qualité avant d'abandonner gpt-6-luna pour lui : Luna est le modèle qu'OpenAI recommande actuellement pour les gros volumes.

Niveaux de traitement : Standard, Batch, Flex, Fast et Ultrafast

Un même modèle a jusqu'à cinq prix selon la vitesse à laquelle vous voulez la réponse. Voici gpt-6.1-sol par niveau (contexte court, par million de tokens) :

Niveau	Entrée	Entrée en cache	Sortie	Quand l'utiliser
Standard	2,00 $	0,10 $	10,00 $	Trafic produit interactif
Batch	1,00 $	0,05 $	5,00 $	Tâches hors ligne qui peuvent attendre la Batch API
Flex	1,00 $	0,05 $	5,00 $	Requêtes de faible priorité tolérant une capacité plus lente, parfois indisponible
Fast	4,00 $	0,20 $	20,00 $	Chemins critiques en latence (ex-Priority)
Ultrafast	12,00 $	0,60 $	60,00 $	Option à la plus faible latence, Astra et 6.1 Sol uniquement

Source : tarifs de l'API OpenAI, 21 octobre 2026.

Pour un produit indépendant, la règle pratique est simple : mettez évaluations, enrichissement nocturne, backfills et génération de contenu en Batch, gardez le chat utilisateur en Standard, et ne payez Fast que sur le ou les deux endpoints où la latence se voit dans votre tunnel de conversion. Si les plafonds de débit vous importent aussi, lisez notre guide des limites LLM : RPM, TPM et retries avant d'acheter de la vitesse.

Prompt caching : lectures en cache et nouveaux tarifs d'écriture

Le tableau de prix d'OpenAI comporte désormais deux colonnes d'écriture en cache. Selon le guide du prompt caching, pour GPT-5.6 et ultérieurs, une écriture en cache coûte 1,25x le tarif d'entrée normal pour la durée par défaut de 30 minutes, une durée de 12 heures (Responses API) coûte 2,5x, et les lectures suivantes 0,1x. L'écriture en cache n'est pas un frais supplémentaire : chaque token d'entrée est facturé une seule fois, au tarif sans cache, en cache ou d'écriture.

Le calcul d'OpenAI : écrire un préfixe une fois et le réutiliser une fois coûte 1,35x son coût d'entrée normal, contre 2x sans cache ; une écriture plus neuf lectures coûte 2,15x contre 10x. Autrement dit, le cache est rentable dès la deuxième requête.

Ce que cela implique pour votre application :

1. Placez le contenu stable en premier : prompt système, définitions d'outils, exemples few-shot, documentation produit.
2. Placez le contenu propre à l'utilisateur et changeant à la fin pour ne pas déclencher de nouvelles écritures.
3. N'utilisez la durée de 12 heures que pour des préfixes sollicités de nombreuses fois dans la journée, car l'écriture coûte deux fois plus qu'une écriture de 30 minutes.

Nous détaillons le seuil de rentabilité dans coût et ROI du workflow de prompt caching.

Frais d'outils, d'image, d'audio et autres

Dès que vous activez les outils intégrés ou des modèles média, les tarifs par token ne sont qu'une partie de la facture. Tarifs de la page officielle, 21 octobre 2026 :

Élément	Prix
Recherche web (tous modèles)	10,00 $ par 1 000 appels + tokens du contenu de recherche au tarif du modèle
Recherche de fichiers	0,10 $ par Go et par jour de stockage (1 Go gratuit) ; 2,50 $ par 1 000 appels d'outil
Conteneurs Hosted Shell / Code Interpreter	De 0,03 $ par session de 20 minutes (1 Go) à 1,92 $ (64 Go)
gpt-image-2.5-sunburst / gpt-image-2.5-flare	Entrée image 8,00 $, sortie image 30,00 $, entrée texte 5,00 $ par 1M tokens
gpt-realtime-2.1	Audio 32,00 $ entrée / 64,00 $ sortie ; texte 4,00 $ / 24,00 $ par 1M tokens
Sessions vocales gpt-live-1	0,05 $ par minute, facturé à la seconde
gpt-transcribe	0,0045 $ par minute
gpt-5.3-codex	1,75 $ entrée / 14,00 $ sortie par 1M tokens

OpenAI précise aussi que les API Responses, Chat Completions, Realtime, Batch et Assistants ne sont pas tarifées séparément : vous payez les tarifs par token du modèle quel que soit l'endpoint appelé. Le fine-tuning est en cours d'arrêt et fermé aux nouveaux utilisateurs ; ne planifiez pas de nouveaux travaux autour. Pour les budgets image, voir notre guide des tarifs de l'API image d'OpenAI.

Exemple chiffré : ce que paie réellement un petit SaaS

Supposons une fonctionnalité IA qui envoie 20M tokens d'entrée et génère 4M tokens de sortie par mois en Standard, contexte court, sans cache :

Modèle	Coût d'entrée	Coût de sortie	Total mensuel
gpt-6-luna	20 x 0,10 $ = 2,00 $	4 x 0,50 $ = 2,00 $	4,00 $
gpt-5.6-luna	20 x 0,20 $ = 4,00 $	4 x 1,20 $ = 4,80 $	8,80 $
gpt-6.1-sol	20 x 2,00 $ = 40,00 $	4 x 10,00 $ = 40,00 $	80,00 $
gpt-5.6-terra	20 x 2,00 $ = 40,00 $	4 x 12,00 $ = 48,00 $	88,00 $
gpt-6-astra	20 x 10,00 $ = 200,00 $	4 x 50,00 $ = 200,00 $	400,00 $

Calculé à partir des tarifs publiés par OpenAI, 21 octobre 2026.

Ajoutez maintenant le cache sur gpt-6.1-sol. Si la moitié de l'entrée (10M tokens) est un préfixe réutilisé, 1M est écrit en cache à 2,50 $ et 9M sont lus à 0,10 $ : 10M x 2 $ + 1M x 2,50 $ + 9M x 0,10 $ + 4M x 10 $ = 20 $ + 2,50 $ + 0,90 $ + 40 $ = 63,40 $, environ 21 % de moins. Passez la même tâche en Batch et le total est à nouveau divisé par deux environ. Le changement le moins cher reste généralement le choix du modèle : si Luna passe vos évaluations sur une route, il est 20 fois moins cher que 6.1 Sol sur cette charge.

Notez que la sortie représente la moitié de la facture sur Sol et Astra. Plafonner max_output_tokens, demander une sortie structurée plutôt que de la prose et réduire l'effort de raisonnement sur les routes simples réduisent tous la ligne la plus chère.

Code à copier : appeler l'API et chiffrer chaque requête

Utilisez l'objet usage renvoyé par l'API plutôt que d'estimer les tokens à la main.

curl https://api.openai.com/v1/responses \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-6.1-sol",
    "input": "Summarize this changelog in three bullet points: ...",
    "max_output_tokens": 300
  }'

# pip install openai
from openai import OpenAI

# Standard short-context rates per 1M tokens, OpenAI pricing page, Oct 21, 2026
RATES = {
    "gpt-6-luna":  {"in": 0.10, "cached": 0.01, "out": 0.50},
    "gpt-6.1-sol": {"in": 2.00, "cached": 0.10, "out": 10.00},
    "gpt-6-astra": {"in": 10.00, "cached": 1.00, "out": 50.00},
}

def request_cost(model: str, usage) -> float:
    r = RATES[model]
    cached = getattr(usage.input_tokens_details, "cached_tokens", 0) or 0
    uncached = usage.input_tokens - cached
    return (uncached * r["in"] + cached * r["cached"] + usage.output_tokens * r["out"]) / 1_000_000

client = OpenAI()
resp = client.responses.create(model="gpt-6.1-sol", input="Write a SQL query that finds churned users.", max_output_tokens=400)
print(resp.output_text)
print(f"cost: ${request_cost('gpt-6.1-sol', resp.usage):.6f}")

// npm install openai
import OpenAI from "openai";

const client = new OpenAI(); // reads OPENAI_API_KEY
const resp = await client.responses.create({
  model: "gpt-6-luna",
  input: "Classify this ticket as billing, bug, or feature request: ...",
  max_output_tokens: 20,
});
const u = resp.usage;
const cost = (u.input_tokens * 0.10 + u.output_tokens * 0.50) / 1e6; // gpt-6-luna Standard
console.log(resp.output_text, `$${cost.toFixed(6)}`);

Les prix de RATES sont un instantané. Stockez-les en configuration avec la date de vérification, et déclenchez une alerte quand le coût calculé s'écarte de la facture. Notre guide du tableau de bord d'usage des tokens montre comment le suivre par fonctionnalité.

OpenAI vs Claude, Gemini et DeepSeek sur le prix

Niveaux comparables, tarifs Standard par million de tokens, chacun tiré de la page officielle de son fournisseur le 21 octobre 2026 :

Modèle	Entrée	Sortie	Source
gpt-6-luna	0,10 $	0,50 $	OpenAI
claude-haiku-5-5 (prompts jusqu'à 100K)	0,10 $	0,50 $	Anthropic
gemini-3.8-flash (promo jusqu'au 31 déc. 2026)	0,75 $	3,75 $	Google
deepseek-v4-pro (pointe / creuses)	1,32 $ / 0,66 $	3,96 $ / 1,98 $	DeepSeek
gpt-6.1-sol	2,00 $	10,00 $	OpenAI
claude-sonnet-5-5	2,00 $	10,00 $	Anthropic
gemini-3.1-pro-preview (prompts jusqu'à 200K)	2,00 $	12,00 $	Google
gpt-6-astra	10,00 $	50,00 $	OpenAI

En entrée de gamme, gpt-6-luna et Claude Haiku 5.5 ont des prix catalogue identiques : le choix dépend de la qualité sur votre tâche et des limites de débit de chaque fournisseur. En milieu de gamme, gpt-6.1-sol et Claude Sonnet 5.5 sont aussi au même prix ; Gemini 3.1 Pro Preview est un peu plus cher en sortie. Pour une vue complète, voir nos guides des tarifs de l'API Claude, des tarifs de l'API Gemini et des tarifs de l'API DeepSeek, ou le comparatif des prix des API d'IA multi-fournisseurs.

Payer moins sans trop modifier votre code

Une fois le bon modèle choisi, il reste comme leviers le niveau de traitement, le cache et l'endroit où vous achetez les tokens. Flatkey est une passerelle compatible OpenAI : vous gardez le SDK OpenAI, changez l'URL de base en https://router.flatkey.ai/v1, et payez depuis un solde unique qui couvre aussi Claude, Gemini et DeepSeek. Le 21 octobre 2026, le répertoire des modèles de Flatkey affichait gpt-6.1-sol à 1,20 $ en entrée / 6,00 $ en sortie par million de tokens (40 % sous le prix catalogue OpenAI de 2/10 $) dans le cadre d'une promotion GPT qui, selon sa page d'accueil, court jusqu'au 23 octobre ; gpt-6-luna était à 0,06 / 0,30 $. Les remises évoluent : vérifiez la page en direct avant d'engager un budget.

from openai import OpenAI

client = OpenAI(api_key="YOUR_FLATKEY_KEY", base_url="https://router.flatkey.ai/v1")
resp = client.chat.completions.create(
    model="gpt-6.1-sol",
    messages=[{"role": "user", "content": "Draft a release note for v2.3."}],
)
print(resp.choices[0].message.content)

Le démarrage rapide Flatkey et le guide du SDK OpenAI couvrent les clés et identifiants de modèles. L'accès direct à OpenAI reste le bon choix si vous avez besoin de fonctionnalités propres à la plateforme d'OpenAI, comme certains outils de la Responses API ou un contrat entreprise.

Checklist tarifaire de l'API OpenAI avant le lancement

• Figez l'identifiant exact du modèle (par exemple gpt-6.1-sol, pas un alias générique) et notez le prix et la date de vérification.
• Estimez entrée et sortie séparément ; la sortie représente souvent 50 % ou plus de la facture.
• Gardez les requêtes sous 272K tokens d'entrée sauf si vous avez budgété le tarif contexte long.
• Basculez en Batch ou Flex tout ce qui peut attendre.
• Structurez les prompts pour le cache et journalisez cached_tokens pour confirmer les hits.
• Budgétisez les appels d'outils (recherche web, recherche de fichiers, conteneurs) comme lignes séparées.
• Ajoutez 10 % si vous utilisez des endpoints de résidence régionale des données.
• Revérifiez les lignes promotionnelles (GPT-5.6 Sol) avant leur date de fin.

FAQ

Combien coûte l'API OpenAI ?

Cela dépend du modèle. Au 21 octobre 2026, gpt-6-luna coûte 0,10 $ par million de tokens d'entrée et 0,50 $ par million de tokens de sortie, gpt-6.1-sol 2 $ et 10 $, et gpt-6-astra 10 $ et 50 $, selon la page de tarifs d'OpenAI. Une petite fonctionnalité typique avec 20M d'entrée et 4M de sortie par mois coûte environ 4 $ avec Luna et 80 $ avec 6.1 Sol.

L'API OpenAI est-elle gratuite ou payante ?

Payante. OpenAI facture l'usage de l'API au token selon les tarifs de sa page ; il n'y a aucune ligne gratuite dans le tableau actuel. L'usage de l'API est facturé sur la plateforme API, séparément des abonnements ChatGPT. Pour expérimenter sans coût, voir notre liste d'API LLM gratuites.

Pourquoi l'API OpenAI est-elle si chère ?

Ce n'est généralement pas le tarif de base mais la forme du trafic : longs prompts renvoyés à chaque appel, sorties verbeuses, modèles de raisonnement lourds sur des tâches simples, et mode Fast là où Standard suffirait. Le cache ramène l'entrée répétée à 0,1x, Batch divise tout par deux, et router les requêtes simples vers gpt-6-luna coûte 20 fois moins que gpt-6.1-sol.

L'API ChatGPT est-elle moins chère que ChatGPT Plus ?

Ce sont des produits différents. ChatGPT Plus est un abonnement mensuel forfaitaire pour utiliser ChatGPT ; l'API est facturée au token pour construire votre propre logiciel. Une charge personnelle légère peut coûter moins d'un dollar par mois avec gpt-6-luna, alors qu'une charge lourde avec gpt-6-astra peut coûter bien plus que n'importe quel abonnement. Comparez votre volume réel de tokens aux tarifs ci-dessus.

Quelle est la différence entre Batch et Flex ?

Les deux sont à 50 % du Standard sur la page de tarifs. Batch est une API de tâches asynchrones pour les grosses charges hors ligne ; Flex conserve le flux de requêtes normal mais échange vitesse et disponibilité contre un prix plus bas. Utilisez Batch pour les traitements en masse et Flex pour les requêtes d'arrière-plan qui s'intègrent à votre code existant.

Le contexte long coûte-t-il plus cher chez OpenAI ?

Oui. Pour les lignes GPT-6, GPT-5.6, GPT-5.5 et GPT-5.4, les requêtes de plus de 272K tokens d'entrée sont facturées sur la colonne contexte long, qui double l'entrée et augmente la sortie de 50 % sur les modèles GPT-6.

Sources

• Tarifs de l'API OpenAI, consulté le 21 octobre 2026
• Aperçu des modèles OpenAI, consulté le 21 octobre 2026
• Guide du prompt caching d'OpenAI, consulté le 21 octobre 2026
• Guide de la Batch API d'OpenAI, consulté le 21 octobre 2026
• Tarifs Anthropic Claude, tarifs de l'API Gemini et tarifs DeepSeek, consultés le 21 octobre 2026
• Prix Flatkey issus du répertoire des modèles Flatkey, consulté le 21 octobre 2026