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

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.

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 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 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; si vienes de GPT Image 2, GPT Image 2.5 frente a GPT Image 2: cuál usar y cómo migrar.

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

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:

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:

{
  "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 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:

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.

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:

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.

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

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