Una configuración práctica para generar imágenes desde n8n con una API gratuita. Crea el token, guárdalo como credencial, construye el POST, el bucle de sondeo con Wait y Switch, guarda el archivo y mantén los lotes por debajo del límite de cinco trabajos para que las ejecuciones masivas terminen sin errores.
Puedes conectar una API gratuita de generación de imágenes a n8n en unos veinte minutos, y lo que más complica las cosas no es la petición. Es la espera. Los trabajos de imagen en la API de PicassoIA son asíncronos, así que un solo nodo HTTP Request te devuelve un ID de trabajo en lugar de una imagen, y todo lo demás depende de lo bien que consultes, reintentes y guardes el resultado. Este recorrido construye el bucle completo: un disparador, un prompt, un POST que crea la predicción, un par Wait e IF que consulta hasta que el trabajo termina, y un paso de descarga que convierte la salida en un archivo real dentro de tu flujo de trabajo.
Si ya has usado la API de Replicate, te resultará familiar. Si no, no pasa nada: cada llamada de este artículo se muestra con la URL, el encabezado y el cuerpo exactos que necesitas, además de las expresiones de n8n que unen los nodos.
PicassoIA expone una API para desarrolladores que se comporta como la API de predicciones de Replicate. Creas un trabajo, lo consultas y lees la salida. No hay streaming ni callback de webhook que configurar, lo cual es una buena noticia para n8n, porque el sondeo es algo que el editor hace muy bien.
La URL base es https://api.picassoia.com/v1, y cada petición lleva un token de portador que empieza por pia_sk_. Cuatro endpoints cubren todo el ciclo de vida de un trabajo:
| Acción | Método y ruta | Para qué se usa |
|---|---|---|
| Crear un trabajo | POST /v1/models/{owner}/{name}/predictions | Iniciar una generación |
| Consultar un trabajo | GET /v1/predictions/{id} | Consultar el estado y leer la salida |
| Cancelar un trabajo | POST /v1/predictions/{id}/cancel | Detener un trabajo que ya no necesitas |
| Listar trabajos | GET /v1/predictions | Revisar las ejecuciones recientes |
Para imágenes fijas importan dos modelos. picassoia/picassoia-image es el modelo de texto a imagen, documentado en la página de PicassoIA Image. No tiene límite, admite siete relaciones de aspecto, acepta una semilla y genera JPG, PNG o WebP. picassoia/picassoia-image-editor-pro se encarga de editar imágenes existentes y está en PicassoIA Image Editor Pro. Detrás del mismo estilo de endpoints hay dos modelos de video, que resultan útiles cuando tu flujo de imágenes ya es estable y quieres movimiento desde el mismo disparador.
Antes de diseñar nada, apunta estas cifras en una nota adhesiva:
El límite de concurrencia condiciona tu flujo más que cualquier otra cosa. Volveremos a él en la sección de fallos, porque una hoja de cálculo con 200 filas superará los cinco trabajos en unos dos segundos si la dejas.
💡 Comprueba tu plan antes de prometer "gratis" a un cliente. Las páginas de la API dicen que las predicciones son gratuitas actualmente y no usan créditos, pero la documentación también menciona el plan Infinite para el acceso a la API, y la página de precios incluye el acceso a la API en varios niveles. Esos datos no encajan del todo, así que confirma qué permite tu cuenta antes de construir un entregable para un cliente sobre ella.
Prueba primero tu prompt en el navegador. No cuesta nada, tarda diez segundos y te dice si la redacción es correcta antes de pasar una tarde depurando nodos.
Los campos del navegador se corresponden uno a uno con el cuerpo de la petición, así que no se pierde nada en la traducción:
| Campo | Valor por defecto | Notas |
|---|---|---|
prompt | ninguno (obligatorio) | Descripción en lenguaje natural, de hasta 4.000 caracteres |
aspect_ratio | 1:1 | También 16:9, 9:16, 4:3, 3:4, 3:2 y 2:3 |
seed | aleatoria | Entero; defínelo para obtener resultados repetibles |
output_format | jpg | jpg, png o webp |
output_quality | 80 | De 0 a 100, se aplica solo a JPG y WebP |
num_outputs | 1 | Una o dos imágenes por llamada |
💡 Escribir cuarenta prompts a mano se hace pesado enseguida. Redacta variaciones con un modelo de chat como GPT 5 Mini o Claude 4.5 Haiku, guarda las mejores y pégalas en la hoja de cálculo que lee tu flujo.
La mayoría de las configuraciones fallidas fracasan aquí, no en el flujo. Dedica dos minutos a esto y no tendrás que volver a pensar en la autenticación.
Abre la página de la API en tu cuenta de PicassoIA y crea un token. Empezará por pia_sk_. Cópialo de inmediato en un gestor de contraseñas. Como una cuenta admite como máximo dos tokens, usa uno para el n8n de producción y guarda el segundo para pruebas locales, así puedes revocar cualquiera de los dos sin romper el otro.
Pruébalo desde la terminal antes de meter n8n en el proceso:
curl -s -X POST https://api.picassoia.com/v1/models/picassoia/picassoia-image/predictions \
-H "Authorization: Bearer $PICASSOIA_TOKEN" \
-H "Content-Type: application/json" \
-d '{"input":{"prompt":"Ceramic mug on linen, window light from the left, 50mm","aspect_ratio":"16:9"}}'
Una respuesta JSON con un id significa que el token funciona. Consúltalo con GET https://api.picassoia.com/v1/predictions/<id> hasta que el estado indique succeeded, y luego fíjate en la estructura del campo output. La necesitarás enseguida.
En n8n, abre Credentials, crea una nueva credencial Header Auth y rellénala así:
AuthorizationBearer pia_sk_ seguido de tu token, con un solo espacio después de "Bearer"PicassoIA APINunca pegues el token en un nodo Set ni directamente en un campo de HTTP Request. Acaba en los registros de ejecución y en cualquier flujo que exportes o compartas. Una credencial guardada queda fuera de ambos. En una instancia autoalojada también puedes inyectarlo mediante una variable de entorno, pero el almacén de credenciales es más sencillo y basta para la mayoría de los equipos.
Esta es la estructura completa. Ocho nodos y un solo bucle:
| # | Nodo | Función |
|---|---|---|
| 1 | Schedule Trigger o Webhook | Inicia la ejecución |
| 2 | Edit Fields (Set) | Guarda el prompt, la relación de aspecto y el formato |
| 3 | HTTP Request (POST) | Crea la predicción |
| 4 | Wait | Hace una pausa de unos segundos |
| 5 | HTTP Request (GET) | Lee el estado del trabajo |
| 6 | Switch o IF | Enruta según succeeded, failed o "sigue en curso" |
| 7 | HTTP Request (GET, archivo) | Descarga la imagen terminada |
| 8 | Drive, S3 o Write Files | La guarda donde la necesites |
Empieza con un Schedule Trigger si el trabajo es rutinario, o con un Webhook si otra herramienta debe poder pedir imágenes. A continuación, añade un nodo Edit Fields que defina tres campos de texto: prompt, aspect_ratio y output_format. Si los tienes en un solo nodo, cambias un ajuste una vez y no en cinco sitios.
Añade un nodo HTTP Request y ponle el nombre Create prediction. Define el método como POST y la URL como https://api.picassoia.com/v1/models/picassoia/picassoia-image/predictions. En la autenticación elige Generic Credential Type, después Header Auth y, por último, tu credencial PicassoIA API. Activa Send Body, elige JSON y usa este cuerpo:
{
"input": {
"prompt": "{{ $json.prompt }}",
"aspect_ratio": "{{ $json.aspect_ratio }}",
"output_format": "{{ $json.output_format }}",
"num_outputs": 1
}
}
Si tus prompts pueden contener comillas o saltos de línea, construye el cuerpo como una expresión: {{ JSON.stringify({ input: { prompt: $json.prompt, aspect_ratio: $json.aspect_ratio, output_format: $json.output_format, num_outputs: 1 } }) }}. Ese cambio evita el clásico error de "invalid JSON" con prompts como a sign that says "OPEN".
La respuesta incluye el ID del trabajo id. Es el único valor que el resto del flujo necesita de verdad.
Añade un nodo Wait configurado para reanudar tras un intervalo de tiempo, cinco segundos para empezar. Después, un segundo nodo HTTP Request llamado Check prediction con el método GET y esta URL:
https://api.picassoia.com/v1/predictions/{{ $('Create prediction').item.json.id }}
Conecta el resultado a un nodo Switch que lea {{ $json.status }} y envíe succeeded al paso de descarga, failed a la rama de errores y todo lo demás de vuelta al nodo Wait. Esa conexión hacia atrás es tu bucle.
Dos hábitos mantienen el bucle a salvo. Primero, cuenta los intentos. Un nodo Code pequeño que incremente un campo attempts y se detenga en 30 te salvará de un trabajo que nunca termina. Segundo, no consultes más deprisa de lo que tarda el trabajo. Las imágenes terminan rápido, así que un intervalo de tres a cinco segundos basta, y martillear el endpoint de estado cada medio segundo solo gasta ejecuciones.
Ahora, la salida. Añade un tercer nodo HTTP Request, método GET, con la URL apuntando a la dirección de la imagen del trabajo terminado. Para una sola salida suele ser {{ $json.output[0] }}, pero ejecuta el bucle una vez con un prompt de prueba y revisa la estructura en el panel de ejecución antes de fiarte de esa expresión. En las Options del nodo, añade Response, define Response Format como File y deja la propiedad binaria como data.
A partir de aquí, la imagen es un archivo binario normal de n8n. Envíalo a Google Drive, S3, un endpoint de medios de WordPress, Slack o una carpeta local. Guarda el archivo en sí y no el enlace al resultado, para que tu archivo nunca dependa de que una URL siga activa.
Un flujo que funciona una vez es una demo. Un flujo que aguanta 200 filas un lunes por la mañana es una herramienta. La diferencia está sobre todo en esta sección.
Aquí está la trampa. La llamada POST responde en una fracción de segundo, así que un nodo HTTP Request alimentado con 50 filas iniciará 50 trabajos casi al instante, mucho antes de que termine el primero. Solo pueden ejecutarse cinco a la vez, y el resto se rechazará o se pondrá en cola según la respuesta de la API.
La solución es un nodo Loop Over Items con el tamaño de lote en 5, colocado antes del paso de creación. Cada lote crea cinco trabajos, los consulta hasta que terminan los cinco, guarda los archivos y solo entonces vuelve a empezar con los cinco siguientes. Recuerda que el límite se comparte en toda tu cuenta, incluidas las conexiones MCP. Si un compañero está generando imágenes al mismo tiempo a través de un asistente conectado, compartes las mismas cinco plazas.
Un estado failed no siempre es culpa tuya. Envíalo a un Wait corto (diez segundos bastan) y luego manda el mismo prompt una vez más. Si el segundo intento también falla, deja de reintentar y avisa a alguien con el nodo Slack, Gmail o Telegram. Reintentar sin límite solo oculta un prompt defectuoso.
Para los fallos de red normales, abre la pestaña Settings del nodo HTTP Request y activa Retry On Fail con tres intentos y una pausa de dos segundos. Así se gestionan las conexiones caídas sin tocar la lógica del bucle.
Los prompts tienen un límite de 4.000 caracteres. Si proceden de la entrada de un usuario o de un modelo de lenguaje, recórtalos en un nodo Code con $json.prompt.slice(0, 4000) antes de que lleguen a la API. El límite de 10 MB del cuerpo no te afectará en la generación de imágenes solo con texto, pero sí importa cuando empieces a enviar fotos de origen al modelo de edición.
Cuando algo falle de todos modos, esta tabla recoge los sospechosos habituales:
| Síntoma | Causa probable | Solución |
|---|---|---|
| 401 Unauthorized | Falta el prefijo Bearer o el token es incorrecto | Vuelve a introducir el valor de la credencial como Bearer pia_sk_... |
| Trabajos rechazados en ejecuciones masivas | Más de 5 predicciones a la vez | Loop Over Items con un tamaño de lote de 5 |
output[0] no está definido | La salida se lee antes de que el estado sea succeeded | Conecta al nodo de descarga solo la rama succeeded |
| El nodo de descarga devuelve JSON | Response Format se dejó en el valor por defecto | Define Response Format como File |
| Prompt rechazado | Más de 4.000 caracteres | Recorta el prompt en un nodo Code |
| El flujo nunca termina | No hay límite de intentos de consulta | Detén tras 30 consultas y avisa a alguien |
Los códigos de error exactos los devuelve la propia API, así que abre la ejecución fallida y lee el cuerpo de la respuesta antes de adivinar.
El mismo bucle sirve para trabajos muy distintos. Cambia el disparador y el destino, y mantén el centro.
Apunta un Schedule Trigger a un nodo Google Sheets que devuelva las filas marcadas como todo. Construye el prompt con el título del artículo más una línea de estilo fija: "documentary photograph, natural light, 35mm, no text". Genera en 16:9, sube la imagen a tu biblioteca de medios y escribe la URL del archivo de vuelta en la fila con el estado done. Un editor puede dejar en cola veinte títulos por la noche y encontrar veinte cabeceras esperándole por la mañana.
Una fila por producto, con columnas para el nombre del producto, el material y el escenario. Genera en 1:1, define num_outputs como 2 para elegir el encuadre que mejor quede y mantén una semilla por línea de producto para que la iluminación siga siendo coherente en todo el catálogo. Para las tomas que necesiten ajustar una foto existente en lugar de inventarla, envía esa foto por el modelo PicassoIA Image Editor Pro con un segundo nodo HTTP Request. Consulta su página de modelo para ver los campos de entrada exactos que espera.
Deja que un formulario, un comando de Slack u otro flujo llame a tu nodo Webhook con un breve encargo. Usa el nodo Respond to Webhook para responder de inmediato con "recibido" y luego ejecuta la generación en segundo plano, publicando la imagen terminada en 9:16 en el canal cuando el trabajo se complete con éxito. La gente se queda contenta porque nada se queda colgado mientras se renderiza la imagen.
En el momento de escribir esto, la API expone cuatro modelos: dos para imágenes y dos para video. Para tu flujo de trabajo en n8n, la decisión se reduce al par de imagen.
| Modelo | Ideal para | Dónde encaja en n8n |
|---|---|---|
| PicassoIA Image | Imágenes nuevas a partir de un prompt, ejecuciones ilimitadas | El nodo predeterminado Create prediction |
| PicassoIA Image Editor Pro | Cambiar o corregir una foto que ya tienes | Una segunda rama que recibe una imagen de origen |
El resto del catálogo sigue siendo útil, aunque hoy no esté disponible a través de la API. Modelos como P Image y FLUX Schnell merece la pena probarlos en el navegador para comparar estilos, y la plataforma también ofrece eliminación de fondo, escalado (aumentar la resolución) y una gran biblioteca de efectos de video desde su página de todos los modelos. Un patrón práctico: prueba un estilo en el navegador y luego reproduce en n8n el prompt y la semilla ganadores.
Ya tienes todo lo necesario para un bucle que funcione: un token guardado de forma segura, un POST que crea el trabajo, un Wait y un Switch que lo consultan, una descarga File que guarda el resultado y lotes de cinco que respetan el límite de concurrencia. La forma más rápida de comprobarlo es mantener la primera versión muy pequeña. Un nodo Edit Fields, un prompt, sin hoja de cálculo y sin Loop Over Items. Cuando esa única imagen llegue a tu carpeta, añade los lotes y la programación.
Abre PicassoIA Image en el navegador, escribe un prompt sobre algo que de verdad necesites esta semana y genéralo. Después, copia ese prompt exacto, la relación de aspecto y la semilla en el flujo de n8n de arriba. Prueba una cabecera 16:9, una miniatura de producto cuadrada y una historia vertical con el mismo prompt, y mira cuál usa tu equipo primero. Todo lo que pruebes está a un clic en Picasso IA, así que solo queda pulsar ejecutar.
Elige tu idioma
