Kosten optimaliseren
Op deze pagina
Bijgewerkt op 2 november 2026 — Afbeeldingsmodellen.
gpt-image-1, het model waarvoor deze cursus oorspronkelijk is geschreven, is stopgezet op 23 oktober 2026.gpt-image-1.5,gpt-image-1-minienchatgpt-image-latestworden op 1 december 2026 buiten gebruik gesteld. De voorbeelden gebruiken nugpt-image-2.5-sunburst, dat de hoogste precisie biedt voor bewerkingen;gpt-image-2.5-flareis sneller voor standaardgeneratie. Beide modellen ondersteunen ook de kwaliteitsniveausxhighenmax. GPT Image-modellen retourneren afbeeldingen altijd in base64: de parameterresponse_formatvan oudere DALL·E-modellen wordt niet langer geaccepteerd en is uit de code verwijderd. Bron: Image generation (OpenAI).
Kosten optimaliseren
In productie stopt afbeeldingsgeneratie een technische curiositeit te zijn en wordt het een begrotingspost. Elk team dat een paar honderd visuals per maand produceert, merkt dit snel op. De eerste reactie—gebruik beperken—is ook de minst slimme. Deze les behandelt vijf strategieën die de uitgaven verlagen zonder afbreuk te doen aan de kwaliteit van uw deliverables, omdat ze zich richten op wat u weggooidt in plaats van op wat u behoudt.
Kostenstructuur begrijpen
Generatiekosten hangen af van drie factoren.
| Factor | Impact op kosten |
|---|---|
Kwaliteit (low, medium, high) | Directe vermenigvuldiger |
| Resolutie (1024, 1536) | Groter = duurder |
Aantal afbeeldingen (n) | Lineaire kosten (n × eenheidsprijs) |
Deze drie factoren vermenigvuldigen elkaar, wat verklaart waarom ongedisciplineerde exploratie een orde van grootte meer kost dan dezelfde exploratie uitgevoerd met discipline. Het onderstaande script somt de vijf combinaties op die u het vaakst zult tegenkomen in productie. Hoewel exacte bedragen op uw OpenAI-dashboard verschijnen, toont de volgorde van de regels al de schaal van de afwegingen.
from openai import OpenAI
client = OpenAI()
# Vergelijk kosten: dezelfde prompt, verschillende 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("Configuratie | Gebruik (geschat)")
print("-" * 50)
for config in configs:
print(f"{config['label']:22s} | Controleer uw OpenAI-dashboard")
Prototypeer in Low, lever in High
Dit is veruit de kosteneffectiefste strategie en de eenvoudigste om over te nemen. Tijdens de exploratiefase beoordeelt u niet de finesse van een verloop: u beoordeelt compositie, kadrering en algemene sfeer, en dat is allemaal perfect zichtbaar in quality: low. Overschakelen naar high is alleen zinvol voor de afbeelding die u daadwerkelijk wilt publiceren. De onderstaande workflow formaliseert deze volgorde door vijf zuinige concepten te produceren, gevolgd door één enkele definitieve render, met als extra voordeel dat voor de definitieve versie wordt overgeschakeld naar landscape-formaat (1536×1024). Over vijf proeven en één oplevering liggen de besparingen die aan het einde van het script worden genoemd rond de 60% in vergelijking met een exploratie die volledig in high wordt uitgevoerd.
from openai import OpenAI
import base64
client = OpenAI()
def economical_workflow(prompt: str, output: str, n_drafts: int = 5):
"""
Tweefasen-workflow:
1. Snelle concepten in lage kwaliteit
2. Definitieve render in hoge kwaliteit
"""
# Fase 1: Snelle exploratie
print("Fase 1: snelle concepten (lage kwaliteit)")
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" Concept {i+1}: {path}")
# Fase 2: Definitieve render (na menselijke selectie van het beste concept)
print("\nFase 2: definitieve render (hoge kwaliteit)")
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" Definitieve render: {output}")
# Samenvatting: 5 low + 1 high in plaats van 5 high
print(f"\nSamenvatting: {n_drafts} low-concepten + 1 finale high")
print("Geschatte besparing: ~60% ten opzichte van all-high exploratie")
economical_workflow(
"Illustratie van een groene tech-campus met zonnepanelen, architectonische stijl",
"campus_final.png"
)
Betaal nooit twee keer voor dezelfde afbeelding
In een echte applicatie komt dezelfde prompt veel vaker terug dan u zou verwachten: een gebruiker die de pagina ververst, een build-script dat een generatie opnieuw uitvoert, of een icoon dat op drie pagina’s wordt hergebruikt. Elk van deze gevallen is een onnodige kostenpost. De onderstaande cache elimineert ze door een SHA-256-hash te berekenen van het triplet (prompt, size, quality)—de drie elementen die het gefactureerde resultaat bepalen—en die hash af te kappen tot zestien tekens om een beheersbare bestandsnaam te creëren. Let op de os.path.exists-controle: de index kan een entry kennen waarvan het bestand van de schijf is verwijderd; in dat geval genereert de code de afbeelding opnieuw in plaats van een dood pad terug te geven.
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:
"""Laadt de 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):
"""Slaat de cache-index op."""
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:
"""Genereert een afbeelding of retourneert het gecachete resultaat."""
# Maak een unieke sleutel op basis van 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 verlopen, opnieuw genereren...")
# Niet in cache: genereren
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"Gegenereerd en gecachet: {path}")
return path
# Eerste generatie: API-call
path1 = generate_with_cache("Minimalistisch logo voor een tech-startup, blauw en wit")
# Tweede identieke call: bediend vanuit cache
path2 = generate_with_cache("Minimalistisch logo voor een tech-startup, blauw en wit")
Maatvoer nauwkeurig
Het genereren van een hoge-resolutie thumbnail die wordt weergegeven in een vierkant van 80 pixel is alsof u betaalt voor een tentoonstellingsprint om deze vervolgens in een portemonnee te stoppen. De remedie is om deze keuze niet langer over te laten aan de gril van de ontwikkelaar, maar deze af te leiden van het gedeclareerde gebruik. De generate_for_usage-dictionary splitst gevallen in drie families: kleine webformaten—thumbnails en avatars—die prima uit de voeten kunnen met low; standaard webgebruik—blogheaders, social posts—die vragen om medium; en media waar finesse echt toe doet—hero banners, A4-print, portfolio’s—die high rechtvaardigen. De laatste twee calls illustreren het verschil: dezelfde astronautenkat kost een veelvoud, afhankelijk van of deze eindigt als thumbnail of als homepage-banner.
from openai import OpenAI
import base64
client = OpenAI()
def generate_for_usage(prompt: str, usage: str, output: str):
"""Kiest automatisch de optimale resolutie en kwaliteit."""
configs = {
# Klein webgebruik
"thumbnail": {"size": "1024x1024", "quality": "low"},
"avatar": {"size": "1024x1024", "quality": "low"},
# Standaard webgebruik
"blog_header": {"size": "1536x1024", "quality": "medium"},
"social_post": {"size": "1024x1024", "quality": "medium"},
# Hoogwaardig gebruik
"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"Gebruik {usage} ({config['quality']}/{config['size']}) → {output}")
generate_for_usage("Schattige kat in een astronautenpak", "thumbnail", "cat_thumb.png")
generate_for_usage("Schattige kat in een astronautenpak", "hero_banner", "cat_hero.png")
Bewerk in plaats van regenereren
De klant keurt de foto goed, maar wil een andere lucht. De natuurlijke reflex—de volledige generatie opnieuw uitvoeren met een aangepaste prompt—laat u betalen voor een hele afbeelding en, erger nog, laat u de rest van de compositie verliezen die iedereen had goedgekeurd. images.edit() handelt deze situatie af voor de prijs van één bewerking: de functie edit_detail bouwt een masker dat alleen de relevante rechthoek vrijgeeft, hier de bovenste 300 pixels hoogte die overeenkomen met de lucht, en de prompt beschrijft alleen de inhoud van die strook. Het landschap zelf beweegt geen pixel.
import base64
from openai import OpenAI
from PIL import Image, ImageDraw
client = OpenAI()
# In plaats van de hele afbeelding opnieuw te genereren om een detail te wijzigen,
# bewerk alleen het relevante gebied.
def edit_detail(image_path: str, zone: tuple, new_content: str, output: str):
"""
Bewerkt een detail in een bestaande afbeelding.
zone: (x1, y1, x2, y2) van het te wijzigen gebied
"""
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 bewerkt: {output}")
print("Kosten: 1 bewerking in plaats van 1 volledige generatie")
# Voorbeeld: verander alleen de lucht van een foto
edit_detail(
"landscape.png",
(0, 0, 1024, 300),
"Blauwe lucht met enkele pluizige witte wolken",
"landscape_sky_edited.png"
)
Weet waar het geld naartoe gaat
De vier vorige strategieën gaan ervan uit dat u weet wat u verbruikt, en dit inzicht komt niet automatisch: het dashboard van de provider geeft u een totaal, geen uitsplitsing per project of kwaliteit. Een lokaal logboek vult deze kloof voor verwaarloosbare ontwikkelkosten. log_generation voegt voor elke call een regel met tijdstempel toe, waarbij de prompt wordt ingekort tot 100 tekens om leesbaar te blijven, en usage_report aggregeert vervolgens alles per kwaliteitsniveau. Deze uitsplitsing leidt tot beslissingen: als uw logboek onthult dat 80% van uw afbeeldingen in high wordt gegenereerd terwijl de meerderheid op social posts belandt, hebt u zojuist uw besparingspotentieel gevonden.
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):
"""Logt elke generatie om kosten te volgen."""
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():
"""Toont een verbruiksrapport."""
if not os.path.exists(USAGE_FILE):
print("Geen verbruiksgegevens.")
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"Totaal generaties: {total}")
print(f"Uitsplitsing per kwaliteit:")
for q, count in sorted(by_quality.items()):
print(f" {q}: {count} afbeeldingen")
usage_report()
Waar te beginnen
Niet al deze strategieën bieden hetzelfde rendement voor de moeite, en de volgende tabel helpt u ze te prioriteren.
| Strategie | Geschatte besparing | Inspanning |
|---|---|---|
| Low voor prototyping | 50-70% | Minimaal |
| Prompt-caching | 10-30% (bij herhaling) | Gemiddeld |
| Aangepaste resolutie | 20-40% | Minimaal |
| Bewerken vs. regenereren | 30-50% (per wijziging) | Gemiddeld |
| Kostentracking | Indirect (inzicht) | Gemiddeld |
Twee regels springen er duidelijk uit: prototypen in low en het aanpassen van de resolutie aan het gebruik vereisen minimale inspanning voor de helft van de mogelijke besparingen. Begin daarmee, en voeg caching en gerichte bewerking toe wanneer uw volume dit rechtvaardigt. Kostentracking zelf bespaart niets direct—maar het is wel wat u vertelt welke van de andere vier in uw specifieke context daadwerkelijk vruchten afwerpen.
De beste manier om er niet meer over na te hoeven denken, is door deze regels onder te brengen in één enkel controlepunt. Schrijf een wrapper om client.images.generate() die prompt-caching integreert, automatische aanpassing van kwaliteit en resolutie op basis van gedeclareerd gebruik, en logging van elke call; voer deze vervolgens uit op tien generaties en lees het verbruiksrapport. Vanaf dat moment bespaart uw hele team geld zonder dat iemand zich iets hoeft te herinneren.