Ir al contenido principal
Español— Elegir un idioma
Menú

Optimizar costes

Lección 11 de 12 Actualizado el 2 de noviembre de 2026 Desarrollador
En esta página
  1. Optimizar costes
  2. Entender la estructura de costes
  3. Prototipar en Low, entregar en High
  4. No pagues dos veces por la misma imagen
  5. Dimensiona con precisión
  6. Editar en lugar de regenerar
  7. Saber a dónde va el dinero
  8. Por dónde empezar

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-mini y chatgpt-image-latest se retirarán el 1 de diciembre de 2026. Los ejemplos ahora utilizan gpt-image-2.5-sunburst, que ofrece la mayor precisión para la edición; gpt-image-2.5-flare es más rápido para la generación estándar. Ambos modelos también admiten los niveles de calidad xhigh y max. Los modelos GPT Image devuelven siempre las imágenes en base64: el parámetro response_format de 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.

FactorImpacto 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.

EstrategiaAhorro estimadoEsfuerzo
Low para prototipado50-70 %Mínimo
Caché de prompts10-30 % (si es repetitivo)Moderado
Resolución adaptada20-40 %Mínimo
Edición frente a regeneración30-50 % (por modificación)Moderado
Seguimiento de gastosIndirecto (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.