Optimiser les coûts
Šiame puslapyje
Mis à jour le 2 novembre 2026 — Modèles d’image.
gpt-image-1, le modèle pour lequel ce cours a été initialement rédigé, a été arrêté le 23 octobre 2026.gpt-image-1.5,gpt-image-1-minietchatgpt-image-latestseront retirés le 1er décembre 2026. Les exemples utilisent désormaisgpt-image-2.5-sunburst, qui offre la plus haute précision pour l’édition ;gpt-image-2.5-flareest plus rapide pour la génération standard. Les deux modèles prennent également en charge les niveaux de qualitéxhighetmax. Les modèles GPT Image renvoient toujours les images en base64 : le paramètreresponse_formatdes anciens modèles DALL·E n’est plus accepté et a été supprimé du code. Source : Génération d’images (OpenAI).
Optimiser les coûts
En production, la génération d’images cesse d’être une curiosité technique pour devenir une ligne budgétaire. Toute équipe produisant quelques centaines de visuels par mois le remarque rapidement. La première réaction — restreindre l’usage — est aussi la moins intelligente. Cette leçon couvre cinq stratégies qui réduisent les dépenses sans compromettre la qualité de vos livrables, car elles ciblent ce que vous jetez plutôt que ce que vous gardez.
Comprendre la structure des coûts
Les coûts de génération dépendent de trois facteurs.
| Facteur | Impact sur le coût |
|---|---|
Qualité (low, medium, high) | Multiplicateur direct |
| Résolution (1024, 1536) | Plus grand = plus cher |
Nombre d’images (n) | Coût linéaire (n × prix unitaire) |
Ces trois facteurs se multiplient entre eux, ce qui explique pourquoi une exploration indisciplinée coûte un ordre de grandeur de plus que la même exploration menée avec rigueur. Le script ci-dessous liste les cinq combinaisons que vous rencontrerez le plus souvent en production. Bien que les montants exacts apparaissent sur votre tableau de bord OpenAI, l’ordre des lignes montre déjà l’échelle des compromis.
from openai import OpenAI
client = OpenAI()
# Compare costs: same prompt, different parameters
configs = [
{"quality": "low", "size": "1024x1024", "label": "Low / 1024"},
{"quality": "medium", "size": "1024x1024", "label": "Medium / 1024"},
{"quality": "high", "size": "1024x1024", "label": "High / 1024"},
{"quality": "medium", "size": "1536x1024", "label": "Medium / 1536"},
{"quality": "high", "size": "1536x1024", "label": "High / 1536"},
]
print("Configuration | Usage (estimated)")
print("-" * 50)
for config in configs:
print(f"{config['label']:22s} | Check your OpenAI dashboard")
Prototyper en « Low », livrer en « High »
C’est de loin la stratégie la plus rentable et la plus simple à adopter. Durant la phase d’exploration, tu ne juges pas la finesse d’un dégradé : tu juges la composition, le cadrage et l’ambiance générale, tous parfaitement visibles avec quality: low. Passer à high n’a de sens que pour l’image que tu comptes réellement publier. Le flux de travail ci-dessous formalise cette séquence en produisant cinq brouillons économiques suivis d’un seul rendu final, avec l’avantage supplémentaire de passer au format paysage (1536×1024) pour la version définitive. Sur cinq essais et une livraison, les économies citées à la fin du script tournent autour de 60 % par rapport à une exploration menée entièrement en high.
from openai import OpenAI
import base64
client = OpenAI()
def economical_workflow(prompt: str, output: str, n_drafts: int = 5):
"""
Two-phase workflow:
1. Fast drafts in low quality
2. Final render in high quality
"""
# Phase 1: Fast exploration
print("Phase 1: fast drafts (low quality)")
drafts = []
for i in range(n_drafts):
response = client.images.generate(
model="gpt-image-2.5-sunburst",
prompt=prompt,
size="1024x1024",
quality="low",
)
path = f"draft_{i+1}.png"
data = base64.b64decode(response.data[0].b64_json)
with open(path, "wb") as f:
f.write(data)
drafts.append(path)
print(f" Draft {i+1}: {path}")
# Phase 2: Final render (after human selection of the best draft)
print("\nPhase 2: final render (high quality)")
response = client.images.generate(
model="gpt-image-2.5-sunburst",
prompt=prompt,
size="1536x1024",
quality="high",
)
data = base64.b64decode(response.data[0].b64_json)
with open(output, "wb") as f:
f.write(data)
print(f" Final render: {output}")
# Summary: 5 low + 1 high instead of 5 high
print(f"\nSummary: {n_drafts} low drafts + 1 final high")
print("Estimated savings: ~60% compared to all-high exploration")
economical_workflow(
"Illustration of a green tech campus with solar panels, architectural style",
"campus_final.png"
)
Ne jamais payer deux fois la même image
Dans une application réelle, le même prompt revient bien plus souvent que tu ne le penses : un utilisateur qui actualise la page, un script de build qui relance une génération, ou une icône réutilisée sur trois pages. Chacun de ces cas constitue une facturation inutile. Le cache ci-dessous les élimine en calculant un hachage SHA-256 du triplet (prompt, taille, qualité) — les trois éléments qui déterminent le résultat facturé — et en tronquant ce hachage à seize caractères pour créer un nom de fichier gérable. Note la vérification os.path.exists : l’index peut connaître une entrée dont le fichier a été supprimé du disque ; dans ce cas, le code régénère l’image plutôt que de renvoyer un chemin mort.
import hashlib
import json
import os
from openai import OpenAI
import base64
client = OpenAI()
CACHE_DIR = "image_cache"
CACHE_INDEX = os.path.join(CACHE_DIR, "index.json")
def load_cache() -> dict:
"""Loads the cache index."""
if os.path.exists(CACHE_INDEX):
with open(CACHE_INDEX, "r") as f:
return json.load(f)
return {}
def save_cache(cache: dict):
"""Saves the cache index."""
os.makedirs(CACHE_DIR, exist_ok=True)
with open(CACHE_INDEX, "w") as f:
json.dump(cache, f, indent=2, ensure_ascii=False)
def generate_with_cache(
prompt: str,
size: str = "1024x1024",
quality: str = "medium"
) -> str:
"""Generates an image or returns the cached result."""
# Create a unique key based on parameters
key_data = f"{prompt}|{size}|{quality}"
cache_key = hashlib.sha256(key_data.encode()).hexdigest()[:16]
cache = load_cache()
if cache_key in cache:
cached_path = cache[cache_key]["path"]
if os.path.exists(cached_path):
print(f"Cache hit: {cached_path}")
return cached_path
else:
print("Cache expired, regenerating...")
# Not in cache: generate
response = client.images.generate(
model="gpt-image-2.5-sunburst",
prompt=prompt,
size=size,
quality=quality,
)
path = os.path.join(CACHE_DIR, f"{cache_key}.png")
os.makedirs(CACHE_DIR, exist_ok=True)
data = base64.b64decode(response.data[0].b64_json)
with open(path, "wb") as f:
f.write(data)
cache[cache_key] = {
"prompt": prompt[:100],
"size": size,
"quality": quality,
"path": path
}
save_cache(cache)
print(f"Generated and cached: {path}")
return path
# First generation: API call
path1 = generate_with_cache("Minimalist logo for a tech startup, blue and white")
# Second identical call: served from cache
path2 = generate_with_cache("Minimalist logo for a tech startup, blue and white")
Dimensionner avec précision
Générer une vignette haute résolution qui sera affichée dans un carré de 80 pixels revient à payer un tirage d’exposition juste pour le glisser dans un portefeuille. Le remède est de cesser de laisser ce choix au bon vouloir du développeur et de le dériver plutôt de l’usage déclaré. Le dictionnaire generate_for_usage répartit les cas en trois familles : les petits formats web — vignettes et avatars — qui se contentent de low ; l’usage web standard — en-têtes de blog, publications sociales — qui appellent du medium ; et les médias où la finesse compte vraiment — bannières hero, impression A4, portfolios — qui justifient du high. Les deux derniers appels illustrent l’écart : le même chat astronaute coûte un multiple selon qu’il finisse en vignette ou en bannière de page d’accueil.
from openai import OpenAI
import base64
client = OpenAI()
def generate_for_usage(prompt: str, usage: str, output: str):
"""Automatically chooses optimal resolution and quality."""
configs = {
# Small web usage
"thumbnail": {"size": "1024x1024", "quality": "low"},
"avatar": {"size": "1024x1024", "quality": "low"},
# Standard web usage
"blog_header": {"size": "1536x1024", "quality": "medium"},
"social_post": {"size": "1024x1024", "quality": "medium"},
# High-quality usage
"hero_banner": {"size": "1536x1024", "quality": "high"},
"print_a4": {"size": "1024x1536", "quality": "high"},
"portfolio": {"size": "1024x1024", "quality": "high"},
}
config = configs.get(usage, {"size": "1024x1024", "quality": "medium"})
response = client.images.generate(
model="gpt-image-2.5-sunburst",
prompt=prompt,
size=config["size"],
quality=config["quality"],
)
data = base64.b64decode(response.data[0].b64_json)
with open(output, "wb") as f:
f.write(data)
print(f"Usage {usage} ({config['quality']}/{config['size']}) → {output}")
generate_for_usage("Cute cat in an astronaut suit", "thumbnail", "cat_thumb.png")
generate_for_usage("Cute cat in an astronaut suit", "hero_banner", "cat_hero.png")
Éditer plutôt que régénérer
Le client approuve la photo mais veut un ciel différent. Le réflexe naturel — relancer la génération complète avec un prompt ajusté — te fait payer une image entière et, pire, te fait perdre le reste de la composition que tout le monde avait approuvé. images.edit() gère cette situation pour le prix d’une édition : la fonction edit_detail construit un masque qui libère uniquement le rectangle pertinent, ici les 300 pixels de hauteur supérieurs correspondant au ciel, et le prompt décrit uniquement le contenu de cette bande. Le paysage lui-même ne bouge pas d’un pixel.
import base64
from openai import OpenAI
from PIL import Image, ImageDraw
client = OpenAI()
# Instead of regenerating the entire image to change a detail,
# edit only the relevant area.
def edit_detail(image_path: str, zone: tuple, new_content: str, output: str):
"""
Edits a detail in an existing image.
zone: (x1, y1, x2, y2) of the area to modify
"""
source = Image.open(image_path)
mask = Image.new("RGBA", source.size, (0, 0, 0, 255))
draw = ImageDraw.Draw(mask)
draw.rectangle(zone, fill=(0, 0, 0, 0))
mask.save("temp_mask.png")
response = client.images.edit(
model="gpt-image-2.5-sunburst",
image=open(image_path, "rb"),
mask=open("temp_mask.png", "rb"),
prompt=new_content
)
with open(output, "wb") as f:
f.write(base64.b64decode(response.data[0].b64_json))
print(f"Detail edited: {output}")
print("Cost: 1 edit instead of 1 full generation")
# Example: change just the sky of a photo
edit_detail(
"landscape.png",
(0, 0, 1024, 300),
"Blue sky with some fluffy white clouds",
"landscape_sky_edited.png"
)
Savoir où va l’argent
Les quatre stratégies précédentes supposent que tu sais ce que tu consommes, et cette visibilité ne vient pas automatiquement : le tableau de bord du fournisseur te donne un total, pas une ventilation par projet ou par qualité. Un journal local comble cette lacune pour un coût de développement négligeable. log_generation ajoute une ligne horodatée pour chaque appel, en tronquant le prompt à 100 caractères pour rester lisible, et usage_report agrège ensuite le tout par niveau de qualité. Cette ventilation déclenche des décisions : si ton journal révèle que 80 % de tes images sont générées en high alors que la majorité finit sur les réseaux sociaux, tu viens de trouver ton gisement d’économies.
import json
import os
from datetime import datetime
USAGE_FILE = "image_usage_log.json"
def log_generation(prompt: str, size: str, quality: str, n: int = 1):
"""Logs every generation to track costs."""
if os.path.exists(USAGE_FILE):
with open(USAGE_FILE, "r") as f:
log = json.load(f)
else:
log = []
entry = {
"timestamp": datetime.now().isoformat(),
"prompt": prompt[:100],
"size": size,
"quality": quality,
"n_images": n,
}
log.append(entry)
with open(USAGE_FILE, "w") as f:
json.dump(log, f, indent=2, ensure_ascii=False)
def usage_report():
"""Displays a consumption report."""
if not os.path.exists(USAGE_FILE):
print("No consumption data.")
return
with open(USAGE_FILE, "r") as f:
log = json.load(f)
total = len(log)
by_quality = {}
for entry in log:
q = entry["quality"]
by_quality[q] = by_quality.get(q, 0) + entry["n_images"]
print(f"Total generations: {total}")
print(f"Breakdown by quality:")
for q, count in sorted(by_quality.items()):
print(f" {q}: {count} images")
usage_report()
Par où commencer
Toutes ces stratégies n’offrent pas le même retour sur investissement, et le tableau suivant t’aide à les prioriser.
| Stratégie | Économies estimées | Effort |
|---|---|---|
| Low pour le prototypage | 50-70 % | Minimal |
| Mise en cache des prompts | 10-30 % (si répétitif) | Modéré |
| Résolution adaptée | 20-40 % | Minimal |
| Édition vs régénération | 30-50 % (par modification) | Modéré |
| Suivi des dépenses | Indirect (visibilité) | Modéré |
Deux lignes se détachent clairement : le prototypage en low et l’adaptation de la résolution à l’usage demandent un effort minimal pour la moitié des économies possibles. Commence par là, puis ajoute la mise en cache et l’édition ciblée lorsque ton volume le justifie. Le suivi des dépenses lui-même n’économise rien directement — mais c’est lui qui te dit lesquelles des quatre autres portent réellement leurs fruits dans ton contexte spécifique.
La meilleure façon de cesser d’y penser est d’encapsuler ces règles en un point de contrôle unique. Écris un wrapper autour de client.images.generate() qui intègre la mise en cache des prompts, l’adaptation automatique de la qualité et de la résolution selon l’usage déclaré, et la journalisation de chaque appel ; puis lance-le sur dix générations et lis le rapport de consommation. À partir de là, toute ton équipe économise de l’argent sans avoir à se souvenir de rien.