GPT Image 2.5: qué cambia, cuánto cuesta y cómo usar la API

GPT Image 2.5 llega a la API en dos variantes: gpt-image-2.5-flare y gpt-image-2.5-sunburst. Ambas generan imágenes a partir de texto y editan imágenes existentes. OpenAI propone Flare para el uso habitual y Sunburst cuando importa especialmente la precisión de la edición. Comparten tarifas por token, pero eso no convierte cada imagen en un producto de precio fijo.

Para una primera integración, empezaría con Flare mediante la API de imágenes y guardaría el PNG devuelto. Después probaría Sunburst con los cambios que más cuestan a tu producto: conservar un objeto, modificar una zona o seguir varias instrucciones de edición. Esa comparación, con tus imágenes y tus criterios de aceptación, resulta más útil que elegir por el nombre de la variante.

Esta guía recoge la documentación disponible el 9 de septiembre de 2026, tras el lanzamiento del día 8. Los ejemplos se basan en esa documentación; no hemos realizado solicitudes API de pago ni medido el rendimiento de los modelos.

Flare, Sunburst y GPT Image 2: qué estás eligiendo

La novedad principal es poder elegir una variante según el trabajo. No necesitas Sunburst para acceder a la edición: Flare también edita. Tampoco Sunburst está limitado a retocar fotografías: puede generar imágenes desde cero.

Según el anuncio de OpenAI, Flare reduce un 50 % la latencia respecto a GPT Image 2. Sunburst necesita más tiempo de generación a cambio de su orientación hacia una edición más precisa. Son afirmaciones del proveedor: no garantizan que tu petición tarde la mitad ni que una edición mantenga intacto cada píxel.

Las mejoras anunciadas incluyen fidelidad a las referencias y seguimiento de cambios concretos y sucesivos. Para un catálogo, por ejemplo, tiene sentido comprobar si el modelo conserva el producto cuando cambia el entorno. Para una campaña, conviene revisar si varias revisiones respetan las decisiones ya aprobadas. El resultado necesita revisión: siguen existiendo limitaciones con texto, composiciones complejas y consistencia visual.

Las fichas de Flare y Sunburst también publican las versiones gpt-image-2.5-flare-2026-09-08 y gpt-image-2.5-sunburst-2026-09-08. Guardar el identificador usado junto con cada petición permite saber qué modelo produjo un resultado; fijar una versión facilita comparaciones posteriores.

Si la decisión es entre proveedores, la comparativa de Nano Banana Pro y GPT Image 2 aborda otro punto de partida. Aquí nos centramos en las dos variantes 2.5 y en su integración directa con OpenAI.

Cuánto cuesta GPT Image 2.5

Estas son las tarifas estándar de la API directa, en USD por millón de tokens, consultadas en la página de precios de OpenAI. Se aplican tanto a Flare como a Sunburst; GPT Image 2 presenta las mismas tarifas en estas categorías.

GPT Image 2.5 no tiene una salida de texto facturable propia en esta tabla. Si lo invocas como herramienta desde Responses, el modelo que coordina la conversación puede añadir su propio consumo. La tabla anterior no cubre ese coste adicional, impuestos ni tarifas de intermediarios.

Del precio por token al coste de una petición

Multiplica cada cantidad de tokens por su tarifa y divide la suma entre un millón:

text
Coste en USD = (
    texto_sin_caché × 5
  + texto_en_caché × 1,25
  + imagen_entrada_sin_caché × 8
  + imagen_entrada_en_caché × 2
  + imagen_salida × 30
) / 1.000.000

Los cinco grupos deben ser excluyentes. Si el registro informa de 2.000 tokens de texto de entrada en total, de los cuales 500 proceden de caché, se facturan 1.500 a tarifa normal y 500 a tarifa de caché. No se cobran 2.000 a tarifa normal y otros 500 con descuento. Aplica la misma lógica a la imagen de entrada.

Supongamos una petición con 1.500 tokens de texto sin caché, 500 de texto en caché y 2.400 de imagen de salida, sin imagen de entrada. El cálculo sería:

text
(1.500 × 5 + 500 × 1,25 + 2.400 × 30) / 1.000.000
= 0,080125 USD

Es un ejemplo aritmético con consumos inventados para explicar la fórmula, no el precio medido de una imagen Flare o Sunburst. Mil peticiones con exactamente ese consumo sumarían 80,125 USD. Una edición añadiría la entrada de imagen que correspondiese.

Por qué no hay un único precio por imagen

La resolución, la calidad solicitada, las referencias y el consumo efectivo cambian el importe. Compartir tarifa tampoco demuestra que Flare y Sunburst usen los mismos tokens para un encargo. En una calculadora, selecciona la variante 2.5 concreta; una estimación configurada para GPT Image 2 no sirve como presupuesto de 2.5.

Para presupuestar producción, registra el coste de todos los intentos y divídelo entre las imágenes que finalmente aceptas. Si un lote cuesta 12 USD y solo utilizas 60 imágenes, el coste de generación por imagen utilizable es 0,20 USD. Es otro supuesto ilustrativo; permite incorporar los descartes sin confundir la factura API con el tiempo de revisión humana.

Generar una imagen y guardarla con Python

Para una aplicación que necesita un archivo a partir de un encargo, la API de imágenes ofrece un recorrido directo: petición, imagen codificada en base64 y guardado. Necesitas una clave API de un proyecto con facturación y acceso al modelo. La documentación advierte de que puede ser necesaria la verificación de la organización; tener una suscripción a ChatGPT no sustituye esta configuración de la API.

Instala el SDK y configura OPENAI_API_KEY en el entorno del servidor. No incluyas la clave en JavaScript enviado al navegador, repositorios o registros de depuración.

bash
python -m pip install --upgrade openai

Guarda lo siguiente como generar.py. Pide explícitamente un PNG de 1.536 × 1.024 píxeles y escribe un archivo nuevo en salidas:

python
import base64
from pathlib import Path
from uuid import uuid4

from openai import OpenAI

client = OpenAI(timeout=180.0, max_retries=0)

result = client.images.generate(
    model="gpt-image-2.5-flare",
    prompt=(
        "Fotografía editorial de una tetera de cerámica azul mate "
        "sobre una mesa de roble junto a una ventana. Luz de mañana, "
        "fondo sencillo, sin texto ni logotipos."
    ),
    size="1536x1024",
    quality="high",
    output_format="png",
)

if not result.data or not result.data[0].b64_json:
    raise RuntimeError("La respuesta no contiene una imagen base64")

image_bytes = base64.b64decode(result.data[0].b64_json, validate=True)
if not image_bytes.startswith(b"\x89PNG\r\n\x1a\n"):
    raise RuntimeError("Los datos recibidos no tienen una cabecera PNG")

folder = Path("salidas")
folder.mkdir(parents=True, exist_ok=True)
output = folder / f"tetera-{uuid4().hex}.png"
output.write_bytes(image_bytes)

print(f"Archivo: {output.resolve()}")
print(f"Bytes guardados: {output.stat().st_size}")
print("Uso comunicado por la API:", result.usage)

Ejecútalo con python generar.py. Una respuesta JSON no es todavía un archivo de imagen: aquí se extrae data[0].b64_json, se decodifica y se escriben los bytes. La comprobación de cabecera detecta una incoherencia básica de formato; abre el PNG guardado para verificar que un visor lo carga y que responde al encargo. El tamaño en bytes no mide la calidad del resultado.

El tiempo de espera y la desactivación de reintentos automáticos son decisiones de este ejemplo, no límites oficiales del servicio. Permiten observar un intento sin que el cliente lo repita automáticamente. El consumo devuelto ayuda a estudiar el coste; conserva también el identificador de la petición cuando esté disponible para relacionarla con tus registros.

Editar una imagen sin perder el original

Para editar, envía el archivo de entrada a images.edit. El siguiente programa utiliza Sunburst y recibe su ruta como argumento. El cambio solicitado es deliberadamente acotado: sustituir el fondo conservando la tetera. Es una instrucción al modelo, no una garantía de conservación exacta.

Guárdalo como editar.py:

python
import base64
import sys
from pathlib import Path
from uuid import uuid4

from openai import OpenAI

source = Path(sys.argv[1])
if not source.is_file():
    raise FileNotFoundError(source)

client = OpenAI(timeout=180.0, max_retries=0)
with source.open("rb") as image_file:
    result = client.images.edit(
        model="gpt-image-2.5-sunburst",
        image=image_file,
        prompt=(
            "Cambia únicamente el fondo por un estudio gris claro. "
            "Conserva la tetera, su color azul, forma, asa, pico y "
            "posición. Mantén una sombra de apoyo natural."
        ),
        size="1536x1024",
        quality="high",
        output_format="png",
    )

if not result.data or not result.data[0].b64_json:
    raise RuntimeError("La respuesta no contiene la imagen editada")

image_bytes = base64.b64decode(result.data[0].b64_json, validate=True)
if not image_bytes.startswith(b"\x89PNG\r\n\x1a\n"):
    raise RuntimeError("Los datos recibidos no tienen una cabecera PNG")

folder = Path("salidas")
folder.mkdir(parents=True, exist_ok=True)
output = folder / f"tetera-editada-{uuid4().hex}.png"
output.write_bytes(image_bytes)

print(f"Archivo editado: {output.resolve()}")
print(f"Bytes guardados: {output.stat().st_size}")
print("Uso comunicado por la API:", result.usage)

Ejecuta python editar.py ruta/a/tu-imagen.png, sustituyendo la ruta por la imagen generada o una fotografía propia. El programa crea otro archivo y conserva el original. Compara ambos: el fondo debe cambiar y el objeto debe seguir siendo adecuado para el uso previsto. Si importa un detalle comercial, como la forma exacta de un producto, revísalo de forma expresa antes de aprobar la edición.

Los dos ejemplos siguen el patrón de la guía oficial de generación y edición. Para repetir la prueba con Flare, cambia el identificador del modelo y mantén la misma imagen de entrada, instrucciones, tamaño y calidad. Así reduces las diferencias ajenas al modelo.

Resolución, calidad y formato: tres decisiones distintas

quality="max" no significa «resolución máxima». La calidad es un ajuste independiente de size. Si necesitas comparar variantes o presupuestar una función, fija ambos: con auto, el servicio puede elegir parámetros y hacer menos uniforme la comparación.

Los tamaños recomendados incluyen 1024x1024, 1536x1024 y 1024x1536. GPT Image 2.5 también admite tamaños personalizados dentro de límites concretos: lados múltiplos de 16, relación de aspecto entre 1:3 y 3:1, ningún lado superior a 3.840 píxeles y un total de entre 655.360 y 8.294.400 píxeles. Comprueba todos los límites a la vez; que un tamaño sea múltiplo de 16 no basta. Las resoluciones superiores a 2.560 × 1.440 se describen como experimentales. Consulta las condiciones en la documentación de personalización de la salida.

PNG es el formato predeterminado; también puedes solicitar JPEG o WebP. Para un fondo transparente, utiliza background="transparent" junto con PNG o WebP y guarda el archivo con la extensión correspondiente. Cambiar solo la extensión de un archivo no convierte su formato.

Cuándo conviene Responses y qué revisar antes de integrar

La API de imágenes encaja en una operación concreta de generación o edición. Responses tiene sentido cuando la imagen forma parte de una conversación, hay varias revisiones o el modelo debe combinar herramientas. La selección se hace en dos lugares: un modelo principal compatible, como gpt-6-astra, coordina la respuesta, mientras que el modelo de imagen se declara dentro de la herramienta:

json
{
  "model": "gpt-6-astra",
  "input": "Crea una imagen de una tetera azul sobre una mesa de roble.",
  "tools": [
    {
      "type": "image_generation",
      "model": "gpt-image-2.5-flare"
    }
  ]
}

En este caso busca un elemento de salida de tipo image_generation_call: su campo result contiene la imagen en base64. No uses la ruta data[0].b64_json, que corresponde a la API de imágenes. La guía de OpenAI explica ambas modalidades; añade al presupuesto el consumo del modelo principal de Responses.

Antes de ofrecer la función a usuarios, comprueba un pequeño conjunto de encargos representativos y guarda modelo, parámetros, duración, consumo y archivo final. Define qué hace aceptable una imagen: por ejemplo, conservar el producto, respetar un espacio para texto o mantener una composición después de editar. Compara después Flare, Sunburst y, si ya lo utilizas, GPT Image 2 con esos mismos encargos.

Una petición compleja puede tardar hasta dos minutos según la documentación. Si falla, conserva el código de estado, el mensaje y el identificador de petición. Corrige primero errores de parámetros, acceso, cuota o moderación; repetirlos a ciegas no los resuelve. Ante un fallo temporal, aplica reintentos limitados y evita que el usuario dispare solicitudes duplicadas mientras espera.

Para empezar hoy, el recorrido es concreto: genera con Flare, abre el archivo, prueba una edición con Sunburst y calcula el coste con el consumo real. La variante adecuada será la que complete tus encargos con un coste y una espera aceptables, no necesariamente la que tenga el ajuste de calidad más alto.