Optimizar costes
En esta página
Actualizado el 2 de noviembre de 2026 — Modelos de imagen.
gpt-image-1, el modelo para el que se escribió originalmente este curso, se discontinuó el 23 de octubre de 2026.gpt-image-1.5,gpt-image-1-miniychatgpt-image-latestse retirarán el 1 de diciembre de 2026. Los ejemplos ahora utilizangpt-image-2.5-sunburst, que ofrece la mayor precisión para la edición;gpt-image-2.5-flarees más rápido para la generación estándar. Ambos modelos también admiten los niveles de calidadxhighymax. Los modelos GPT Image devuelven siempre las imágenes en base64: el parámetroresponse_formatde los modelos DALL·E anteriores ya no se acepta y se ha eliminado del código. Fuente: Generación de imágenes (OpenAI).
Optimizar costes
En producción, la generación de imágenes deja de ser una curiosidad técnica para convertirse en una partida presupuestaria. Cualquier equipo que produzca unos pocos cientos de visuales al mes lo nota rápidamente. La primera reacción —restringir el uso— es también la menos inteligente. Esta lección cubre cinco estrategias que reducen el gasto sin comprometer la calidad de tus entregables, porque se centran en lo que descartas en lugar de en lo que conservas.
Entender la estructura de costes
Los costes de generación dependen de tres factores.
| Factor | Impacto en el coste |
|---|---|
Calidad (low, medium, high) | Multiplicador directo |
| Resolución (1024, 1536) | Mayor = más caro |
Número de imágenes (n) | Coste lineal (n × precio unitario) |
Estos tres factores se multiplican entre sí, lo que explica por qué una exploración indisciplinada cuesta un orden de magnitud más que la misma exploración realizada con disciplina. El siguiente script enumera las cinco combinaciones que encontrarás con mayor frecuencia en producción. Aunque las cantidades exactas aparecen en tu panel de control de OpenAI, el orden de las líneas ya muestra la escala de las compensaciones.
from openai import OpenAI
client = OpenAI()
# Comparar costes: mismo prompt, diferentes parámetros
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("Configuración | Uso (estimado)")
print("-" * 50)
for config in configs:
print(f"{config['label']:22s} | Consulta tu panel de OpenAI")
Prototipar en Low, entregar en High
Esta es, con diferencia, la estrategia más rentable y la más sencilla de adoptar. Durante la fase de exploración, no estás juzgando la finura de un degradado: estás juzgando la composición, el encuadre y el ambiente general, todo lo cual es perfectamente visible con quality: low. Cambiar a high solo tiene sentido para la imagen que realmente pretendes publicar. El flujo de trabajo siguiente formaliza esta secuencia produciendo cinco borradores económicos seguidos de un único renderizado final, con la ventaja añadida de cambiar al formato apaisado (1536×1024) para la versión definitiva. En cinco pruebas y una entrega, el ahorro citado al final del script ronda el 60 % en comparación con una exploración realizada íntegramente en high.
from openai import OpenAI
import base64
client = OpenAI()
def economical_workflow(prompt: str, output: str, n_drafts: int = 5):
"""
Flujo de trabajo en dos fases:
1. Borradores rápidos en baja calidad
2. Renderizado final en alta calidad
"""
# Fase 1: Exploración rápida
print("Fase 1: borradores rápidos (baja calidad)")
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" Borrador {i+1}: {path}")
# Fase 2: Renderizado final (tras la selección humana del mejor borrador)
print("\nFase 2: renderizado final (alta calidad)")
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" Renderizado final: {output}")
# Resumen: 5 en low + 1 en high en lugar de 5 en high
print(f"\nResumen: {n_drafts} borradores en low + 1 final en high")
print("Ahorro estimado: ~60 % comparado con exploración todo en high")
economical_workflow(
"Ilustración de un campus tecnológico verde con paneles solares, estilo arquitectónico",
"campus_final.png"
)
No pagues dos veces por la misma imagen
En una aplicación real, el mismo prompt vuelve a aparecer con mucha más frecuencia de lo que podrías esperar: un usuario que actualiza la página, un script de compilación que vuelve a ejecutar una generación o un icono reutilizado en tres páginas. Cada uno de estos casos supone un cobro innecesario. La caché siguiente los elimina calculando un hash SHA-256 de la tripleta (prompt, size, quality) —los tres elementos que determinan el resultado facturado— y truncando ese hash a dieciséis caracteres para crear un nombre de archivo manejable. Observa la comprobación os.path.exists: el índice podría conocer una entrada cuyo archivo haya sido eliminado del disco; en ese caso, el código regenera la imagen en lugar de devolver una ruta muerta.
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:
"""Carga el índice de la caché."""
if os.path.exists(CACHE_INDEX):
with open(CACHE_INDEX, "r") as f:
return json.load(f)
return {}
def save_cache(cache: dict):
"""Guarda el índice de la caché."""
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 una imagen o devuelve el resultado en caché."""
# Crear una clave única basada en los parámetros
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"Acierto de caché: {cached_path}")
return cached_path
else:
print("Caché caducada, regenerando...")
# No está en caché: generar
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"Generada y almacenada en caché: {path}")
return path
# Primera generación: llamada a la API
path1 = generate_with_cache("Logotipo minimalista para una startup tecnológica, azul y blanco")
# Segunda llamada idéntica: servida desde la caché
path2 = generate_with_cache("Logotipo minimalista para una startup tecnológica, azul y blanco")
Dimensiona con precisión
Generar una miniatura de alta resolución que se mostrará en un cuadrado de 80 píxeles es como pagar por una impresión de exposición solo para meterla en una cartera. El remedio es dejar de dejar esta elección al capricho del desarrollador y derivarla en su lugar del uso declarado. El diccionario generate_for_usage divide los casos en tres familias: formatos web pequeños —miniaturas y avatares—, que van bien con low; uso web estándar —cabeceras de blog, publicaciones en redes sociales—, que requieren medium; y medios donde la finura importa de verdad —banners hero, impresión A4, portafolios—, que justifican high. Las dos últimas llamadas ilustran la brecha: el mismo gato astronauta cuesta un múltiplo dependiendo de si acaba como miniatura o como banner de página de inicio.
from openai import OpenAI
import base64
client = OpenAI()
def generate_for_usage(prompt: str, usage: str, output: str):
"""Elige automáticamente la resolución y calidad óptimas."""
configs = {
# Uso web pequeño
"thumbnail": {"size": "1024x1024", "quality": "low"},
"avatar": {"size": "1024x1024", "quality": "low"},
# Uso web estándar
"blog_header": {"size": "1536x1024", "quality": "medium"},
"social_post": {"size": "1024x1024", "quality": "medium"},
# Uso de alta calidad
"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("Gato lindo con traje de astronauta", "thumbnail", "cat_thumb.png")
generate_for_usage("Gato lindo con traje de astronauta", "hero_banner", "cat_hero.png")
Editar en lugar de regenerar
El cliente aprueba la foto pero quiere un cielo diferente. El reflejo natural —volver a ejecutar la generación completa con un prompt ajustado— te hace pagar por una imagen entera y, lo que es peor, te hace perder el resto de la composición que todos habían aprobado. images.edit() gestiona esta situación al precio de una edición: la función edit_detail construye una máscara que libera solo el rectángulo relevante, aquí los 300 píxeles superiores de altura correspondientes al cielo, y el prompt describe solo el contenido de esa franja. El paisaje en sí no se mueve ni un píxel.
import base64
from openai import OpenAI
from PIL import Image, ImageDraw
client = OpenAI()
# En lugar de regenerar toda la imagen para cambiar un detalle,
# edita solo el área relevante.
def edit_detail(image_path: str, zone: tuple, new_content: str, output: str):
"""
Edita un detalle en una imagen existente.
zone: (x1, y1, x2, y2) del área a modificar
"""
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"Detalle editado: {output}")
print("Coste: 1 edición en lugar de 1 generación completa")
# Ejemplo: cambiar solo el cielo de una foto
edit_detail(
"landscape.png",
(0, 0, 1024, 300),
"Cielo azul con algunas nubes blancas esponjosas",
"landscape_sky_edited.png"
)
Saber a dónde va el dinero
Las cuatro estrategias anteriores asumen que sabes qué estás consumiendo, y esta visibilidad no llega automáticamente: el panel del proveedor te da un total, no un desglose por proyecto o calidad. Un registro local llena este hueco con un coste de desarrollo insignificante. log_generation añade una línea con marca de tiempo por cada llamada, truncando el prompt a 100 caracteres para mantener la legibilidad, y usage_report agrega luego todo por nivel de calidad. Este desglose desencadena decisiones: si tu registro revela que el 80 % de tus imágenes se generan en high mientras que la mayoría acaba en publicaciones de redes sociales, acabas de encontrar tu bolsa de ahorro.
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 cada generación para rastrear costes."""
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():
"""Muestra un informe de consumo."""
if not os.path.exists(USAGE_FILE):
print("No hay datos de 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"Generaciones totales: {total}")
print(f"Desglose por calidad:")
for q, count in sorted(by_quality.items()):
print(f" {q}: {count} imágenes")
usage_report()
Por dónde empezar
No todas estas estrategias ofrecen el mismo retorno del esfuerzo, y la siguiente tabla te ayuda a priorizarlas.
| Estrategia | Ahorro estimado | Esfuerzo |
|---|---|---|
| Low para prototipado | 50-70 % | Mínimo |
| Caché de prompts | 10-30 % (si es repetitivo) | Moderado |
| Resolución adaptada | 20-40 % | Mínimo |
| Edición frente a regeneración | 30-50 % (por modificación) | Moderado |
| Seguimiento de gastos | Indirecto (visibilidad) | Moderado |
Dos líneas destacan claramente: prototipar en low y adaptar la resolución al uso requieren un esfuerzo mínimo para la mitad del ahorro posible. Empieza por ahí, y añade luego la caché y la edición dirigida cuando tu volumen lo justifique. El seguimiento de gastos en sí no ahorra nada directamente, pero es lo que te dice cuál de las otras cuatro está dando realmente frutos en tu contexto específico.
La mejor manera de dejar de pensar en ello es encapsular estas reglas en un único punto de control. Escribe un envoltorio alrededor de client.images.generate() que integre la caché de prompts, la adaptación automática de calidad y resolución basada en el uso declarado y el registro de cada llamada; ejecútalo luego en diez generaciones y lee el informe de consumo. A partir de ahí, todo tu equipo ahorrará dinero sin tener que recordar nada.