# GPT Image 2.5 en n8n: cuándo basta el nodo OpenAI y cuándo no

> El nodo OpenAI usa GPT Image 2.5 hasta calidad high y 1536 px, sin fondo transparente ni registro de tokens. Para más, HTTP Request; la API se paga aparte.

- URL: https://blog.laozhang.ai/es/posts/gpt-image-2-5-n8n
- Published: 2026-09-21
- Updated: 2026-09-25
- Author: LaoZhang AI Team (https://blog.laozhang.ai/es/about)
- Topic: Generación de imágenes con IA
- Tags: GPT Image 2.5, n8n, Automatización, OpenAI, HTTP Request

---
Sí, puedes generar imágenes con GPT Image 2.5 usando el nodo **OpenAI** de n8n: en la operación **Generate an Image** (versión del nodo 2.2 o posterior) eliges `gpt-image-2.5-flare` o `gpt-image-2.5-sunburst` y el nodo te devuelve directamente un archivo binario en el campo `data`. El límite está en los ajustes: para los modelos GPT Image, ese nodo solo ofrece calidad `low`, `medium` o `high` y tres tamaños (`1024x1024`, `1024x1536`, `1536x1024`), sin fondo transparente, sin elegir formato y sin conservar el consumo de tokens.

Si necesitas `xhigh`, `max` o `auto`, imágenes de 2K o 4K, un tamaño libre, fondo transparente, JPEG o WebP al generar, o registrar cuánto gasta cada imagen, monta la llamada con **HTTP Request** y convierte el Base64 con **Convert to File**. En cualquiera de los dos casos, n8n no hace gratuita la API: OpenAI factura cada imagen por tokens a tu cuenta.

## Qué ajustes llegan al nodo OpenAI y cuáles exigen HTTP Request

La tabla compara lo que admite la API de GPT Image 2.5 con lo que exponen las dos operaciones de imagen del nodo OpenAI, según su código fuente público a 25 de septiembre de 2026.

| Ajuste | Generate an Image (nodo ≥ 2.2) | Edit Image (nodo ≥ 2.3) | HTTP Request contra la API |
|---|---|---|---|
| Modelo `gpt-image-2.5-flare` / `-sunburst` | Sí (lista o ID) | Sí (lista o ID) | Sí |
| Calidad | `low`, `medium`, `high` | `auto`, `low`, `medium`, `high` | `low`, `medium`, `high`, `xhigh`, `max`, `auto` |
| Tamaño | 3 tamaños fijos, lado largo 1536 px | Fijos hasta 1536 px y `auto` | Libre hasta 3840 px por lado |
| Fondo transparente | No | Sí (Background) | Sí (`background: "transparent"`) |
| Formato de salida | Siempre PNG | PNG, JPEG, WebP | PNG, JPEG, WebP |
| Varias imágenes de referencia | — | Sí, como `image[]` | Sí, como `image[]` |
| Máscara | — | Sí (Image Mask) | Sí (`mask`) |
| Consumo de tokens (`usage`) | Se descarta | Se descarta | Llega en la respuesta |
| Respuesta con URL o ID de tarea | No la procesa | No la procesa | Sí, con nodos adicionales |

De ahí sale una regla sencilla. Te basta el nodo OpenAI si quieres imágenes cuadradas, verticales u horizontales de hasta 1536 px, en calidad `high` como máximo, y no necesitas saber cuánto costó cada una. En cuanto aparece cualquier otra necesidad de la columna derecha, pasa a HTTP Request.

Estas conclusiones salen de leer el código del nodo, no de una prueba en una instalación concreta. El archivo de la operación Generate no ha cambiado desde el 20 de mayo de 2026 y la última versión de n8n publicada es la 2.40.6 (24 de septiembre de 2026), así que lo esperable es que tu instalación se comporte igual. Para comprobarlo en la tuya, abre el nodo, elige un modelo 2.5, pulsa **Add Option** y mira qué valores ofrece **Quality** y **Resolution**.

Ojo con una confusión frecuente: la «versión del nodo» (typeVersion) no es la versión de n8n. Un nodo creado hace tiempo puede seguir en una versión antigua aunque actualices n8n; en ese caso Generate solo muestra DALL·E 2, DALL·E 3 y GPT Image 1 en un desplegable fijo. Si no ves el selector con **From List** e **ID**, añade un nodo OpenAI nuevo.

![Dos caminos en n8n: el nodo OpenAI entrega la imagen como archivo binario en el campo data; HTTP Request devuelve un JSON del que salen el archivo a partir de b64_json y el registro de usage](https://blog.laozhang.ai/posts/es/gpt-image-2-5-n8n/img/native-or-http.webp)

Dos detalles del esquema no se aplican a GPT Image 2.5: la opción de estilo del nodo solo existe para DALL·E 3, y el `usage` de la API de imágenes usa los campos `input_tokens`, `output_tokens` y `total_tokens`.

## Credencial y modelo: lo que hay que escribir

La credencial **OpenAI** de n8n tiene cuatro campos: API Key, Organization ID (opcional), Base URL y Add Custom Header. La Base URL viene rellenada con `https://api.openai.com/v1` y el nodo envía cada petición a esa dirección más el endpoint (`/images/generations` o `/images/edits`). Si dudas sobre el Organization ID, en [OpenAI API Key y Organization ID: lo que de verdad necesitas en 2026](https://blog.laozhang.ai/es/posts/openai-api-key-organization-id) se explica cuándo hace falta.

En el campo **Model**, el modo **From List** consulta `/models` en la Base URL de la credencial y muestra solo los IDs que contienen `dall-e` o `gpt-image`. Si los modelos 2.5 no aparecen, cambia a modo **ID** y escribe el identificador completo:

- `gpt-image-2.5-flare`: generación rápida y de alta calidad para el día a día.
- `gpt-image-2.5-sunburst`: el modelo de OpenAI pensado para cuando la precisión al editar es lo que más importa.

`gpt-image-2.5` a secas no es un ID válido. Si quieres fijar una versión concreta, existen las instantáneas `gpt-image-2.5-flare-2026-09-08` y `gpt-image-2.5-sunburst-2026-09-08`. Para decidir entre los dos modelos, consulta [GPT Image 2.5 Sunburst vs Flare: cuál elegir y cuánto difieren](https://blog.laozhang.ai/es/posts/gpt-image-2-5-sunburst-vs-flare); si vienes de GPT Image 2, [GPT Image 2.5 frente a GPT Image 2: cuál usar y cómo migrar](https://blog.laozhang.ai/es/posts/gpt-image-2-5-vs-gpt-image-2).

Si la primera llamada devuelve un 403 o un error de modelo no disponible con una clave que funciona para texto, revisa la organización: OpenAI puede exigir la [verificación de la organización de la API](https://help.openai.com/en/articles/10910291-api-organization-verification) en la consola de desarrollador antes de permitir los modelos GPT Image.

## ¿Sale gratis generar imágenes en n8n?

No. Da igual que uses n8n autoalojado o en la nube: n8n solo orquesta el flujo y cada imagen la cobra el proveedor de la API. En OpenAI, Flare y Sunburst comparten tarifa por millón de tokens: USD 5 de texto de entrada, USD 8 de imagen de entrada y USD 30 de imagen de salida (con descuento para la entrada en caché). OpenAI advierte de que la misma tarifa no significa el mismo coste por imagen, porque el consumo de tokens cambia con el modelo y la calidad. Con `quality` en `auto` es el modelo quien elige, así que dos peticiones idénticas pueden costar distinto.

La única forma fiable de saber cuánto te cuesta una imagen es el objeto `usage` que devuelve la API. Ahí está la trampa del nodo OpenAI: lo descarta. La incidencia [#38482](https://github.com/n8n-io/n8n/issues/38482), abierta a 25 de septiembre de 2026, lo reproduce en n8n 2.38.6 con el nodo en versión 2.3 y `gpt-image-2.5-flare`: el panel de ejecución muestra cero tokens aunque la API sí devolvió el consumo, y la imagen se factura igual. No se puede recuperar con una expresión ni con un nodo Code, porque el dato nunca sale de la operación.

Si quieres calcular precios por imagen, llamada o mes, tienes el detalle 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).

## Lo que devuelve la API decide qué nodos necesitas

Antes de montar nada, haz una petición de prueba y mira la forma exacta de la respuesta. Con OpenAI directo siempre recibirás `data[].b64_json`, pero algunos proveedores compatibles devuelven otras formas, y cada una pide una cadena de nodos distinta:

| Lo que llega | Ejemplo | Cadena en n8n |
|---|---|---|
| Base64 limpio | `data[0].b64_json` = `iVBORw0K…` | Nodo OpenAI, o HTTP Request → Convert to File |
| Base64 con prefijo o sin `=` final | `data:image/png;base64,iVBORw0K…` | HTTP Request → Code (limpiar) → Convert to File |
| Enlace temporal | `data[0].url` | HTTP Request → segundo HTTP Request (GET, Response Format: File) cuanto antes |
| Tarea asíncrona | `task_id` y luego `resultUrl` | HTTP Request (enviar) → Wait → HTTP Request (consultar estado) → If → descarga |

El nodo OpenAI solo sabe decodificar `b64_json` limpio: pasa esa cadena directamente a binario, sin quitar prefijos ni descargar enlaces. Con un proveedor que responda de otra forma, lo previsible es un error o un archivo que no abre, así que para las tres últimas filas usa HTTP Request.

El modelo asíncrono lo usan pasarelas como HiAPI: su plantilla de n8n envía la tarea, consulta el estado cada 5 segundos hasta 36 veces y al final recibe una `resultUrl`; guardar el archivo queda como un paso aparte. Si tu proveedor funciona así, el tiempo máximo de espera lo marca tu bucle de consultas, no el Timeout de la primera petición.

## El flujo con HTTP Request, de la petición al archivo

Este es el recorrido completo para OpenAI directo. Sirve igual para un proveedor compatible cambiando la URL y la clave.

### 1. La petición

Añade un nodo **HTTP Request** detrás de tu disparador (Webhook, Schedule Trigger, una fila nueva en una hoja de cálculo…) y configúralo así:

- **Method**: `POST`
- **URL**: `https://api.openai.com/v1/images/generations`
- **Authentication**: si tu credencial OpenAI aparece en **Predefined Credential Type**, reutilízala; si no, usa **Generic Credential Type → Header Auth** con el nombre `Authorization` y el valor `Bearer` seguido de tu clave.
- **Send Body**: activado, **Body Content Type** JSON, **Specify Body** Using JSON, con el campo en modo Expression:

```json
{
  "model": "gpt-image-2.5-flare",
  "prompt": {{ JSON.stringify($json.prompt) }},
  "size": "2048x1152",
  "quality": "high",
  "output_format": "png"
}
```

`JSON.stringify` evita que unas comillas dentro del prompt rompan el JSON. El tamaño `2048x1152` es un 16:9 válido: los tamaños libres deben tener ambos lados múltiplos de 16, una proporción entre 1:3 y 3:1, ningún lado por encima de 3840 px y entre 655.360 y 8.294.400 píxeles en total. Por encima de `2560x1440` OpenAI califica los resultados de experimentales. Para un fondo transparente añade `"background": "transparent"` con `output_format` en `png` o `webp`. No envíes `response_format`: es un parámetro de la época de DALL·E y los modelos GPT Image siempre devuelven Base64.

Para imágenes 4K en concreto y cómo verificar que el archivo tiene los píxeles pedidos, [GPT Image 2 4K API: generar, guardar y verificar imágenes 3840x2160](https://blog.laozhang.ai/es/posts/gpt-image-2-4k-image-generation) recorre el proceso con GPT Image 2; las reglas de tamaño son las mismas en 2.5.

### 2. Guardar el consumo antes de convertir

El orden importa: **Convert to File** entrega un ítem con el JSON vacío y solo el binario, así que todo lo que venía de la respuesta, `usage` incluido, desaparece en ese paso. Pon antes un nodo **Edit Fields (Set)** con estos campos:

- `image_base64` = `{{ $json.data[0].b64_json }}`
- `input_tokens` = `{{ $json.usage.input_tokens }}`
- `output_tokens` = `{{ $json.usage.output_tokens }}`
- `total_tokens` = `{{ $json.usage.total_tokens }}`

Conecta la salida de Edit Fields a dos ramas: una hacia tu registro de costes (Google Sheets, una Data Table de n8n o una base de datos) y otra hacia Convert to File. Si en HTTP Request activas **Include Response Headers and Status**, la respuesta queda dentro de `body` y las rutas pasan a ser `$json.body.data[0].b64_json` y `$json.body.usage`.

Si tu proveedor devuelve Base64 con prefijo, sin relleno o una URL, sustituye Edit Fields por un nodo **Code** en modo Run Once for Each Item:

```javascript
const item = $json.data?.[0] ?? {};
let b64 = item.b64_json ?? '';
if (b64.startsWith('data:')) b64 = b64.split(',')[1];
b64 = b64.replace(/\s/g, '');
if (b64) b64 += '='.repeat((4 - (b64.length % 4)) % 4);

return {
  json: {
    image_base64: b64 || null,
    image_url: item.url ?? null,
    usage: $json.usage ?? null,
  },
};
```

Después, un nodo **If** separa los ítems con `image_url` (van a un HTTP Request GET con Response Format **File**) de los que traen `image_base64` (van a Convert to File).

### 3. De Base64 a archivo

En **Convert to File** elige la operación **Move Base64 String to File**:

- **Base64 Input Field**: `image_base64` (solo el nombre del campo, sin llaves ni `$json`).
- **Put Output File in Field**: `data`.
- En Options, **File Name** con una expresión que dé nombres únicos, por ejemplo `{{ $now.toFormat('yyyyMMdd-HHmmss') }}-{{ $itemIndex }}.png`, y **MIME Type** `image/png`. Si pediste `jpeg` o `webp`, cambia la extensión y el MIME Type para que coincidan.

![Del JSON al archivo PNG en cuatro pasos: HTTP Request recibe el campo b64_json del primer elemento de data, Edit Fields lo guarda en image_base64, Convert to File con Move Base64 String to File lo convierte y el destino recibe taza.png](https://blog.laozhang.ai/posts/es/gpt-image-2-5-n8n/img/json-to-png.webp)

En el paso de Edit Fields, la expresión completa es `{{ $json.data[0].b64_json }}`; el esquema la abrevia sin `$json`.

### 4. Entrega y comprobación

El nodo de destino (Google Drive, S3, Send Email como adjunto, Telegram…) debe leer el binario del campo `data`, o el nombre que pusieras en Put Output File in Field. Antes de activar el flujo, haz una ejecución de prueba y comprueba tres cosas: que el archivo se abre, que sus dimensiones coinciden con el `size` pedido y que la fila de costes se ha escrito con valores distintos de cero.

## Editar con imágenes de referencia y máscara

Para editar tienes dos opciones con requisitos distintos.

**Nodo OpenAI → Edit Image** (versión 2.3 o posterior). En **Images** añade un campo binario por cada imagen de referencia; el nodo las envía como `image[]` repetido y su propia ayuda habla de hasta 16 imágenes. Admite **Image Mask**, Background, Output Format y Output Compression, pero la calidad llega a `high` y el tamaño a 1536 px. No toques **Input Fidelity**: OpenAI solo lo documenta para los modelos GPT Image anteriores y no para 2.5.

**HTTP Request contra `/v1/images/edits`**. Body Content Type **Form-Data**. Añade `model` y `prompt` como Form Data y, por cada imagen, un parámetro de tipo **n8n Binary File** con Name `image[]` e Input Data Field Name igual al campo binario de entrada (`data`, `data_1`…). La máscara va en otro parámetro binario llamado `mask`. Por aquí sí puedes pedir `xhigh`, `max` o tamaños grandes.

Las reglas de la máscara son iguales por los dos caminos:

- Con varias imágenes, la máscara se aplica solo a la primera.
- Imagen y máscara deben tener el mismo formato y tamaño, y la máscara necesita canal alfa.
- Es una guía, no un recorte exacto: OpenAI avisa de que el modelo puede no seguir la forma con total precisión.
- No hay un límite de peso único: la guía de OpenAI habla de menos de 50 MB y otras documentaciones piden menos de 4 MB para la máscara. Mantenerla por debajo de 4 MB evita problemas en cualquier caso.

## Lotes, tiempo de espera y reintentos

Cuando el flujo procesa muchos ítems, el primer freno es el límite de imágenes por minuto (IPM) de tu nivel de uso en OpenAI. Si mandas una imagen por petición y no hay más tráfico en la organización, el intervalo mínimo entre peticiones es 60.000 ÷ IPM milisegundos:

| Nivel de uso | IPM | Tokens por minuto | Batch Interval mínimo |
|---|---|---|---|
| Tier 1 | 5 | 100.000 | 12.000 ms |
| Tier 2 | 20 | 250.000 | 3.000 ms |
| Tier 3 | 50 | 800.000 | 1.200 ms |
| Tier 4 | 150 | 3.000.000 | 400 ms |
| Tier 5 | 250 | 8.000.000 | 240 ms |

En HTTP Request, abre **Options → Batching** y pon **Items per Batch** en `1` y **Batch Interval** en el valor de tu nivel. El cálculo supone `n` = 1; si pides varias imágenes por petición o compartes la organización con otras aplicaciones, amplía el margen. Con imágenes grandes en calidad alta vigila también el límite de tokens por minuto: el `total_tokens` que registras en el paso 2 te dice cuánto consume cada imagen. El nodo OpenAI no tiene esta opción; si lo usas en lotes, intercala **Loop Over Items** y **Wait**.

El **Timeout** de HTTP Request (en milisegundos) solo cubre lo que tarda el servidor en empezar a responder. OpenAI indica que un prompt complejo puede tardar hasta unos 2 minutos, así que un valor como `180000` (3 minutos) deja margen. La documentación de n8n no indica el valor por defecto; ponlo tú de forma explícita.

Un timeout no demuestra que no se haya generado nada. Algunos proveedores documentan que cortar la conexión en el cliente no cancela la generación y la imagen se cobra al terminar. Antes de reintentar una petición que expiró, revisa el registro de uso o de llamadas del proveedor para no pagar dos veces.

Para decidir qué errores reintentar, activa en Options → Response **Never Error** e **Include Response Headers and Status**, y pon detrás un nodo **If** o **Switch** sobre `statusCode`:

- **429 por límite de velocidad y errores 5xx**: reintenta tras un **Wait**, alargando la espera en cada intento.
- **Cuota agotada**: no reintentes; avisa y detén el flujo.
- **`image_generation_user_error`**, por ejemplo `error.code` = `moderation_blocked`: tampoco reintentes sin cambiar el prompt o las imágenes, porque fallará igual. El campo opcional `moderation_details.moderation_stage` indica si el bloqueo vino de la entrada (`input`) o de la imagen generada (`output`).

## Diagnóstico: de la petición al archivo entregado

Recorre la cadena en orden; el primer punto que falle es donde está el problema.

| Síntoma | Dónde mirar | Causa habitual | Qué hacer |
|---|---|---|---|
| 401 o 403 | Credencial | Clave errónea u organización sin verificar | Revisa la clave y la verificación de la organización |
| Modelo no encontrado | Campo Model | La lista viene de `/models` de la Base URL | Modo ID y el identificador completo |
| 400 por parámetros | Cuerpo de la petición | Tamaño no múltiplo de 16, `response_format`, Input Fidelity | Corrige el campo que nombra el error |
| Nodo en verde pero sin archivo | Pestaña Binary de la salida | Base64 Input Field mal escrito o rutas sin `body.` | Revisa el nombre del campo y las opciones de respuesta |
| El archivo no se abre | Inicio del Base64 | Prefijo `data:image/…`, relleno o formato distinto de la extensión | Nodo Code de limpieza; MIME Type acorde a `output_format` |
| Consumo a cero | Nodo usado y orden | Nodo OpenAI o registro después de Convert to File | HTTP Request y guardar `usage` antes de convertir |
| 429 en lotes | Batching | Intervalo inferior a 60.000 ÷ IPM | Sube Batch Interval |
| Timeout | Opciones de HTTP Request | Imagen grande o prompt complejo | Sube Timeout; revisa el registro antes de repetir |
| El destino no recibe nada | Nodo de destino | Lee un campo binario distinto de `data` | Iguala el nombre del campo binario |

## Con un proveedor compatible con OpenAI

Para usar otro proveedor con la misma interfaz basta cambiar la **Base URL** de la credencial OpenAI y poner su clave. La lista de modelos mostrará lo que devuelva el `/models` de ese proveedor; si no aparece el que buscas, usa el modo ID. Antes de elegir entre nodo y HTTP Request, comprueba con una petición de prueba qué forma de respuesta devuelve.

LaoZhang API es un ejemplo. Su Base URL es `https://api.laozhang.ai/v1` y, a 25 de septiembre de 2026, ofrece tres vías para GPT Image 2.5:

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

- **Reenvío oficial**: conserva los IDs `gpt-image-2.5-flare` y `gpt-image-2.5-sunburst`, factura por tokens y el grupo `Sora2Official` aplica los mismos precios unitarios que OpenAI (el grupo empresarial suma un 20 %). Admite varias imágenes de referencia y máscara con las mismas reglas que OpenAI.
- **Modelos `-vip`** (`gpt-image-2.5-flare-vip`, `gpt-image-2.5-sunburst-vip`): USD 0,03 por llamada, con calidades de `low` a `max` y tamaños libres, pero sin máscara. Estuvieron suspendidos del 16 al 22 de septiembre de 2026 y ya vuelven a estar disponibles.
- **`gpt-image-2.5-web`**: USD 0,03 por llamada, sin posibilidad de elegir entre Flare y Sunburst.

Según su documentación, la respuesta puede traer Base64 con prefijo `data:image/png;base64,`, sin el `=` final o una `url` que caduca, así que conviene la ruta de HTTP Request con el nodo Code del paso 2. El reenvío oficial tampoco acepta `response_format`. Y un timeout en el cliente no cancela la generación: consulta el registro de llamadas antes de reintentar. Los detalles están en la [documentación de GPT Image 2.5 de LaoZhang](https://docs.laozhang.ai/api-capabilities/gpt-image-2-5).

## Preguntas frecuentes

### ¿Qué versión de n8n necesito para GPT Image 2.5?

Lo que cuenta es la versión del nodo OpenAI, no la de n8n: Generate an Image necesita la 2.2 o posterior para escribir cualquier ID de modelo, y Edit Image la 2.3. Hay casos documentados funcionando en n8n 2.38.6 con el nodo en 2.3. HTTP Request no depende de ninguna versión concreta, porque tú escribes la petición completa.

### ¿Puedo usar GPT Image 2.5 con la Responses API desde n8n?

No como modelo principal: OpenAI indica que Flare y Sunburst no se admiten directamente en `v1/responses`. Allí se usan como modelo de la herramienta de generación de imágenes, con otro modelo al frente de la conversación, y ese modelo también consume tokens. Para un flujo que solo genera o edita imágenes, la API de imágenes (`/v1/images/generations` y `/v1/images/edits`) es más directa.

### ¿Por qué salen imágenes con ruido o grano?

No es cosa de n8n: tanto el nodo OpenAI como Convert to File se limitan a decodificar el Base64 que envía la API, sin recomprimir la imagen. Qué revisar en la petición lo tienes en [Ruido, grano o cuadrícula en GPT Image 2.5: qué revisar y cambiar](https://blog.laozhang.ai/es/posts/gpt-image-2-5-noise-grainy). Si trabajas con ComfyUI en lugar de n8n, el nodo oficial funciona de otra manera: [GPT Image 2.5 en ComfyUI: cuenta, créditos y coste por imagen](https://blog.laozhang.ai/es/posts/gpt-image-2-5-comfyui).

## Fuentes

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

- [verificación de la organización de la API](https://help.openai.com/en/articles/10910291-api-organization-verification) (help.openai.com)
- [#38482](https://github.com/n8n-io/n8n/issues/38482) (github.com)