Optimera kostnaderna
På denna sida
Uppdaterad 2 november 2026 — Bildmodeller.
gpt-image-1, modellen som denna kurs ursprungligen skrevs för, lades ner den 23 oktober 2026.gpt-image-1.5,gpt-image-1-miniochchatgpt-image-latestkommer att tas ur bruk den 1 december 2026. Exemplen använder nugpt-image-2.5-sunburst, som erbjuder högsta precision för redigering;gpt-image-2.5-flareär snabbare för standardgenerering. Båda modellerna stöder även kvalitetsnivåernaxhighochmax. GPT Image-modeller returnerar alltid bilder i base64: parameternresponse_formatfrån äldre DALL·E-modeller accepteras inte längre och har tagits bort från koden. Källa: Image generation (OpenAI).
Optimera kostnaderna
I produktion upphör bildgenerering att vara en teknisk kuriositet och blir istället en budgetpost. Varje team som producerar några hundra visuella element i månaden märker detta snabbt. Den första reaktionen – att begränsa användningen – är också den minst smarta. Denna lektion täcker fem strategier som minskar kostnaderna utan att kompromissa med kvaliteten på dina leverabler, eftersom de riktar in sig på det du kasserar snarare än det du behåller.
Förstå kostnadsstrukturen
Genereringskostnader beror på tre faktorer.
| Faktor | Påverkan på kostnad |
|---|---|
Kvalitet (low, medium, high) | Direkt multiplikator |
| Upplösning (1024, 1536) | Större = dyrare |
Antal bilder (n) | Linjär kostnad (n × enhetspris) |
Dessa tre faktorer multiplicerar varandra, vilket förklarar varför odisciplinerad utforskning kostar en storleksordning mer än samma utforskning genomförd med disciplin. Skriptet nedan listar de fem kombinationer du oftast stöter på i produktion. Även om exakta belopp visas i din OpenAI-dashboard, visar redan ordningen på raderna omfattningen av avvägningarna.
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")
Prototypa i låg kvalitet, leverera i hög
Detta är långt ifrån den mest kostnadseffektiva strategin och den enklaste att införa. Under utforskningsfasen bedömer du inte finessen i en gradient: du bedömer komposition, bildutsnitt och övergripande stämning, allt som är fullt synligt i quality: low. Att byta till high är bara meningsfullt för den bild du faktiskt tänker publicera. Arbetsflödet nedan formaliserar denna sekvens genom att producera fem ekonomiska utkast följt av en enda slutlig rendering, med den extra fördelen att byta till liggande format (1536×1024) för den definitiva versionen. Över fem försök och en leverans ligger besparingarna som nämns i slutet av skriptet runt 60 % jämfört med en utforskning som genomförs helt i 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"
)
Betala aldrig två gånger för samma bild
I en riktig applikation återkommer samma prompt mycket oftare än du kanske tror: en användare som laddar om sidan, ett byggsript som kör om en generering, eller en ikon som återanvänds över tre sidor. Vart och ett av dessa fall är en onödig kostnad. Cachen nedan eliminerar dem genom att beräkna en SHA-256-hash av trippeln (prompt, storlek, kvalitet) – de tre element som bestämmer det fakturerade resultatet – och trunkerar den hashen till sexton tecken för att skapa ett hanterbart filnamn. Notera kontrollen os.path.exists: indexet kan känna till en post vars fil har raderats från disken, i vilket fall koden genererar om bilden istället för att returnera en död sökväg.
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")
Använd exakt rätt storlek
Att generera en högupplöst miniatyrbild som ska visas i en ruta på 80 pixlar är som att betala för ett utställningsprint bara för att stoppa det i en plånbok. Botemedlet är att sluta överlåta detta val till utvecklarens nyck och istället härleda det från den deklarerade användningen. Ordboken generate_for_usage delar in fallen i tre familjer: små webbformat – miniatyrbilder och avatarer – som klarar sig med low; standardanvändning på webben – bloggrubriker, sociala inlägg – som kräver medium; och media där finess verkligen spelar roll – hero-banners, A4-print, portfolior – som motiverar high. De två sista anropen illustrerar gapet: samma astronautkatt kostar en multipel beroende på om den hamnar som en miniatyrbild eller en startsidsbanner.
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")
Redigera istället för att generera om
Kunden godkänner fotot men vill ha en annan himmel. Den naturliga reflexen – att köra om hela genereringen med en justerad prompt – får dig att betala för en hel bild och, värre än så, får dig att förlora resten av kompositionen som alla hade godkänt. images.edit() hanterar denna situation till priset av en redigering: funktionen edit_detail bygger en mask som frigör endast den relevanta rektangeln, här de övre 300 pixlarna på höjden som motsvarar himlen, och prompten beskriver endast innehållet i den remsan. Själva landskapet flyttar sig inte en 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"
)
Vet var pengarna tar vägen
De fyra tidigare strategierna förutsätter att du vet vad du konsumerar, och denna synlighet kommer inte automatiskt: leverantörens dashboard ger dig en summa, inte en fördelning per projekt eller kvalitet. En lokal logg fyller detta gap till en försumbar utvecklingskostnad. log_generation lägger till en tidsstämplad rad för varje anrop och trunkerar prompten till 100 tecken för att förbli läsbar, och usage_report aggregerar sedan allt efter kvalitetsnivå. Denna uppdelning utlöser beslut: om din logg avslöjar att 80 % av dina bilder genereras i high medan majoriteten hamnar på sociala medier, har du precis hittat din besparingspott.
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()
Var ska du börja?
Inte alla dessa strategier ger samma avkastning på insatsen, och följande tabell hjälper dig att prioritera dem.
| Strategi | Beräknad besparing | Insats |
|---|---|---|
| Låg kvalitet för prototyper | 50–70 % | Minimal |
| Caching av prompts | 10–30 % (vid repetition) | Måttlig |
| Anpassad upplösning | 20–40 % | Minimal |
| Redigering kontra omgenerering | 30–50 % (per ändring) | Måttlig |
| Spårning av utgifter | Indirekt (synlighet) | Måttlig |
Två rader sticker ut tydligt: prototypning i low och anpassning av upplösning till användningen kräver minimal insats för hälften av de möjliga besparingarna. Börja med dessa, lägg sedan till cachelagring och målinriktad redigering när din volym motiverar det. Själva spårningen av utgifter sparar ingenting direkt – men det är den som talar om för dig vilka av de andra fyra som faktiskt bär frukt i just ditt sammanhang.
Det bästa sättet att sluta tänka på det är att kapsla in dessa regler i en enda kontrollpunkt. Skriv en wrapper runt client.images.generate() som integrerar cachelagring av prompts, automatisk anpassning av kvalitet och upplösning baserat på deklarerad användning, samt loggning av varje anrop; kör den sedan på tio genereringar och läs konsumtionsrapporten. Därifrån sparar hela ditt team pengar utan att behöva komma ihåg något.