Ottimizza i costi
In questa pagina
Aggiornato il 2 novembre 2026 — Modelli immagine.
gpt-image-1, il modello per cui questo corso era stato originariamente scritto, è stato dismesso il 23 ottobre 2026.gpt-image-1.5,gpt-image-1-miniechatgpt-image-latestverranno ritirati il 1° dicembre 2026. Gli esempi ora utilizzanogpt-image-2.5-sunburst, che offre la massima precisione per il fotoritocco;gpt-image-2.5-flareè più veloce per la generazione standard. Entrambi i modelli supportano inoltre i livelli di qualitàxhighemax. I modelli GPT Image restituiscono sempre le immagini in base64: il parametroresponse_formatdei vecchi modelli DALL·E non è più accettato ed è stato rimosso dal codice. Fonte: Generazione immagini (OpenAI).
Ottimizza i costi
In produzione, la generazione di immagini smette di essere una curiosità tecnica per diventare una voce di bilancio. Qualsiasi team che produca qualche centinaio di visual al mese se ne accorge rapidamente. La prima reazione—limitare l’utilizzo—è anche la meno intelligente. Questa lezione copre cinque strategie che riducono la spesa senza compromettere la qualità dei tuoi deliverable, perché prendono di mira ciò che scarti piuttosto che ciò che conservi.
Comprendi la struttura dei costi
I costi di generazione dipendono da tre fattori.
| Fattore | Impatto sul costo |
|---|---|
Qualità (low, medium, high) | Moltiplicatore diretto |
| Risoluzione (1024, 1536) | Più grande = più costoso |
Numero di immagini (n) | Costo lineare (n × prezzo unitario) |
Questi tre fattori si moltiplicano tra loro, il che spiega perché un’esplorazione indisciplinata costa un ordine di grandezza in più rispetto alla stessa esplorazione condotta con disciplina. Lo script seguente elenca le cinque combinazioni che incontrerai più spesso in produzione. Sebbene gli importi esatti appaiano sulla tua dashboard OpenAI, l’ordine delle righe mostra già la scala dei compromessi.
from openai import OpenAI
client = OpenAI()
# Confronta i costi: stesso prompt, parametri diversi
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("Configurazione | Utilizzo (stimato)")
print("-" * 50)
for config in configs:
print(f"{config['label']:22s} | Controlla la tua dashboard OpenAI")
Prototipa in Low, consegna in High
Questa è di gran lunga la strategia più conveniente e la più semplice da adottare. Durante la fase di esplorazione, non stai giudicando la finezza di una sfumatura: stai giudicando la composizione, l’inquadratura e l’atmosfera generale, tutti elementi perfettamente visibili con quality: low. Passare a high ha senso solo per l’immagine che intendi effettivamente pubblicare. Il flusso di lavoro sottostante formalizza questa sequenza producendo cinque bozze economiche seguite da un singolo render finale, con il vantaggio aggiuntivo di passare al formato landscape (1536×1024) per la versione definitiva. Su cinque prove e una consegna, il risparmio citato alla fine dello script si aggira intorno al 60% rispetto a un’esplorazione condotta interamente in high.
from openai import OpenAI
import base64
client = OpenAI()
def economical_workflow(prompt: str, output: str, n_drafts: int = 5):
"""
Flusso di lavoro in due fasi:
1. Bozze veloci in bassa qualità
2. Render finale in alta qualità
"""
# Fase 1: Esplorazione veloce
print("Fase 1: bozze veloci (bassa qualità)")
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" Bozza {i+1}: {path}")
# Fase 2: Render finale (dopo la selezione umana della migliore bozza)
print("\nFase 2: render finale (alta qualità)")
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" Render finale: {output}")
# Riepilogo: 5 low + 1 high invece di 5 high
print(f"\nRiepilogo: {n_drafts} bozze low + 1 finale high")
print("Risparmio stimato: ~60% rispetto all'esplorazione tutta in high")
economical_workflow(
"Illustrazione di un campus tech verde con pannelli solari, stile architettonico",
"campus_final.png"
)
Non pagare mai due volte la stessa immagine
In un’applicazione reale, lo stesso prompt ricorre molto più spesso di quanto potresti pensare: un utente che aggiorna la pagina, uno script di build che riesegue una generazione o un’icona riutilizzata su tre pagine. Ciascuno di questi casi rappresenta un addebito inutile. La cache sottostante li elimina calcolando un hash SHA-256 della terna (prompt, size, quality)—i tre elementi che determinano il risultato fatturato—e troncando quell’hash a sedici caratteri per creare un nome file gestibile. Nota il controllo os.path.exists: l’indice potrebbe conoscere una voce il cui file è stato cancellato dal disco; in tal caso, il codice rigenera l’immagine invece di restituire un percorso morto.
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:
"""Carica l'indice della cache."""
if os.path.exists(CACHE_INDEX):
with open(CACHE_INDEX, "r") as f:
return json.load(f)
return {}
def save_cache(cache: dict):
"""Salva l'indice della cache."""
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:
"""Genera un'immagine o restituisce il risultato in cache."""
# Crea una chiave univoca basata sui parametri
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 scaduta, rigenerazione in corso...")
# Non in cache: genera
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"Generata e messa in cache: {path}")
return path
# Prima generazione: chiamata API
path1 = generate_with_cache("Logo minimalista per una startup tech, blu e bianco")
# Seconda chiamata identica: servita dalla cache
path2 = generate_with_cache("Logo minimalista per una startup tech, blu e bianco")
Dimensiona con precisione
Generare una miniatura ad alta risoluzione che verrà visualizzata in un quadrato di 80 pixel è come pagare per una stampa da esposizione solo per infilarla in un portafoglio. Il rimedio è smettere di lasciare questa scelta al capriccio dello sviluppatore e derivarla invece dall’uso dichiarato. Il dizionario generate_for_usage divide i casi in tre famiglie: formati web piccoli—miniature e avatar—che vanno bene con low; uso web standard—intestazioni di blog, post social—che richiedono medium; e media dove la finezza conta davvero—banner hero, stampa A4, portfolio—che giustificano high. Le ultime due chiamate illustrano il divario: lo stesso gatto astronauta costa un multiplo a seconda che finisca come miniatura o come banner homepage.
from openai import OpenAI
import base64
client = OpenAI()
def generate_for_usage(prompt: str, usage: str, output: str):
"""Sceglie automaticamente risoluzione e qualità ottimali."""
configs = {
# Uso web piccolo
"thumbnail": {"size": "1024x1024", "quality": "low"},
"avatar": {"size": "1024x1024", "quality": "low"},
# Uso web standard
"blog_header": {"size": "1536x1024", "quality": "medium"},
"social_post": {"size": "1024x1024", "quality": "medium"},
# Uso alta qualità
"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"Uso {usage} ({config['quality']}/{config['size']}) → {output}")
generate_for_usage("Gatto carino in tuta da astronauta", "thumbnail", "cat_thumb.png")
generate_for_usage("Gatto carino in tuta da astronauta", "hero_banner", "cat_hero.png")
Modifica invece di rigenerare
Il cliente approva la foto ma vuole un cielo diverso. Il riflesso naturale—rieseguire l’intera generazione con un prompt aggiustato—ti fa pagare un’immagine intera e, peggio, ti fa perdere il resto della composizione che tutti avevano approvato. images.edit() gestisce questa situazione al prezzo di una modifica: la funzione edit_detail costruisce una maschera che libera solo il rettangolo rilevante, qui i 300 pixel superiori di altezza corrispondenti al cielo, e il prompt descrive solo il contenuto di quella striscia. Il paesaggio stesso non si sposta di un pixel.
import base64
from openai import OpenAI
from PIL import Image, ImageDraw
client = OpenAI()
# Invece di rigenerare l'intera immagine per cambiare un dettaglio,
# modifica solo l'area rilevante.
def edit_detail(image_path: str, zone: tuple, new_content: str, output: str):
"""
Modifica un dettaglio in un'immagine esistente.
zone: (x1, y1, x2, y2) dell'area da modificare
"""
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"Dettaglio modificato: {output}")
print("Costo: 1 modifica invece di 1 generazione completa")
# Esempio: cambia solo il cielo di una foto
edit_detail(
"landscape.png",
(0, 0, 1024, 300),
"Cielo blu con alcune nuvole bianche soffici",
"landscape_sky_edited.png"
)
Sapere dove vanno i soldi
Le quattro strategie precedenti presuppongono che tu sappia cosa stai consumando, e questa visibilità non arriva automaticamente: la dashboard del provider ti dà un totale, non una ripartizione per progetto o qualità. Un log locale colma questa lacuna con un costo di sviluppo trascurabile. log_generation aggiunge una riga con timestamp per ogni chiamata, troncando il prompt a 100 caratteri per rimanere leggibile, e usage_report aggrega poi tutto per livello di qualità. Questa ripartizione innesca decisioni: se il tuo log rivela che l’80% delle tue immagini è generato in high mentre la maggior parte finisce sui post social, hai appena trovato il tuo bacino di risparmio.
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):
"""Registra ogni generazione per tracciare i costi."""
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():
"""Visualizza un report dei consumi."""
if not os.path.exists(USAGE_FILE):
print("Nessun dato di consumo.")
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"Generazioni totali: {total}")
print(f"Ripartizione per qualità:")
for q, count in sorted(by_quality.items()):
print(f" {q}: {count} immagini")
usage_report()
Da dove iniziare
Non tutte queste strategie offrono lo stesso ritorno sull’impegno, e la tabella seguente ti aiuta a stabilire le priorità.
| Strategia | Risparmio stimato | Impegno |
|---|---|---|
| Low per il prototyping | 50-70% | Minimo |
| Caching del prompt | 10-30% (se ripetitivo) | Moderato |
| Risoluzione adattata | 20-40% | Minimo |
| Modifica vs rigenerazione | 30-50% (per modifica) | Moderato |
| Tracciamento spese | Indiretto (visibilità) | Moderato |
Due righe spiccano chiaramente: prototipare in low e adattare la risoluzione all’uso richiedono uno sforzo minimo per metà del risparmio possibile. Inizia da quelle, poi aggiungi caching e modifica mirata quando il tuo volume lo giustifica. Il tracciamento delle spese di per sé non fa risparmiare nulla direttamente—ma è ciò che ti dice quale delle altre quattro sta davvero dando frutti nel tuo contesto specifico.
Il modo migliore per smettere di pensarci è incapsulare queste regole in un unico punto di controllo. Scrivi un wrapper attorno a client.images.generate() che integri il caching del prompt, l’adattamento automatico di qualità e risoluzione basato sull’uso dichiarato e la registrazione di ogni chiamata; poi eseguilo su dieci generazioni e leggi il report dei consumi. Da lì, tutto il tuo team risparmia denaro senza dover ricordare nulla.