OpenAI facture la génération d’images en tokens, et non à prix fixe par image. Cet article détaille les tarifs de chaque modèle GPT Image, le coût par image et pour 1 000 images à chaque niveau de qualité, un code Python fonctionnel qui journalise les dépenses réelles, et les habitudes qui réduisent la facture.
La tarification de l’API Image d’OpenAI paraît simple jusqu’à l’arrivée de la première facture. Il n’existe pas de prix fixe par image. Vous payez en tokens, et le nombre de tokens qu’utilise une image dépend du modèle, de la taille et du réglage quality que vous transmettez dans votre appel Python. Une image 1024x1024 peut coûter 0,006 $ ou 0,211 $ pour exactement le même prompt, soit un écart d’environ 35 fois. Cet article présente les tarifs actuels, les coûts par image pour chaque niveau de qualité, une configuration Python fonctionnelle et les habitudes qui évitent qu’un lot de 1 000 images ne se transforme en mauvaise surprise.
💡 À lire d’abord : les montants en dollars ci-dessous proviennent des tarifs en tokens publiés par OpenAI (30 $ par million de tokens de sortie image sur les modèles actuels) et de calculateurs tiers qui appliquent ces tarifs. La page tarifaire d’OpenAI indique des tokens et renvoie vers un calculateur, et non vers un tableau par image. Vérifiez-la donc avant de fixer un budget.
Chaque requête vers l’API Images est facturée sur trois compteurs. Les tokens d’entrée texte correspondent à votre prompt. Les tokens d’entrée image n’apparaissent que lorsque vous envoyez des photos de référence pour une modification. Les tokens de sortie image correspondent à l’image que vous recevez, et ils constituent presque toujours la plus grosse ligne de la facture.
Aux tarifs actuels, la formule est simple : tokens texte × 5 $, tokens d’entrée image × 8 $, tokens de sortie image × 30 $, le tout par million. La longueur du prompt pèse peu. Un prompt de 200 tokens coûte 0,001 $, alors qu’une sortie unique en haute qualité peut dépasser 1 700 tokens, soit environ 0,05 $ pour la seule image.
Voici les tarifs en tokens d’OpenAI, par million de tokens, pour chaque modèle de la famille :
| Modèle | Entrée texte | Entrée image | Sortie image |
|---|---|---|---|
| GPT Image 2.5 Flare | 5,00 $ | 8,00 $ | 30,00 $ |
| GPT Image 2.5 Sunburst | 5,00 $ | 8,00 $ | 30,00 $ |
| GPT Image 2 | 5,00 $ | 8,00 $ | 30,00 $ |
| GPT Image 1.5 | 5,00 $ | 8,00 $ | 32,00 $ |
| GPT Image 1 | 5,00 $ | 10,00 $ | 40,00 $ |
| GPT Image 1 Mini | 2,00 $ | 2,50 $ | 8,00 $ |
Les tokens en cache coûtent moins cher : 1,25 $ par million pour le texte et 2,00 $ pour les images sur la famille GPT Image 2. Les deux variantes 2.5 partagent exactement les tarifs de GPT Image 2, donc la liste des prix ne permet pas de choisir entre elles. C’est la consommation de tokens qui le fait.
Les modèles 2.5 acceptent low, medium, high, xhigh, max et auto pour le paramètre quality. GPT Image 2 fonctionne avec trois niveaux : low, medium et high. Pour les modèles 2.5, une analyse de Kanaries détaille les tokens de sortie par niveau. En les multipliant par 30 $ par million, on obtient ces prix par image :
| Qualité | Tokens en 1024x1024 | Coût en 1024x1024 | Tokens en 1536x1024 | Coût en 1536x1024 |
|---|---|---|---|---|
| low | 196 | 0,006 $ | 158 | 0,005 $ |
| medium | 439 | 0,013 $ | 343 | 0,010 $ |
| high | 1 756 | 0,053 $ | 1 372 | 0,041 $ |
| xhigh | 3 122 | 0,094 $ | 2 459 | 0,074 $ |
| max | 7 024 | 0,211 $ | 5 488 | 0,165 $ |
Deux points ressortent. D’abord, les formats rectangulaires sont moins chers que les carrés à chaque niveau, d’environ 20 à 22 %. Choisissez donc le paysage ou le portrait chaque fois que la mise en page le permet. Ensuite, la courbe des prix est raide : max coûte environ 36 fois low.
GPT Image 2 est indiqué par des calculateurs comme CostGoat à 0,006 $, 0,053 $ et 0,211 $ pour low, medium et high en 1024x1024, et à 0,005 $, 0,041 $ et 0,165 $ pour les rectangles. Ces montants correspondent aux lignes low, high et max des modèles 2.5, ce qui suggère que ces derniers ajoutent des paliers plus fins entre elles. Vérifiez les nombres de tokens sur votre propre compte avant de vous fier à cette correspondance.
Les centimes par image masquent le vrai budget. En multipliant les nombres de tokens pour un lot de 1 000 images, on obtient :
| Qualité | 1 000 images carrées | 1 000 images en paysage |
|---|---|---|
| low | 5,88 $ | 4,74 $ |
| medium | 13,17 $ | 10,29 $ |
| high | 52,68 $ | 41,16 $ |
| xhigh | 93,66 $ | 73,77 $ |
| max | 210,72 $ | 164,64 $ |
Ajoutez environ 0,75 $ par tranche de 1 000 images pour un prompt de 150 tokens. C’est toute la facture du prompt. Le réglage de qualité est le vrai levier budgétaire.
Low coûte environ un neuvième de high, et bien des travaux n’ont pas besoin de davantage. Les miniatures, les planches d’ambiance, les vérifications de concept et les tests A/B de composition rendent tous bien en low. Les visuels principaux, les maquettes d’emballage et tout ce qu’un client va zoomer méritent high ou plus.
Commencez par medium. Il coûte environ 2,2 fois low et un quart de high. C’est une valeur par défaut raisonnable pour un pipeline que personne n’a encore mesuré.
GPT Image 2.5 Flare est positionné pour la génération rapide au quotidien. Un test indique une latence d’environ la moitié de celle de GPT Image 2. Cette vitesse compte davantage en Python que dans une fenêtre de discussion : quand un utilisateur attend une requête web, chaque seconde compte, et des appels plus rapides signifient aussi moins de connexions ouvertes à gérer.
GPT Image 2.5 Sunburst vise les flux de travail où la précision de modification compte le plus, par exemple préserver un détail fin tout en changeant un élément. Il est plus lent et facturé aux mêmes tarifs par token que Flare. Si votre pipeline modifie surtout des photos produit, testez d’abord Sunburst. S’il crée surtout de nouvelles images, commencez par Flare.
| Modèle | Prix par image | Meilleur usage |
|---|---|---|
| GPT Image 2.5 Flare | 0,005 $ à 0,211 $ | Brouillons rapides et volume quotidien |
| GPT Image 2.5 Sunburst | 0,005 $ à 0,211 $ | Modifications précises |
| GPT Image 2 | 0,005 $ à 0,211 $ | Trois niveaux, prise en charge de la Batch API |
| GPT Image 1.5 | 0,009 $ à 0,20 $ | Projets déjà bâtis dessus |
| GPT Image 1 | 0,011 $ à 0,25 $ | Ancienne génération uniquement |
| GPT Image 1 Mini | 0,005 $ à 0,052 $ | Miniatures en masse les moins chères |
GPT Image 1 Mini plafonne à 0,052 $, soit environ un quart des 0,211 $ du modèle phare. C’est le choix économique pour les travaux en masse qui tolèrent une fidélité moindre. GPT Image 1 est à surveiller : CostGoat annonce une fin de service le 23 octobre 2026. Confirmez donc la date sur la page des dépréciations d’OpenAI et évitez de commencer quoi que ce soit de neuf avec lui.
Installez le SDK avec pip install openai et définissez vos identifiants dans l’environnement. Le client les lit automatiquement, ainsi rien de sensible ne se trouve dans votre code.
import base64
from pathlib import Path
from openai import OpenAI
client = OpenAI(timeout=180)
result = client.images.generate(
model="gpt-image-2.5-flare",
prompt="Studio photo of a cobalt-blue ceramic mug on a pale gray backdrop, soft light from the left",
size="1536x1024",
quality="medium",
)
Path("mug.png").write_bytes(base64.b64decode(result.data[0].b64_json))
L’image arrive en base64 dans b64_json. Décodez-la donc et écrivez les octets. OpenAI indique que les prompts complexes peuvent prendre jusqu’à deux minutes, c’est pourquoi le client ci-dessus fixe un délai d’attente explicite de 180 secondes. Une requête bloquée échoue alors au bout de trois minutes, au lieu de bloquer un worker.
Ne faites pas confiance à un tableau, y compris ceux ci-dessus. Journalisez ce que chaque appel a réellement consommé et convertissez-le en dollars :
TEXT_IN = 5.00 / 1_000_000
IMAGE_IN = 8.00 / 1_000_000
IMAGE_OUT = 30.00 / 1_000_000
def cost_of(result):
usage = result.usage
details = usage.input_tokens_details
return (
details.text_tokens * TEXT_IN
+ details.image_tokens * IMAGE_IN
+ usage.output_tokens * IMAGE_OUT
)
print(f"${cost_of(result):.4f}")
💡 Astuce : ces noms de champs suivent l’objet usage de l’API Images. Affichez
result.usageune fois avec votre version du SDK pour les confirmer avant de bâtir des rapports dessus.
Une boucle de brouillons peu coûteux se rentabilise en quelques images. Générez quatre brouillons en low, retenez la formulation du prompt qui fonctionne, puis dépensez une fois pour un rendu en high :
PROMPT = "Studio photo of a cobalt-blue ceramic mug on a pale gray backdrop, soft light from the left"
MODEL = "gpt-image-2.5-flare"
drafts = [
client.images.generate(model=MODEL, prompt=PROMPT, size="1536x1024", quality="low")
for _ in range(4)
]
# Review the drafts, adjust PROMPT, then pay for one final render.
final = client.images.generate(model=MODEL, prompt=PROMPT, size="1536x1024", quality="high")
Le calcul en 1536x1024 : quatre brouillons à 0,0047 $ plus une image finale à 0,0412 $ donnent environ 0,060 $. Trois tentatives à l’aveugle en high coûtent environ 0,123 $. Une réserve : le rendu final ne reproduira pas un brouillon pixel pour pixel. La boucle de brouillons sert donc à choisir le prompt, pas l’image.
Les images de référence sont facturées en entrée image à 8 $ par million de tokens. Dans une décomposition modélisée d’Omid Saffari, une génération neuve avec 200 tokens de texte et 2 000 tokens de sortie coûte 0,061 $. Ajoutez une image de référence de 6 000 tokens et la même requête coûte 0,109 $. La mise en cache de l’entrée répétée ramène le coût à environ 0,072 $. Ce sont des illustrations avec des hypothèses énoncées, pas des factures types, mais elles montrent la tendance : les flux de modification coûtent plus cher que la génération.
Le chiffre qui compte est le coût par image acceptée : le coût d’une tentative divisé par la part des tentatives que vous gardez.
Un niveau moins cher peut encore l’emporter, même si vous rejetez davantage de ses sorties. Mesurez votre propre taux d’acceptation pendant une semaine avant de choisir une valeur par défaut.
Le débit est plafonné par votre palier d’utilisation. Voici les limites qu’OpenAI indique pour GPT Image 2 :
| Palier | Tokens par minute | Images par minute |
|---|---|---|
| Palier 1 | 100 000 | 5 |
| Palier 2 | 250 000 | 20 |
| Palier 3 | 800 000 | 50 |
| Palier 4 | 3 000 000 | 150 |
| Palier 5 | 8 000 000 | 250 |
Au palier 1, cinq images par minute font au maximum 300 par heure. Au palier 3, 1 000 images s’écoulent en 20 minutes. Encadrez votre boucle d’un petit sémaphore ou d’une nouvelle tentative avec backoff, afin qu’une rafale d’erreurs 429 ne devienne pas une rafale de nouvelles tentatives inutiles.
low, finition une seule fois. La boucle ci-dessus coûte environ la moitié de trois tentatives high à l’aveugle.
Passez les brouillons en revue côte à côte avant toute passe de high. Une planche-contact de 12 brouillons peu coûteux permet à un designer d’en entourer les deux à finaliser, et cette revue ne prend que quelques minutes.
Avant d’intégrer un appel API dans un script, vous pouvez tester le même modèle dans un navigateur. GPT Image 2.5 Flare est disponible sur PicassoIA, et ses paramètres reprennent ceux de l’API, ce qui en fait un bac à sable pratique pour décider quel niveau appeler depuis Python.
quality. La valeur par défaut est auto. Utilisez un réglage bas pour les brouillons et un réglage élevé quand la composition est définitive. La page précise qu’une qualité supérieure prend plus de temps et coûte davantage.aspect_ratio. La valeur par défaut est 1:1. Testez un format paysage, puisque c’est la forme la moins chère dans l’API.number_of_images accepte de 1 à 10 pour comparer plusieurs options à partir d’un seul prompt. output_format est réglé par défaut sur webp, output_compression est réglé sur 90, et background peut être défini sur transparent pour les détourages. input_images accepte des photos de référence pour les modifications.💡 Astuce : lancez un même prompt en low et en high sur GPT Image 2.5 Flare, puis comparez le résultat avec GPT Image 2 et GPT Image 1 Mini avant d’en intégrer un seul dans un pipeline.
PicassoIA propose aussi une API pour développeurs de type Replicate à api.picassoia.com/v1, avec une authentification par Bearer token, des prédictions asynchrones en créer-puis-interroger et une limite de cinq prédictions simultanées par compte. Elle sert notamment PicassoIA Image et PicassoIA Image Editor Pro. Consultez picassoia.com/en/api pour les conditions d’accès et les tarifs actuels, car cet article ne les cite pas.
Les tableaux de prix ne vont que jusqu’à un certain point. Le meilleur chiffre est celui que vous mesurez avec vos propres prompts, votre propre taux d’acceptation et vos propres tailles. Choisissez trois prompts issus de votre charge de travail réelle, générez chacun en low, medium et high, et journalisez le coût avec la fonction utilitaire ci-dessus. Décidez ensuite quel niveau mérite sa place.
Si vous voulez voir la différence de qualité avant de dépenser le moindre centime sur l’API, ouvrez GPT Image 2.5 Flare ou GPT Image 2.5 Sunburst sur Picasso IA et générez votre propre série. Essayez une photo de produit, un portrait et une affiche avec un court texte, puis comparez-les à différents réglages. Votre première image de test n’est qu’à un clic.
Choisissez votre langue
