Guide étape par étape : utiliser Apiframe avec n8n

Dans ce guide, vous apprendrez comment connecter Apiframe à n8n afin de générer des images IA (ou des vidéos, de la musique, etc.) depuis n’importe quel workflow.

Nous allons voir :

1. Ce que nous allons construire
2. Prérequis
3. Création d’identifiants Apiframe dans n8n
4. Workflow 1 - Génération d’image simple avec /imagine
5. Workflow 2 - Récupération des résultats avec /fetch
6. Workflow 3 - Recommandé : Utiliser des webhooks pour des résultats en temps réel
7. Extension de ce modèle à d’autres endpoints Apiframe

Tous les exemples utiliseront l’endpoint Midjourney /imagine mais le même schéma fonctionne pour la plupart des autres endpoints et modèles.

I. Ce que nous allons construire

Nous allons créer deux petites intégrations n8n :

1. Générer une image à la demande
   • Déclencheur : Manuel, Webhook, Google Sheet, n’importe quoi
   • Requête HTTP: POST https://api.apiframe.pro/imagine
   • Récupérer un task_id que vous pouvez stocker ou journaliser
2. Récupérer automatiquement les images finales
   • En interrogeant Apiframe avec /fetch jusqu’à ce que la tâche soit terminée
   • Ou (recommandé) laisser Apiframe appeler un Webhook n8n lorsque la tâche est terminée

Une fois que les URL des images arrivent dans n8n, vous pouvez tout faire : les envoyer sur Slack, les stocker dans Airtable, Google Drive, etc.

II. Prérequis

Vous aurez besoin de :

• Un compte Apiframe et une clé API. Vous pouvez la récupérer depuis votre tableau de bord Apiframe (ou cliquez ici). Cette clé API sera utilisée pour authentifier nos requêtes via l’en‑tête Authorization .

• Une instance n8n (auto‑hébergée ou cloud)
• Une connaissance de base des nœuds n8n (HTTP Request, Webhook, Set, IF, etc.). Le nœud HTTP Request est la façon générique d’appeler n’importe quelle API REST dans n8n.

III. Créer des identifiants Apiframe dans n8n

Nous allons configurer les identifiants une seule fois, puis les réutiliser dans tous les nœuds HTTP Request.

• Étape 1 : Dans n8n, allez dans Credentials → Create credential.

• Étape 2 : Choisissez Header Auth (ou « HTTP Header Auth », « API Key in Header » selon votre version)

• Étape 3 : Configurez :
  • Nom de l’en‑tête : Authorization
  • Valeur : votre clé API Apiframe (exactement comme indiqué dans votre tableau de bord)

• Étape 4 : Donnez‑lui un nom comme Apiframe Auth et enregistrez

Apiframe s’attend à :

Authorization: YOUR_API_KEY
Content-Type: application/json

IV. Workflow 1 – Génération d’image basique avec /imagine

Nous allons construire un workflow simple :

1. Créer le workflow

1. Dans n8n, créez un New workflow.
2. Ajoutez un Déclencheur manuel node.

2. Ajouter un nœud « Set » pour le prompt

1. Ajoutez un Set node après le déclencheur manuel.
2. Dans Values → Add Field → String:
   • Name : prompt
   • Value : par exemple une photo cinématographique d’une ville cyberpunk de nuit, ultra détaillée, 4K
3. (Facultatif) Ajoutez un autre champ de type string :
   • Name : aspect_ratio
   • Value : 3:2

La sortie JSON du nœud Set ressemble maintenant à ceci :

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

3. Ajouter le nœud HTTP Request pour /imagine

1. Ajoutez un HTTP Request node après le nœud Set.
2. Configurez :
   • Method : POST
   • URL : https://api.apiframe.pro/imagine
   • Pour l’authentification, choisissez « Generic Credential type », puis « Header Auth », puis les identifiants « Apiframe Auth » que vous avez créés plus tôt.
   • Pour le corps, activez « Send body », puis ajoutons nos champs : prompt, aspect_ratio et, éventuellement, webhook_url pour plus tard.

Lorsque vous exécutez ce nœud, Apiframe renvoie quelque chose comme :

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

Cela signifie que la tâche est en file d’attente/en cours de traitement. Les images sont générées de façon asynchrone ; vous n’obtenez pas les URL finales depuis /imagine lui‑même.

Vous pouvez maintenant :

• Consigner le task_id
• Stockez-le dans une base de données / une feuille Google Sheets
• Transmettez-le à un workflow « Fetch »

V. Workflow 2 - Interroger Apiframe avec /fetch

Récupérons maintenant les véritables URLs d’images en utilisant le point de terminaison /fetch.

Apiframe expose un point de terminaison POST https://api.apiframe.pro/fetch qui prend un task_id et renvoie soit le résultat final soit une réponse avec status: "processing".

Nous allons mettre en place un flux minimal « Attendre puis Fetch ».

1. Ajouter un nœud Wait

Après le nœud de requête HTTP /imagine :

1. Ajoutez un nœud Wait.
2. Configurez-le pour attendre, par exemple, 2–3 secondes.

Cela donne à Apiframe le temps de terminer la génération. Le temps de génération dépend de la complexité de la tâche et de la charge du système.

2. Ajouter le nœud de requête HTTP /fetch

Ajoutez un autre nœud HTTP Request après le nœud Wait :

• Méthode : POST
• URL : https://api.apiframe.pro/fetch
• Pour l’authentification, choisissez « Generic Credential type », puis « Header Auth », puis « Apiframe Auth », comme précédemment.
• Pour le corps, activez « Send body », et ajoutons notre task_id champ

En cours de traitement (tâche encore en cours) :

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

Terminé (tâche finie, URLs d’images prêtes) :

{
  "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. Gérer le « still processing »

Pour une config de dev rapide, vous pouvez :

• Simplement attendre plus longtemps puis récupérer une seule fois.
• Ou ajouter un simple nœud IF après le Fetch :
  • Condition : status est égal à "processing"
  • Si « true » : bifurquer vers un autre Wait + Fetch
  • Si « false » : continuer avec votre logique finale (Slack, Airtable, etc.)

En production, Apiframe recommande d’utiliser des webhooks au lieu du polling pour éviter les requêtes inutiles et recevoir des mises à jour instantanées.

Faisons cela maintenant.

VI. Workflow 3 - Résultats basés sur webhook (recommandé)

Voici l’architecture « temps réel » propre :

• Workflow A : Envoyer la requête de génération (avec webhook_url et webhook_secret)
• Workflow B : Recevoir le webhook d’Apiframe quand la génération est terminée

1. Créer le Workflow B - Le récepteur de webhook

1. Créez un Nouveau workflow dans n8n et nommez-le Apiframe – Image terminée.
2. Ajoutez un nœud Webhook . Configurez le nœud Webhook :
   • Méthode HTTP : POST
   • Chemin : quelque chose comme apiframe/midjourney-completed
   • Mode de réponse :
     • Par exemple, When Last Node Finishes (pour pouvoir renvoyer des données si vous le souhaitez).

Copiez l’URL de production – c’est ce que nous allons définir comme webhook_url dans Apiframe.

2. Sécuriser le webhook avec « webhook_secret »

Apiframe vous permet de passer un webhook_secret dans la requête /imagine ; il vous le renverra dans l’en-tête x-webhook-secret lors des appels webhook.

1. Ajoutez un nœud IF après le nœud Webhook.
2. Dans le nœud IF, vérifiez :
   • Côté gauche : une expression comme ={{ $json["headers"]["x-webhook-secret"] }}
   • Condition : equals
   • Côté droit : votre secret, par exemple my-super-secret
3. Si le secret ne correspond pas, dirigez le flux vers une branche qui se contente de s’arrêter (ou qui journalise la tentative).

Cela garantit que seuls les webhooks d’Apiframe sont traités.

3. Accéder aux URL des images dans la charge utile du webhook

Le corps du webhook aura le même format que la charge utile « completed » montrée plus tôt :

{
  "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"
  ]
}

Vous pouvez accéder aux URL des images, puis les transmettre à :

• Nœud Slack (envoyer un message avec l’URL)
• Airtable / Notion (stocker l’URL)
• Requête HTTP (envoyer vers le backend de votre application)

4. Mettre à jour le Workflow A pour utiliser le webhook

Revenez au Workflow A (celui qui appelle /imagine) et modifiez le corps du nœud Requête HTTP pour inclure :

• webhook_url
• webhook_secret

Exemple de corps JSON dans le nœud Requête HTTP :

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

Le flux devient alors :

1. Workflow A → /imagine avec webhook_url + webhook_secret
2. Apiframe génère l’image en arrière-plan
3. Une fois terminé, Apiframe appelle votre Webhook (Workflow B) avec les URL finales
4. Le Workflow B les traite et les envoie où vous le souhaitez

Pas de polling, pas de requêtes HTTP supplémentaires – uniquement piloté par les événements.

VII. Étendre ce modèle à d’autres endpoints Apiframe

L’avantage, c’est que une fois que vous avez câblé n8n → Apiframe une première fois, vous pouvez réutiliser le même schéma pour tout le reste.

Quelques idées :

• Variations: remplacez l’URL par https://api.apiframe.pro/variations et envoyez le task_id + nouveau prompt.
• Upscales: même authentification, endpoint/corps différent.
• Faceswap: envoyez deux URLs d’images (source et cible) vers l’endpoint faceswap.
• Describe: créez un workflow n8n où vous déposez une URL d’image et Apiframe renvoie un prompt correspondant.
• Autres médias: Flux, Ideogram, Luma, Suno, etc. suivent tous le même schéma REST : POST avec du JSON, incluez webhook_url + webhook_secret si vous voulez des webhooks.

Chacun de ces cas devient simplement un autre nœud HTTP Request (ou deux, si vous utilisez aussi /fetch) en utilisant les mêmes identifiants « Apiframe Auth ».

VIII. Récapitulatif

Vous avez maintenant :

• Un workflow de base /imagine pour déclencher Midjourney via Apiframe dans n8n
• Une configuration de polling utilisant /fetch pour des expérimentations rapides
• Une architecture basée sur des webhooks pour des pipelines temps réel, prêts pour la production