How to Use Apiframe in Make.com: Step-by-Step Automation Guide

If you already have a "How to Use Apiframe in n8n" guide bookmarked, this one covers the same ground for a different no-code platform. Make.com and n8n solve similar problems in different ways, and plenty of teams pick Make specifically for its visual scenario builder and its operations-based pricing. This guide walks through connecting Apiframe to Make.com from scratch: getting your API key, building a scenario, handling the async nature of AI generation, and routing the finished image, video, or track wherever you need it.

What Is Make.com (and Why Pair It With Apiframe)

Make.com is a visual no-code automation platform. You build "scenarios" by connecting modules on a canvas: a trigger module starts the flow, and each module after it processes data, calls an API, or moves data into another app. It's a similar category to Zapier and n8n, with a stronger focus on visual, branching workflows and usage-based pricing.

Apiframe gives you a single API for image, video, and music generation across models like Midjourney, Flux, Kling, and Suno. Since generation is async (you submit a request and get a result later, not instantly), pairing it with Make.com lets you handle that waiting period, and everything that happens after, without writing a backend service just to glue the two together.

What You Can Automate: Use Cases

Auto-generate social media images or video from a content calendar

You can pull content ideas from Airtable or Google Sheets, generate an image or short video for each entry, and save the result back to your content calendar or send it to another app.

Turn form submissions into AI-generated assets

Connect a form tool (Typeform, Google Forms, Make's own webhook trigger) so that every submission, a product description, a customer photo, a request, triggers a generation job automatically instead of someone doing it by hand.

Sync generated content to Notion, Airtable, or Google Drive

Once a job completes, push the resulting URL (or the downloaded file) into whatever system your team already works in, so generated assets show up next to the rest of your project data instead of living in a separate tool.

Prerequisites

You'll need an Apiframe account and API key, a Make.com account, and whichever destination apps you're routing output to (Slack, Google Drive, Airtable, and so on). Nothing else is required to follow along, though it helps to have a specific use case in mind before you start building.

Step 1: Get Your Apiframe API Key

Sign up at console.apiframe.ai and create an API key from the dashboard's API Keys section. Apiframe API keys start with the prefix afk_. Keep this key private: don't paste it into a public scenario template or commit it anywhere version-controlled. In Make.com, you'll store it inside the HTTP module's connection settings rather than hardcoding it into the request body, which keeps it out of your scenario's visible configuration.

Step 2: Create a New Scenario in Make.com

From your Make.com dashboard, create a new scenario. This gives you a blank canvas where you'll add modules left to right (or in whatever order your logic needs).

Choosing a trigger

What starts the scenario depends on your use case:

Webhook: use Make's Custom Webhook module if an external system (your app, a form tool, another service) should kick off generation. Adding this module generates a unique URL you can send requests to.

Schedule: use a scheduled trigger if you want generation to run on a timer, for example, producing a batch of social images every morning.

App event: use a native app trigger (a new row in Airtable, a new form response) if generation should follow directly from activity in another tool you already use.

Step 3: Add an HTTP Module to Call the Apiframe API

Add an HTTP > Make a request module after your trigger. This is the module that actually calls Apiframe's API.

Setting headers and authentication

Configure the request with:

URL: https://api.apiframe.ai/v2/images/generate (swap in /v2/videos/generate or /v2/music/generate depending on what you're generating)

Method: POST

Headers:

X-API-Key: your Apiframe API key

Content-Type: application/json

Building the request body for image, video, or music generation

Set the body type to raw JSON. A basic image generation request looks like this:

{
  "prompt": "a cinematic photo of a cyberpunk city at night, ultra detailed, 4k",
  "model": "flux-1.1-pro"
}

You can map the prompt field directly to data from your trigger, for example, a column value from an Airtable row or a field from a webhook payload, using Make's mapping panel instead of typing it in as static text.

Apiframe responds immediately with a job ID and a QUEUED status, since generation happens in the background:

{
  "jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
  "status": "QUEUED"
}

Step 4: Handle Async Responses (Polling or Webhooks)

Since the first request only gives you a job ID, you need a second step to get the actual result. Make.com supports both patterns Apiframe offers: polling and webhooks.

Using Make.com's built-in repeater for polling

For a simple setup, add a Tools > Sleep module (wait a few seconds), followed by an HTTP > Make a request module that checks the job status:

URL: https://api.apiframe.ai/v2/jobs/{jobId} (map jobId from the previous module's response)

Method: GET

Headers: X-API-Key

Wrap the Sleep and status-check modules inside a Repeater module, and add a Filter on the connection after it so the scenario only continues once status equals COMPLETED (or stops and flags an error if it equals FAILED). This mirrors the polling pattern in Apiframe's own docs, just built with Make's flow-control modules instead of code.

Setting up a webhook listener for completed jobs

For production use, webhooks are the better fit: no repeated polling, and you get notified the moment a job finishes. Add webhookUrl and webhookEvents to your original generation request body:

{
  "prompt": "a cinematic photo of a cyberpunk city at night, ultra detailed, 4k",
  "model": "flux-1.1-pro",
  "webhookUrl": "https://hook.make.com/your-unique-webhook-id",
  "webhookEvents": ["completed", "failed"]
}

Create a second, separate scenario that starts with a Custom Webhook module using that same URL. Apiframe will POST a JSON payload to it when the job completes:

{
  "event": "completed",
  "jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
  "status": "COMPLETED",
  "result": {
    "images": ["https://cdn2.apiframe.ai/images/a1b2c3d4-...-1.png"]
  },
  "model": "flux-1.1-pro",
  "completedAt": "2026-08-13T10:00:32.000Z"
}

Apiframe signs every webhook request with an X-Webhook-Signature header (HMAC-SHA256, using the SHA-256 hash of your API key as the signing secret). If your webhook handler needs to verify this, you'll need a Tools > Set variable module plus a hashing function, since Make doesn't verify HMAC signatures natively the way a custom backend would. For most internal automations, restricting who knows the webhook URL is sufficient; for anything public-facing, verify the signature before acting on the payload. Full details are in Apiframe's webhooks documentation.

Step 5: Route the Output (Save, Post, Notify)

Once you have the completed job's result, whether from the polling branch or the webhook scenario, add modules to do something with it.

Example: save to Google Drive and post to Slack

Add a Google Drive > Upload a file module, mapping the image or video URL from the job result.

Add a Slack > Create a message module after it, posting the CDN URL (or the uploaded Drive link) to a channel your team watches.

You can chain as many destination modules as you need. Airtable, Notion, and a plain HTTP callback to your own app all work the same way: map the result URL from the previous module into whatever field or message the destination expects.

Make.com vs Zapier for AI Generation Workflows

Both platforms can run this exact pattern, and the HTTP request logic barely changes between them. The differences that actually matter for AI generation workflows come down to pricing and flexibility:

Pricing model: Make bills by "operations" (each module execution roughly counts as one), while Zapier bills by "tasks" (each action step). Make's free plan currently includes around 1,000 operations a month against Zapier's 100 tasks, and Make's entry paid tier tends to stretch further per dollar, which matters for a workflow that involves several modules per generation (submit, poll or webhook, then route to a destination).

Module flexibility: Make's visual canvas makes multi-branch logic, like the poll-and-filter pattern above, easier to build and read at a glance. Zapier's linear Zap structure can do it too, using Paths and Delays, but it reads less like a flowchart.

When each is the better fit: if your team already standardized on Zapier for other integrations, staying there avoids fragmenting your automation stack across tools. If you're starting fresh or your workflow branches a lot (different destinations depending on job status or content type), Make.com's canvas usually ends up easier to maintain.

Pricing and limits change over time on both platforms, so check current numbers before committing to one for a high-volume workflow.

Common Errors and Troubleshooting

401 authentication errors: usually means the X-API-Key header is missing or wasn't attached to the HTTP module's headers correctly. Double-check it's set as a header, not a query parameter or body field.

Timeouts on long-running jobs: video and music jobs can take longer than a single Sleep-and-check cycle. Increase the Repeater's iteration count, or switch to the webhook pattern so you're not bound by a fixed polling window.

Malformed request bodies: a 400 response with a details field pointing at a specific field usually means a required parameter (like prompt or model) is missing or misspelled. Compare your JSON body against the image, video, or music generation examples in the docs for the model you're using.

429 rate limit errors: Apiframe allows up to 500 authenticated requests per minute per account. This is rarely an issue for a single scenario, but can come up if you're running a high-frequency polling loop across many scenarios at once, another reason to prefer webhooks at scale.

For the same pattern on a different automation platform, see the n8n integration guide. For the full list of supported models and their parameters, check Apiframe's model catalog and the API documentation.