Otimizar Custos
Nesta página
Atualizado a 2 de novembro de 2026 — Modelos de imagem. O
gpt-image-1, modelo para o qual este curso foi originalmente escrito, foi descontinuado a 23 de outubro de 2026. Os modelosgpt-image-1.5,gpt-image-1-miniechatgpt-image-latestserão retirados a 1 de dezembro de 2026. Os exemplos utilizam agora ogpt-image-2.5-sunburst, que oferece a maior precisão para edição; ogpt-image-2.5-flareé mais rápido para geração padrão. Ambos os modelos suportam também os níveis de qualidadexhighemax. Os modelos GPT Image devolvem sempre imagens em base64: o parâmetroresponse_formatdos modelos DALL·E antigos já não é aceite e foi removido do código. Fonte: Image generation (OpenAI).
Otimizar Custos
Em produção, a geração de imagens deixa de ser uma curiosidade técnica para se tornar uma rubrica orçamental. Qualquer equipa que produza algumas centenas de visuais por mês nota isso rapidamente. A primeira reação — restringir a utilização — é também a menos inteligente. Esta lição abrange cinco estratégias que reduzem as despesas sem comprometer a qualidade das suas entregas, pois visam aquilo que descarta e não aquilo que mantém.
Compreender a Estrutura de Custos
Os custos de geração dependem de três fatores.
| Fator | Impacto no Custo |
|---|---|
Qualidade (low, medium, high) | Multiplicador direto |
| Resolução (1024, 1536) | Maior = mais caro |
Número de imagens (n) | Custo linear (n × preço unitário) |
Estes três fatores multiplicam-se entre si, o que explica por que razão uma exploração indisciplinada custa uma ordem de grandeza superior à mesma exploração conduzida com disciplina. O script abaixo lista as cinco combinações que encontrará com mais frequência em produção. Embora os valores exatos apareçam no seu painel da OpenAI, a ordem das linhas já mostra a escala das compensações.
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")
Prototipar em Baixo, Entregar em Alto
Esta é, de longe, a estratégia mais económica e a mais simples de adotar. Durante a fase de exploração, não está a julgar a finura de um gradiente: está a julgar a composição, o enquadramento e o ambiente geral, tudo perfeitamente visível em quality: low. Mudar para high só faz sentido para a imagem que realmente tenciona publicar. O fluxo de trabalho abaixo formaliza esta sequência, produzindo cinco rascunhos económicos seguidos de uma única renderização final, com a vantagem adicional de mudar para o formato paisagem (1536×1024) para a versão definitiva. Em cinco tentativas e uma entrega, as poupanças citadas no final do script rondam os 60% em comparação com uma exploração conduzida inteiramente em 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"
)
Nunca Pague Duas Vezes pela Mesma Imagem
Numa aplicação real, o mesmo prompt surge muito mais frequentemente do que imagina: um utilizador a atualizar a página, um script de compilação a voltar a executar uma geração ou um ícone reutilizado em três páginas. Cada um destes casos representa uma cobrança desnecessária. A cache abaixo elimina-os calculando um hash SHA-256 do triplo (prompt, tamanho, qualidade) — os três elementos que determinam o resultado faturado — e truncando esse hash para dezasseis caracteres para criar um nome de ficheiro gerível. Note a verificação os.path.exists: o índice pode conhecer uma entrada cujo ficheiro foi apagado do disco; nesse caso, o código regenera a imagem em vez de devolver um caminho inválido.
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")
Dimensionar com Precisão
Gerar uma miniatura de alta resolução que será exibida num quadrado de 80 píxeis é como pagar por uma impressão de exposição apenas para a colocar numa carteira. A solução é deixar de deixar esta escolha ao arbítrio do programador e, em vez disso, derivá-la da utilização declarada. O dicionário generate_for_usage divide os casos em três famílias: formatos web pequenos — miniaturas e avatares — que funcionam bem com low; utilização web padrão — cabeçalhos de blogues, publicações sociais — que exigem medium; e suportes onde a finura realmente importa — banners principais, impressão A4, portefólios — que justificam high. As duas chamadas finais ilustram a diferença: o mesmo gato astronauta custa um múltiplo consoante acabe como miniatura ou como banner da página inicial.
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")
Editar em Vez de Regenerar
O cliente aprova a fotografia mas quer um céu diferente. O reflexo natural — voltar a executar a geração completa com um prompt ajustado — faz-lhe pagar por uma imagem inteira e, pior ainda, faz-lhe perder o resto da composição que todos tinham aprovado. A função images.edit() resolve esta situação pelo preço de uma edição: a função edit_detail constrói uma máscara que liberta apenas o retângulo relevante, aqui os 300 píxeis de altura superiores correspondentes ao céu, e o prompt descreve apenas o conteúdo dessa faixa. A paisagem em si não se move um único píxel.
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"
)
Saber Para Onde Vai o Dinheiro
As quatro estratégias anteriores pressupõem que sabe o que está a consumir, e esta visibilidade não surge automaticamente: o painel do fornecedor dá-lhe um total, não uma desagregação por projeto ou qualidade. Um registo local colmata esta lacuna com um custo de desenvolvimento negligenciável. A função log_generation adiciona uma linha carimbada com data e hora para cada chamada, truncando o prompt para 100 caracteres para manter a legibilidade, e a usage_report agrega depois tudo por nível de qualidade. Esta desagregação desencadeia decisões: se o seu registo revelar que 80% das suas imagens são geradas em high enquanto a maioria acaba em publicações sociais, acabou de encontrar a sua reserva de poupança.
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()
Por Onde Começar
Nem todas estas estratégias oferecem o mesmo retorno pelo esforço despendido, e a tabela seguinte ajuda-o a defini-las por prioridade.
| Estratégia | Poupança Estimada | Esforço |
|---|---|---|
| Baixo para prototipagem | 50-70% | Mínimo |
| Cache de prompts | 10-30% (se repetitivo) | Moderado |
| Resolução adaptada | 20-40% | Mínimo |
| Edição vs. regeneração | 30-50% (por modificação) | Moderado |
| Rastreio de despesas | Indireto (visibilidade) | Moderado |
Duas linhas destacam-se claramente: prototipar em low e adaptar a resolução à utilização exigem um esforço mínimo para metade das poupanças possíveis. Comece por essas e adicione depois a cache e a edição direcionada quando o seu volume o justificar. O rastreio de despesas em si não poupa nada diretamente — mas é ele que lhe diz quais das outras quatro estão realmente a dar frutos no seu contexto específico.
A melhor forma de deixar de pensar nisto é encapsular estas regras num único ponto de controlo. Escreva um wrapper em torno de client.images.generate() que integre a cache de prompts, a adaptação automática da qualidade e da resolução com base na utilização declarada e o registo de cada chamada; execute-o depois em dez gerações e leia o relatório de consumo. A partir daí, toda a sua equipa poupa dinheiro sem ter de se lembrar de nada.