Connect Midjourney to Make, n8n & Zapier via API (2026)

Why No Native Midjourney Integration Exists

If you have looked for Midjourney in the Make, Zapier, or n8n app directories, you already know the answer: it is not there. Midjourney does not provide a REST API that these platforms can connect to. Every Midjourney interaction goes through Discord — which requires session management, WebSocket connections, and state tracking that standard automation platforms cannot handle natively.

The solution is to use LinkrAPI as a REST API bridge. LinkrAPI handles the Discord complexity and exposes Midjourney through a standard HTTP API. Make, n8n, and Zapier can all call HTTP APIs using their built-in modules — which means you can automate Midjourney through any of these platforms without writing a line of code.

Before starting, you need:

• A LinkrAPI account with an active hold and your Midjourney subscription connected
• Your LinkrAPI API key (format: lkr_xxxxxxxxxxxx)
• An account on whichever platform you want to use (Make, n8n, or Zapier)

Connecting Midjourney to Make.com

Make (formerly Integromat) is the most flexible of the three platforms, with excellent support for async workflows and loops.

Step 1: Create a New Scenario

In Make, create a new scenario. Choose your trigger based on your use case — common triggers include:

• New row in Google Sheets (if your prompts come from a spreadsheet)
• New item in Airtable (if you manage prompts in a database)
• HTTP Webhook (if another system sends prompts to Make)
• Schedule (if you want to run batch generation on a timer)

Step 2: Add an HTTP Make a Request Module

Add a module: HTTP → Make a request

Configure it:

• URL: https://linkrapi.com/api/v1/imagine
• Method: POST
• Headers: Add Authorization → Bearer lkr_your_api_key
• Body type: JSON
• Body content:

json
{
  "prompt": "{{your prompt variable}}"
}

Map your prompt variable from the trigger module. Run the module once to verify you get a task_id back.

Step 3: Add a Repeater + Fetch Loop

Midjourney generation is asynchronous. You need to poll for the result:

1. Add a Flow Control → Repeater module
2. Set Repeats to 20 (20 attempts)
3. Inside the repeater, add another HTTP → Make a request module:

- URL: https://linkrapi.com/api/v1/fetch/{{task_id from Step 2}} - Method: GET - Headers: same Authorization header

1. Add a Flow Control → Break module connected to the fetch module
2. In the Break's condition, set: status = completed
3. Add a Tools → Set Variable module to capture the image_url when the Break fires

Step 4: Use the Image URL

Connect whatever action you want after the Break — upload to Google Drive, update an Airtable record, post to Slack, send an email. The image_url from the fetch response is a direct CDN link to the generated image.

Estimated build time: 20-30 minutes for your first workflow.

Make.com Webhook Approach (Advanced)

For a cleaner setup without polling loops, use LinkrAPI's webhook feature:

1. In Make, create a Webhooks → Custom Webhook trigger module
2. Copy the generated webhook URL from Make
3. In your HTTP request to /v1/imagine, add webhook_url to the body:

json
{
  "prompt": "your prompt",
  "webhook_url": "https://hook.make.com/your-webhook-id"
}

1. Make will pause the scenario until LinkrAPI calls your webhook — no polling needed

This approach is cleaner but requires a paid Make plan that supports waiting webhooks in multi-step scenarios.

Connecting Midjourney to n8n

n8n is an open-source workflow automation tool. You can self-host it or use n8n Cloud. It has excellent HTTP support and is ideal for developers who want full control.

Step 1: Create a New Workflow

In n8n, create a new workflow. Add your trigger node based on your data source:

• Schedule Trigger for batch jobs
• Webhook for event-driven flows
• Airtable / Google Sheets node for data-driven prompts

Step 2: Add an HTTP Request Node (Submit)

Add an HTTP Request node.

Set:

• Method: POST
• URL: https://linkrapi.com/api/v1/imagine
• Authentication: Header Auth

- Name: Authorization - Value: Bearer lkr_your_api_key

• Body: JSON
• JSON Body:

json
{
  "prompt": "={{ $json.prompt }}"
}

The ={{ $json.prompt }} expression pulls the prompt from the previous node's output.

Step 3: Add a Wait Node

Add a Wait node set to 30 seconds. This gives Midjourney time to process before you start polling.

Step 4: Add an HTTP Request Node (Fetch)

Add another HTTP Request node:

• Method: GET
• URL: https://linkrapi.com/api/v1/fetch/={{ $node["HTTP Request"].json.task_id }}
• Same Authorization header

Step 5: Add an IF Node to Check Status

Add an IF node:

• Condition: {{ $json.status }} equals completed
• True branch: proceed to your action node
• False branch: connect back to the Wait node to create a polling loop

Add a Limit or counter to prevent infinite loops — after 20 attempts, route to an error handler.

Step 6: Process the Result

On the true branch, use the image_url from the fetch response. Common next steps:

• Airtable node: update a record with the image URL
• HTTP Request node: POST the image URL to another service
• Google Drive node: download and store the image
• Slack / Discord node: send the image to a channel

n8n Webhook Alternative:

n8n has a Respond to Webhook node that makes it perfect for webhook-based flows. Set up a workflow triggered by a webhook and configure LinkrAPI to call your n8n webhook URL when generation completes. This eliminates the polling loop entirely.

Connecting Midjourney to Zapier

Zapier has the largest app library but is less flexible than Make or n8n for multi-step async workflows. You can still connect Midjourney using the Webhooks by Zapier app.

Step 1: Create a Zap

Create a new Zap. Choose your trigger:

• New Google Sheet Row (if prompts come from a sheet)
• Webhooks by Zapier → Catch Hook (if another app sends prompts)
• Schedule by Zapier (for timed batch jobs)

Step 2: Add a Webhooks by Zapier Action (Submit)

Add an action: Webhooks by Zapier → POST

Configure:

• URL: https://linkrapi.com/api/v1/imagine
• Payload Type: JSON
• Data:

- prompt: (map from your trigger)

• Headers:

- Authorization: Bearer lkr_your_api_key

Test this step and verify you receive a task_id in the response.

Step 3: Add a Delay Step

Add a Delay by Zapier → Delay For step. Set it to 45 seconds. This gives Midjourney time to generate before fetching.

Step 4: Add a Webhooks by Zapier Action (Fetch)

Add another action: Webhooks by Zapier → GET

Configure:

• URL: https://linkrapi.com/api/v1/fetch/ + the task_id from Step 2
• Headers: same Authorization header

Step 5: Use the Result

Map the image_url from the fetch response to your final action — update a Notion page, send an email, post to Twitter, update Airtable. Zapier's app library makes the last step easy.

Zapier Limitation: Zapier does not support polling loops natively. The single-wait approach works for most prompts (which complete in 30-60 seconds), but very slow jobs in relax mode may not be ready after a 45-second wait. For high-reliability workflows with relax mode, use Make or n8n instead.

Common Use Cases for These Workflows

Content generation pipeline: Google Sheets prompt → LinkrAPI → Airtable with image URL → Webflow CMS update. Fully automated blog post image creation.

Shopify product images: New product added to Shopify → prompt built from product data → Midjourney via LinkrAPI → image uploaded to Shopify product media.

Social media automation: RSS feed new article → title → prompt → Midjourney → image posted to Buffer/Hootsuite queue.

Client deliverable workflow: Client submits brief via Typeform → prompt constructed in Make → Midjourney via LinkrAPI → image delivered to client via email or Dropbox.

For code-based automation, see our Python integration guide and our Midjourney automation guide.