Cómo usar Apiframe en n8n (guía paso a paso)

En esta guía aprenderás a conectar Apiframe con n8n para que puedas generar imágenes (o videos, música, etc.) con IA desde cualquier workflow.

Veremos:

1. Qué vamos a construir
2. Requisitos previos
3. Crear las credenciales de Apiframe en n8n
4. Workflow 1 - Generación sencilla de imágenes usando /imagine
5. Workflow 2 - Consultar resultados periódicamente con /fetch
6. Workflow 3 - Recomendado: Usar webhooks para obtener resultados en tiempo real
7. Ampliar este patrón a otros endpoints de Apiframe

Todos los ejemplos usarán el endpoint /imagine de Midjourney, pero el mismo patrón funciona para la mayoría de los demás endpoints y modelos.

I. Qué vamos a construir

Crearemos dos pequeñas integraciones en n8n:

1. Generar una imagen bajo demanda
   • Disparador: Manual, Webhook, Google Sheet, cualquiera
   • HTTP Request: POST https://api.apiframe.pro/imagine
   • Recibir un task_id que puedes almacenar o registrar
2. Obtener las imágenes finales automáticamente
   • Haciendo polling a Apiframe con /fetch hasta que la tarea esté completa
   • O (recomendado) dejar que Apiframe llame a un Webhook de n8n cuando la tarea esté completa

Una vez que las URLs de las imágenes lleguen a n8n, puedes hacer cualquier cosa: enviarlas a Slack, guardarlas en Airtable, Google Drive, etc.

II. Requisitos previos

Vas a necesitar:

• Una cuenta de Apiframe y una clave de API. Puedes obtenerla desde tu panel de control de Apiframe (o Haz clic aquí). Esta clave de API se utilizará para autenticar nuestras solicitudes mediante la cabecera Authorization .

• Una instancia de n8n (autohospedada o en la nube)
• Familiaridad básica con los nodos de n8n (HTTP Request, Webhook, Set, IF, etc.). El nodo HTTP Request es la forma genérica de llamar a cualquier API REST en n8n.

III. Crear credenciales de Apiframe en n8n

Configuraremos las credenciales una sola vez y luego las reutilizaremos en todos los nodos HTTP Request.

• Paso 1: En n8n, ve a Credentials → Create credential.

• Paso 2: Elige Header Auth (o "HTTP Header Auth", "API Key in Header" según tu versión)

• Paso 3: Configura:
  • Nombre de la cabecera: Authorization
  • Valor: tu clave de API de Apiframe (exactamente como aparece en tu panel de control)

• Paso 4: Ponle un nombre como Apiframe Auth y guárdala

Apiframe espera:

Authorization: YOUR_API_KEY
Content-Type: application/json

IV. Flujo de trabajo 1 - Generación básica de imágenes con /imagine

Crearemos un flujo de trabajo sencillo:

1. Crea el flujo de trabajo

1. En n8n, crea un New workflow.
2. Añade un Disparador manual node.

2. Añadir un nodo "Set" para el prompt

1. Añade un Set node después del Disparador manual.
2. En Values → Add Field → String:
   • Name: prompt
   • Value: algo como a cinematic photo of a cyberpunk city at night, ultra detailed, 4k
3. (Opcional) Añade otro campo de tipo string:
   • Name: aspect_ratio
   • Value: 3:2

Ahora el JSON de salida del nodo Set se ve aproximadamente así:

{
  "prompt": "a cinematic photo of a cyberpunk city at night, ultra detailed, 4k",
  "aspect_ratio": "3:2"
}

3. Añadir el nodo HTTP Request para /imagine

1. Añade un HTTP Request node después del nodo Set.
2. Configura:
   • Method: POST
   • URL: https://api.apiframe.pro/imagine
   • Para la autenticación, elige "Generic Credential type", luego "Header Auth" y después las credenciales “Apiframe Auth” que creaste antes.
   • Para el cuerpo, activa "Send body" y añadamos nuestros campos: prompt, aspect_ratio y, opcionalmente, webhook_url para más adelante.

Cuando ejecutes este nodo, Apiframe devuelve algo como:

{
  "task_id": "29e983ca-7e86-4017-a9e3-ef6fe9cd5f2a"
}

Esto significa que la tarea está en cola/en procesamiento. Las imágenes se generan de forma asíncrona; no obtienes las URLs finales desde /imagine directamente.

Ahora puedes:

• Registrar el task_id
• Guárdalo en una base de datos / Google Sheet
• Pásalo a un flujo de trabajo de “Fetch”

V. Flujo de trabajo 2 - Sondear Apiframe con /fetch

Ahora obtengamos las URLs reales de las imágenes usando el endpoint /fetch.

Apiframe expone un endpoint POST https://api.apiframe.pro/fetch que recibe un task_id y devuelve o bien el resultado final o una respuesta con status: "processing".

Haremos un flujo mínimo de “Esperar y luego Fetch”.

1. Añadir un nodo Wait

Después del nodo HTTP Request de /imagine:

1. Añade un nodo Wait.
2. Configúralo para que espere, por ejemplo, 2–3 segundos.

Esto le da a Apiframe tiempo para terminar la generación. El tiempo de generación depende de la complejidad de la tarea y de la carga del sistema.

2. Añadir el nodo HTTP Request para /fetch

Añade otro nodo HTTP Request después del nodo Wait:

• Método: POST
• URL: https://api.apiframe.pro/fetch
• Para la autenticación, elige el "Generic Credential type", luego "Header Auth" y después “Apiframe Auth”, igual que antes.
• Para el cuerpo, activa "Send body" y vamos a añadir nuestro task_id field

En proceso (tarea aún en ejecución):

{
  "task_id": "29e983ca-7e86-4017-a9e3-ef6fe9cd5f2a",
  "task_type": "imagine",
  "status": "processing",
  "percentage": "40"
}

Completado (tarea terminada, URLs de las imágenes listas):

{
  "task_id": "29e983ca-7e86-4017-a9e3-ef6fe9cd5f2a",
  "task_type": "imagine",
  "original_image_url": "https://.../grid.png",
  "image_urls": [
    "https://.../image1.png",
    "https://.../image2.png",
    "https://.../image3.png",
    "https://.../image4.png"
  ]
}

3. Manejar el “still processing”

Para una configuración rápida de desarrollo, puedes:

• Simplemente esperar más tiempo y hacer una sola consulta.
• O añadir un nodo IF sencillo después del Fetch:
  • Condición: status es igual a "processing"
  • Si es “true”: ramifica a otro Wait + Fetch
  • Si es “false”: continúa con tu lógica final (Slack, Airtable, etc.)

En producción, Apiframe recomienda usar webhooks en lugar de polling para evitar solicitudes innecesarias y recibir actualizaciones al instante.

Hagamos eso ahora.

VI. Flujo de trabajo 3 - Resultados basados en webhook (recomendado)

Esta es la arquitectura limpia y “en tiempo real”:

• Flujo de trabajo A: Enviar solicitud de generación (con webhook_url y webhook_secret)
• Flujo de trabajo B: Recibir webhook desde Apiframe cuando la generación haya terminado

1. Crear el Flujo de trabajo B - El receptor del webhook

1. Crea un Nuevo flujo de trabajo en n8n y ponle el nombre Apiframe – Imagen completada.
2. Añade un Webhook node. Configura el nodo Webhook:
   • Método HTTP: POST
   • Ruta (Path): algo como apiframe/midjourney-completed
   • Modo de respuesta:
     • Por ejemplo, When Last Node Finishes (para que puedas devolver datos si lo deseas).

Copia la Production URL – esto es lo que configuraremos como webhook_url en Apiframe.

2. Asegura el webhook con "webhook_secret"

Apiframe te permite pasar un webhook_secret en la solicitud a /imagine; lo enviará de vuelta como cabecera x-webhook-secret en las llamadas al webhook.

1. Añade un nodo IF después del nodo Webhook.
2. En el nodo IF, comprueba:
   • Lado izquierdo: una expresión como ={{ $json["headers"]["x-webhook-secret"] }}
   • Condición: equals
   • Lado derecho: tu secreto, p. ej. my-super-secret
3. Si el secreto no coincide, ve a una rama que simplemente termine (o registre el intento).

Esto garantiza que solo se procesen los webhooks de Apiframe.

3. Acceder a las URLs de las imágenes en el payload del webhook

El cuerpo del webhook tendrá el mismo formato que el payload de “completed” que vimos antes:

{
  "task_id": "29e983ca-7e86-4017-a9e3-ef6fe9cd5f2a",
  "task_type": "imagine",
  "original_image_url": "https://.../grid.png",
  "image_urls": [
    "https://.../image1.png",
    "https://.../image2.png",
    "https://.../image3.png",
    "https://.../image4.png"
  ]
}

Puedes acceder a las URLs de las imágenes y luego pasarlas a:

• Nodo de Slack (enviar un mensaje con la URL)
• Airtable / Notion (almacenar la URL)
• HTTP Request (enviar a tu backend de la aplicación)

4. Actualizar el Workflow A para usar el webhook

Vuelve al Workflow A (el que llama a /imagine) y edita el cuerpo del nodo HTTP Request para incluir:

• webhook_url
• webhook_secret

Ejemplo de cuerpo JSON en el nodo HTTP Request:

{
  "prompt": "a cinematic photo of a cyberpunk city at night, ultra detailed, 4k",
  "aspect_ratio": "3:2",
  "webhook_url": "https://your-n8n-domain.com/webhook/apiframe/midjourney-completed",
  "webhook_secret": "my-super-secret"
}

Ahora el flujo es:

1. Workflow A → /imagine con webhook_url + webhook_secret
2. Apiframe genera la imagen en segundo plano
3. Cuando termina, Apiframe llama a tu Webhook (Workflow B) con las URLs finales
4. Workflow B las procesa y las envía a donde tú quieras

Sin polling, sin peticiones HTTP extra: solo basado en eventos.

VII. Extender este patrón a otros endpoints de Apiframe

La parte buena: una vez que has conectado n8n → Apiframe una vez, puedes reutilizar el mismo patrón para todo.

Algunas ideas:

• Variations: cambia la URL a https://api.apiframe.pro/variations y envía el task_id + nuevo prompt.
• Upscales: misma autenticación, endpoint/body diferente.
• Faceswap: envía dos URLs de imagen (origen y destino) al endpoint faceswap .
• Describe: crea un flujo de trabajo en n8n donde introduces una URL de imagen y Apiframe devuelve un prompt para ella.
• Otros medios: Flux, Ideogram, Luma, Suno, etc. siguen el mismo patrón REST: POST con JSON, incluye webhook_url + webhook_secret si quieres usar webhooks.

Cada uno de estos se convierte simplemente en otro nodo HTTP Request (o dos, si también usas /fetch) usando las mismas credenciales de “Apiframe Auth”.

VIII. Cierre

Ahora tienes:

• Un flujo de trabajo básico de /imagine para disparar Midjourney vía Apiframe en n8n
• Una configuración de sondeo (polling) usando /fetch para experimentos rápidos
• Una arquitectura basada en webhooks para pipelines en tiempo real y de nivel producción