# Precio de GPT Image 2.6 Sunburst y Flare: 0,025–0,21 $ por imagen

> A 5 de noviembre de 2026, una imagen 1024 de GPT Image 2.6 cuesta 0,025 $ en low y 0,053 $ en high, igual en Sunburst que en Flare. Desde medium supera 0,03 $.

- URL: https://blog.laozhang.ai/es/posts/gpt-image-2-6-pricing
- Published: 2026-11-05
- Updated: 2026-11-05
- Author: LaoZhang AI Team (https://blog.laozhang.ai/es/about)
- Topic: Precios y planes de API
- Tags: GPT Image 2.6, Precios de API, API de OpenAI, Sunburst, Flare, Generación de imágenes

---
OpenAI cobra GPT Image 2.6 por tokens y con las mismas tarifas para sus dos modelos de API, `gpt-image-2.6-sunburst` y `gpt-image-2.6-flare`: 30 $ por millón de tokens de salida de imagen, 8 $ por millón de entrada de imagen y 5 $ por millón de entrada de texto. Como los dos gastan los mismos tokens con la misma calidad, una imagen de 1024×1024 cuesta lo mismo en ambos: unos 0,025 $ en `low`, 0,043 $ en `medium`, 0,053 $ en `high`, 0,094 $ en `xhigh` y 0,21 $ en `max`, a 5 de noviembre de 2026. Flare solo la entrega antes.

Para presupuestar, envía `quality` en cada petición, porque sin ella Flare elige el nivel según el prompt y una sola imagen puede pasar de 0,17 $. Después multiplica el coste de tu calidad por las imágenes del mes: 1.000 imágenes en `high` son 52,68 $, sin descuento Batch, que 2.6 no admite. Si casi todo lo que generas es `medium` o `high` y no necesitas `xhigh`, `max`, SVG ni GIF pequeños, una tarifa plana de 0,03 $ por llamada, como la de los modelos `gpt-image-2.6-flare-vip` y `gpt-image-2.6-sunburst-vip` de LaoZhang API, deja esas mismas 1.000 imágenes en 30 $. En `low`, pagar por tokens sigue costando menos.

*Aviso: [laozhang.ai es un servicio propio](https://blog.laozhang.ai/es/about#laozhang). Sus precios son nuestra tarifa, no una comparación independiente.*

Los tokens por imagen salen de una prueba que el equipo de documentación de LaoZhang API hizo el 5 de noviembre de 2026 con llamadas directas a la API de OpenAI, una ejecución por caso. Ese mismo día, el coste recalculado con las tarifas oficiales coincidió, con menos de un 0,1 % de diferencia, con lo que se cobró de verdad por tres de esas peticiones con importe conocido. En ChatGPT no hay precio por imagen: Images 2.6 entra en la suscripción que ya pagas.

## Precio por imagen de GPT Image 2.6 según quality y tamaño

El coste de una imagen generada es sus tokens de salida × 30 $ / 1.000.000, más el prompt como texto de entrada, que no llega a 0,001 $. La [tabla de precios de la API de OpenAI](https://developers.openai.com/api/docs/pricing) aplica esa tarifa a Flare y Sunburst por igual, así que lo único que mueve el precio es cuántos tokens gasta cada `quality` y cada tamaño. Con los recuentos medidos el 5 de noviembre de 2026, una imagen sale así:

| `quality` | Tokens de salida, 1024×1024 | Coste por imagen, 1024×1024 | 1.000 imágenes, 1024×1024 | Coste por imagen, 1536×1024 |
| --- | ---: | ---: | ---: | ---: |
| `low` | 824 | 0,0247 $ | 24,72 $ | 0,0199 $ |
| `medium` | 1.449 | 0,0435 $ | 43,47 $ | 0,0340 $ |
| `high` | 1.756 | 0,0527 $ | 52,68 $ | 0,0406 $ |
| `xhigh` | 3.122 | 0,0937 $ | 93,66 $ | 0,0738 $ |
| `max` | 7.024 | 0,2107 $ | 210,72 $ | sin medir |

Por ejemplo, una imagen `high` cuadrada son 1.756 × 30 / 1.000.000 = 0,05268 $. El formato horizontal 1536×1024 gasta menos tokens que el cuadrado (664 en `low`, 1.353 en `high`), y el 4K de 3840×2160 gasta 1.559 tokens en `low` (0,0468 $) y 3.337 en `high`, unos 0,10 $ por imagen. Si tu presupuesto es mensual, la cuenta es imágenes al mes × coste de tu calidad y tamaño; las imágenes que descartes también entran en esa cifra.

La fórmula no se queda en teoría. El 5 de noviembre de 2026 se aplicó a peticiones cuyo cargo real se conocía, cobradas por el reenvío oficial de LaoZhang API a las tarifas de OpenAI: una imagen `low` de 1024 con 15 tokens de texto y 824 de salida da 0,02480 $ y se cobraron 0,02480 $; un GIF de 512×512 en `low` con 4 fotogramas (36 de texto, 1.172 de salida) da 0,03534 $, lo mismo que se cobró; una imagen `low` de GPT Image 2.5 da 0,00596 $ en ambos casos, y una edición `low`, cuyo recuento de tokens de la referencia es aproximado, sale por unos 0,033 $ frente a 0,03301 $ cobrados.

*Aviso: [laozhang.ai es un servicio propio](https://blog.laozhang.ai/es/about#laozhang). Sus precios son nuestra tarifa, no una comparación independiente.*

## ¿Sunburst es más caro que Flare? Mismo precio, distinto tiempo

No: `gpt-image-2.6-sunburst` y `gpt-image-2.6-flare` tienen la misma tarifa y en la prueba del 5 de noviembre, a 1024×1024, gastaron los mismos tokens en cada calidad, con una única diferencia de dos tokens en `high`. Lo que cambia es la espera, porque Flare tardó 8, 11 y 12 s en `low`, `medium` y `high`, y Sunburst 34, 42 y 59 s; son mediciones únicas y dependen de la cola. Cuál conviene para cada trabajo, y si te compensa dejar la versión anterior, lo tienes en [GPT Image 2.6 vs 2.5: diferencias y cuándo cuesta 4 veces más](https://blog.laozhang.ai/es/posts/gpt-image-2-6-vs-2-5).

## Cuánto cuestan ediciones, GIF y SVG en GPT Image 2.6

Editar, pedir un GIF o pedir un SVG se cobra con las mismas tarifas que generar, pero cada tipo de petición suma tokens distintos. La edición añade cada imagen de referencia como entrada de imagen, el GIF dibuja todos los fotogramas en una misma hoja y el SVG encadena una imagen de referencia con un modelo de texto que escribe el código. Estos son los ejemplos medidos el 5 de noviembre de 2026, a 1024×1024 salvo que se indique otro tamaño:

| Petición | Qué se cobra | Ejemplo |
| --- | --- | --- |
| Generar (`/v1/images/generations`) | Tokens de salida según `quality` y `size`, más el prompt como texto | `low`: 824 tokens, 0,0247 $ |
| Editar (`/v1/images/edits`) | Lo mismo, más cada imagen de referencia a 8 $ por millón | Una referencia de 1024 son unos 1.048 tokens, +0,0084 $; edición `low`, unos 0,033 $ |
| GIF (`output_format: "gif"`, `frame_count`) | Una hoja con todos los fotogramas: sube con el tamaño de cada fotograma, su número y la calidad | 512×512 `low`, 4 fotogramas: 1.172 tokens, 0,0352 $; `medium`, 9 fotogramas: 2.073 tokens, 0,0622 $ |
| SVG (`output_format: "svg"`, `svg.model`) | La imagen de referencia a su tarifa normal, más el modelo de texto que escribe el SVG a la tarifa de ese modelo | Referencia `low` + `gpt-6.1-terra` en OpenAI directo: 0,011–0,015 $ más, unos 0,036–0,040 $ en total |

Como los fotogramas comparten hoja, un tamaño pequeño con muchos fotogramas falla con «No supported sheet fits»; 512×512 con 4 a 9 fotogramas funciona. El GIF no admite `stream` y, según la guía de imágenes de OpenAI, tampoco sale de una edición. El SVG rinde bien en iconos y gráficos sencillos: las escenas completas acabaron casi siempre en errores 502 de OpenAI, y cuanto más compleja es la imagen, más largo es el código y más cuesta escribirlo. En el reenvío oficial de LaoZhang API, escribir el SVG no añade cargo con el modelo por defecto, `gpt-6.1-terra`, ni con otros ocho modelos de texto baratos como `gpt-5.4-mini`; un icono sencillo en `medium` queda en unos 0,044 $ y tarda unos 40 s.

*Aviso: [laozhang.ai es un servicio propio](https://blog.laozhang.ai/es/about#laozhang). Sus precios son nuestra tarifa, no una comparación independiente.*

## ¿Tokens o 0,03 $ por llamada? El límite está en 1.000 tokens

Una tarifa fija de 0,03 $ equivale a 1.000 tokens de salida a 30 $ por millón, así que la regla es simple: si tu imagen gasta menos de 1.000 tokens, paga por tokens; si gasta más, la tarifa por llamada se queda por debajo. A 1024×1024 eso deja `low` (824 tokens) del lado de los tokens y todo lo que va de `medium` (1.449) hacia arriba del lado de la tarifa fija; en 1536×1024 pasa lo mismo, con `low` en 664 tokens y `medium` en 1.132. La tarifa fija solo vale si la ruta admite lo que pides, y ahí está la otra mitad de la decisión.

![Coste por imagen de GPT Image 2.6 a 1024×1024 según la quality, de 0,0247 $ en low a 0,2107 $ en max, frente a la línea de 0,03 $ por llamada, equivalente a 1.000 tokens](https://blog.laozhang.ai/posts/es/gpt-image-2-6-pricing/img/coste-por-calidad-vs-tarifa-fija.webp)

LaoZhang API vende GPT Image 2.6 de tres formas. El reenvío oficial manda tus peticiones a OpenAI y cobra los mismos tokens a las mismas tarifas, con claves de los grupos `OpenAI Official` u `OpenAI Official Enterprise`. La versión VIP son los modelos terminados en `-vip`, con precio fijo por imagen en el grupo `default`, el grupo estándar de las claves. La ruta web es el modelo `gpt-image-2.6-web`, también con precio fijo por llamada en el grupo `default`, pensada para GIF:

*Aviso: [laozhang.ai es un servicio propio](https://blog.laozhang.ai/es/about#laozhang). Sus precios son nuestra tarifa, no una comparación independiente.*

| Ruta | Precio | Calidad y modelo | GIF | SVG | 4K |
| --- | --- | --- | --- | --- | --- |
| API de OpenAI directa | Por tokens, según la tabla de arriba | Hasta `max`; Flare o Sunburst | Sí; 512×512 funciona | Sí; el modelo autor se cobra aparte | Sí; `high` unos 0,10 $ |
| LaoZhang API, reenvío oficial | Mismas tarifas por token; el grupo Enterprise suma un 20 % | Hasta `max`; Flare o Sunburst | Sí; 512×512 funciona | Sí; autor por defecto sin cargo | Sí, por tokens |
| LaoZhang API, 2.6 VIP | 0,03 $ por imagen con cualquier tamaño y calidad, al generar o editar | Hasta `high`; Flare o Sunburst | No (error 400) | No (error 400) | Nativo, 3840×2160 |
| LaoZhang API, ruta web | 0,03 $ por llamada, sea cual sea el tamaño o el número de fotogramas | No se elige Flare ni Sunburst | Sí, desde unos 1024×1024 y de 2 a 64 fotogramas | No | Ampliado desde unos 2K |

El 5 de noviembre de 2026, una clave del grupo `default` de LaoZhang API pidió cuatro imágenes VIP con el mismo prompt de foto de producto: `gpt-image-2.6-sunburst-vip` en `low` y en `high` a 1024×1024, y `gpt-image-2.6-flare-vip` en `high` a 3840×2160 y en `low` a 1536×1024. Las cuatro devolvieron un PNG del tamaño pedido, también el 4K, en 47,3, 65,8, 32,3 y 72,2 s, al mismo precio de lista de 0,03 $; Flare VIP no es la vía rápida. La misma petición con `quality: "xhigh"` volvió con un 400 en 1,1 s («gpt-image-2.6 -vip models support quality up to high; xhigh / max are not supported») y el saldo no se movió. Si necesitas `xhigh` o `max` a precio fijo, la alternativa son los modelos VIP de 2.5, `gpt-image-2.5-flare-vip` y `gpt-image-2.5-sunburst-vip`, que admiten todas las calidades.

Esa misma noche, con la misma clave, `gpt-image-2.6-web` con `output_format: "gif"`, `size: "1024x1024"`, `frame_count: 6` y `frame_duration_ms: 150` devolvió un 200 en 41,4 s: un GIF de 1024×1024 y 1,4 MB con exactamente 6 fotogramas de 150 ms. La misma petición en 512×512 se rechazó con un 400 en 1,7 s y `"param":"size"`, porque la ruta web exige al menos 655.360 píxeles. En esta ruta pagas por llamada, no por fotograma: un GIF de 64 fotogramas sigue siendo una llamada de 0,03 $, aunque tarda unos 2 minutos. Un GIF pequeño de 512×512, en cambio, solo sale por tokens, en OpenAI o en el reenvío oficial.

![Qué ruta de GPT Image 2.6 conviene según lo que pides: low por tokens, medium, high o 4K con 2.6 VIP, xhigh o max por tokens o 2.5 VIP, GIF grande por la ruta web y GIF de 512×512 o SVG solo por tokens](https://blog.laozhang.ai/posts/es/gpt-image-2-6-pricing/img/que-ruta-elegir.webp)

## Qué hace que la factura de GPT Image 2.6 suba más de lo previsto

La tarifa por token no cambia, pero hay seis costumbres que hacen que cada imagen salga más cara de lo que dice la tabla:

- Si no envías `quality`, Flare elige el nivel según el prompt: con un prompt detallado gastó unos 5.795 tokens tres veces seguidas, unos 0,174 $ por imagen de 1024, y Sunburst sin `quality` trabaja en `high`.
- Si cuentas con la mitad de precio de Batch, no la vas a tener: a 5 de noviembre de 2026 las fichas de [GPT Image 2.6 Flare en la documentación de OpenAI](https://developers.openai.com/api/docs/models/gpt-image-2.6-flare) y de Sunburst marcan Batch como no compatible, y la tabla de precios Batch no tiene filas de 2.6. OpenAI no ha dicho si lo añadirá; mientras tanto, una imagen `high` de GPT Image 2.5 por Batch sale por unos 0,026 $.
- Si das por hecho el descuento de entrada en caché, revisa la letra pequeña: la tabla lista precios en caché para 2.6, pero la nota que los acompaña dice que solo se aplican a GPT Image 2 y 2.5 generadas con la Responses API.
- Si usas el grupo `OpenAI Official Enterprise` del reenvío oficial, todo cuesta un 20 % más: una imagen `high` de 1024 pasa a 0,0632 $.
- Si cambias `svg.model` a un modelo grande, el código del SVG se cobra a la tarifa de ese modelo; con `gpt-5.5`, solo escribir un icono sencillo cuesta 0,09–0,16 $.
- Si repites generaciones hasta dar con la buena, cada respuesta correcta se cobra entera, así que descartar la mitad duplica tu coste por imagen útil. En LaoZhang API, las respuestas que no son 200, como los errores de parámetros o los bloqueos de moderación, no se cobran.

*Aviso: [laozhang.ai es un servicio propio](https://blog.laozhang.ai/es/about#laozhang). Sus precios son nuestra tarifa, no una comparación independiente.*

Lo que no sube la factura es `complexity`, el parámetro nuevo que controla la complejidad de la escena (`low`, `medium` o `high`, por defecto `high`): con la misma `quality`, el número de tokens no cambia.

## Por qué hay páginas que dan 4 $ u 8 $ por millón de tokens

Esas cifras no son lo que te cobra OpenAI por una imagen. Un «precio inicial de 4 $ por millón de tokens» es la tarifa de entrada de un revendedor, no la de OpenAI, cuyo texto de entrada cuesta 5 $; «8 $ de entrada y 8 $ de salida» mezcla la tarifa de entrada de imagen con la de salida, que es 30 $, y otros catálogos añaden su propio margen sobre esa salida. Las páginas escritas antes del 4 de noviembre de 2026, que dicen que OpenAI aún no había publicado precios, simplemente se quedaron atrás. En cualquier caso, un precio por millón no te dice cuánto cuesta una imagen hasta que lo multiplicas por sus tokens, que a 1024×1024 van de 824 en `low` a 7.024 en `max`.

## Cómo calcular el coste de cada respuesta desde `usage`

Cada respuesta de la Image API trae un objeto `usage` con `input_tokens_details.text_tokens`, `input_tokens_details.image_tokens` y `output_tokens`, según la [referencia del método de generación de imágenes de OpenAI](https://developers.openai.com/api/reference/resources/images/methods/generate). Multiplicados por 5, 8 y 30 $ por millón dan el coste exacto de esa petición, y esta función, ejecutada el 5 de noviembre de 2026 con los tokens de peticiones cuyo cargo se conocía, devolvió los mismos importes:

```python
# Cost of one GPT Image 2.6 response from its `usage` object (OpenAI rates, Nov 2026).
RATES = {"text_in": 5.00, "image_in": 8.00, "image_out": 30.00}  # USD per 1M tokens

def image_cost_usd(usage: dict, enterprise_markup: float = 1.0) -> float:
    inp = usage.get("input_tokens_details") or {}
    text_in = inp.get("text_tokens", usage.get("input_tokens", 0))
    image_in = inp.get("image_tokens", 0)
    out = usage.get("output_tokens", 0)
    usd = (text_in * RATES["text_in"] + image_in * RATES["image_in"] + out * RATES["image_out"]) / 1_000_000
    return round(usd * enterprise_markup, 5)

if __name__ == "__main__":
    samples = {  # token counts from the Nov 5 test requests whose billed amounts are known
        "low 1024 generate (billed $0.02480)": {"input_tokens": 15, "input_tokens_details": {"text_tokens": 15, "image_tokens": 0}, "output_tokens": 824},
        "GIF 512 low 4 frames (billed $0.03534)": {"input_tokens": 36, "input_tokens_details": {"text_tokens": 36, "image_tokens": 0}, "output_tokens": 1172},
        "high 1024, Enterprise +20%": {"input_tokens": 15, "input_tokens_details": {"text_tokens": 15, "image_tokens": 0}, "output_tokens": 1756},
    }
    for name, u in samples.items():
        m = 1.2 if "Enterprise" in name else 1.0
        print(f"{name}: ${image_cost_usd(u, m):.5f}")
```

```text
low 1024 generate (billed $0.02480): $0.02480
GIF 512 low 4 frames (billed $0.03534): $0.03534
high 1024, Enterprise +20%: $0.06331
```

Sirve para la API de OpenAI directa y para el reenvío oficial de LaoZhang API; en el grupo Enterprise, llama a `image_cost_usd(usage, 1.2)`. No la uses con las rutas VIP o web: cobran 0,03 $ fijos por llamada y los tokens que devuelvan no son la factura.

*Aviso: [laozhang.ai es un servicio propio](https://blog.laozhang.ai/es/about#laozhang). Sus precios son nuestra tarifa, no una comparación independiente.*

Para montar la petición en sí (ID de modelo, primera llamada y errores), consulta [GPT Image 2.6 API: ID de modelo, código y Flare vs Sunburst](https://blog.laozhang.ai/es/posts/gpt-image-2-6-api).

## Preguntas frecuentes sobre el precio de GPT Image 2.6

### ¿Cuánto cuesta GPT Image 2.6 en ChatGPT?

No tiene precio por imagen. Según el [anuncio de Images 2.6 de OpenAI](https://openai.com/index/introducing-images-2-6/), desde el 4 de noviembre de 2026 está en ChatGPT y Codex en todos los planes, y OpenAI no publica cuántas imágenes o GIF permite cada uno: pagas tu suscripción. Si lo que quieres son animaciones dentro de ChatGPT, mira [Cómo hacer un GIF en ChatGPT con Images 2.6: pasos y fotogramas](https://blog.laozhang.ai/es/posts/how-to-make-a-gif-in-chatgpt).

### ¿Se puede usar la API de GPT Image 2.6 gratis?

No. A 5 de noviembre de 2026, la página de precios de la API de OpenAI no indica ningún nivel gratuito para `gpt-image-2.6-flare` ni para `gpt-image-2.6-sunburst`, así que cada imagen se paga por tokens o, en las rutas de precio fijo, por llamada. La única forma de usar Images 2.6 sin pagar por imagen es dentro de ChatGPT, con los límites sin publicar de tu plan.

### ¿Cuánto cuesta una imagen vertical de 1024×1536 con GPT Image 2.6?

A 5 de noviembre de 2026 no hay recuento medido de tokens para el vertical 1024×1536, y no conviene copiar la cifra del horizontal 1536×1024 aunque tenga los mismos píxeles. Lo más fiable es hacer una petición de prueba con tu `quality` y pasar su `usage` por la función de arriba.

### ¿Cuánto cuestan GPT Image 2.5 y GPT Image 2 por imagen?

Usan las mismas tarifas por token, pero no los mismos tokens: GPT Image 2.5 gasta bastante menos en `low` y `medium`. Las cifras por imagen están en [Precio de GPT Image 2.5 Sunburst: por imagen, llamada y mes](https://blog.laozhang.ai/es/posts/gpt-image-2-5-api-pricing) y en [Precio de la API de GPT Image 2: de 0,005 a 0,43 USD por imagen](https://blog.laozhang.ai/es/posts/gpt-image-2-api-pricing).

## Fuentes

Páginas externas que cita esta guía, en el orden en que aparecen. Última actualización: 2026-11-05.

- [tabla de precios de la API de OpenAI](https://developers.openai.com/api/docs/pricing) (developers.openai.com)
- [GPT Image 2.6 Flare en la documentación de OpenAI](https://developers.openai.com/api/docs/models/gpt-image-2.6-flare) (developers.openai.com)
- [referencia del método de generación de imágenes de OpenAI](https://developers.openai.com/api/reference/resources/images/methods/generate) (developers.openai.com)
- [anuncio de Images 2.6 de OpenAI](https://openai.com/index/introducing-images-2-6/) (openai.com)