Seedance 2.5 from ByteDance is officially available on Apiframe.

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

Connect Apiframe to Make.com to auto-generate images, video, and music in no-code workflows.

Renaud Last updated November 14, 2026 August 13, 2026 · 9 min read Beginner
How to Use Apiframe in Make.com: Step-by-Step Automation Guide

Make.com and n8n solve the same problem in different ways, and plenty of teams pick Make for its visual canvas and its usage-based pricing. If you have already worked through our guide to using Apiframe in n8n, this one covers the same ground on a different platform. It walks through connecting Apiframe to Make.com from scratch: getting your API key, building a scenario, handling the wait while a generation job runs, and sending 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 automation platform you can use without writing code. You build "scenarios" by connecting modules on a canvas: a trigger module starts the flow, and every module after it processes data, calls an API, or passes the result into another app. It sits in the same category as Zapier and n8n, with more emphasis on visual, branching workflows and usage-based pricing.

Apiframe gives you one API for image, video, and music generation across models like Midjourney, Flux, Kling, and Suno. Generation does not finish instantly. You submit a request, the job runs in the background, and the result arrives a little later. Pairing Apiframe with Make.com lets you handle that waiting period, and everything that happens after it, without building a backend service just to connect the two. Our guide to choosing an AI media API covers what to look for in a provider if you're still deciding whether Apiframe fits your stack.

What You Can Automate: Use Cases

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

Pull content ideas from Airtable or Google Sheets, generate an image or a short video for each row, and write the result back to your calendar or send it on to another app. Our walkthrough on building cost-effective AI video ads shows how teams keep this kind of batch work affordable.

Turn form submissions into AI-generated assets

Connect a form tool such as Typeform, Google Forms, or Make's own webhook trigger, so every submission starts a generation job on its own instead of someone doing it by hand. A product description, a customer photo, or a one-line request is enough to kick things off. If your forms collect images, our notes on using reference images in AI image generation explain how to feed them into a prompt.

Sync generated content to Notion, Airtable, or Google Drive

Once a job finishes, push the resulting URL, or the downloaded file, into the system your team already works in. Generated assets then sit 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 sending output to (Slack, Google Drive, Airtable, and so on). Nothing else is required to follow along. If you've never called the Apiframe API before, Getting Started with Apiframe is a short warm-up, and 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 a key in the API Keys section of the dashboard. Every Apiframe key starts with afk_, and it authenticates requests through the X-API-Key header. Keep the key private: don't paste it into a scenario template you plan to share, and don't commit it to a repository. In Make.com, the tidiest option is the HTTP > Make an API Key Auth request module, which stores the key in a reusable connection instead of leaving it on display in every module. For more on handling keys safely, see our notes on AI media API security and authentication.

Step 2: Create a New Scenario in Make.com

From your Make.com dashboard, create a new scenario. You get a blank canvas where you add modules in the order your logic needs, usually left to right.

Choosing a trigger

What starts the scenario depends on your use case:

  • Webhook. Use Make's Custom Webhook module when an external system (your own app, a form tool, another service) should start generation. Adding the module creates a unique URL you can send requests to.
  • Schedule. Use a scheduled trigger when generation should run on a timer, for example a batch of social images every morning.
  • App event. Use a native app trigger (a new row in Airtable, a new form response) when generation should follow activity in a 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, or HTTP > Make an API Key Auth request if you saved your key as a connection in Step 1. This is the module that calls Apiframe.

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:

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

You can map the prompt field straight to data from your trigger, such as a column from an Airtable row or a field from a webhook payload, using Make's mapping panel rather than typing static text. The model field takes a model identifier, for example flux-1.1-pro, nano-banana-2, or gpt-image-2. Our Nano Banana guide helps you choose between versions, and our roundup of the best AI image generation APIs compares models on price and quality.

Apiframe replies right away with a job ID and a QUEUED status, because the generation itself runs in the background:

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

Step 4: Handle the Waiting Period (Polling or Webhooks)

The first request only gives you a job ID, so you need a second step to collect the result. Make.com supports both of the patterns Apiframe offers: checking the job yourself on a loop (polling), or letting Apiframe call you the moment it's done (webhooks). Our AI video generation API guide explains this submit-then-check pattern in more depth if you want the background before wiring it up in Make.

Using Make.com's repeater to poll for the result

For a simple setup, add a Flow Control > Repeater module, then a Tools > Sleep module set to a few seconds, then 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

A Repeater runs everything after it once per iteration, so the Sleep and the status check repeat until you have an answer. Add a Filter on the connection after the status check so the scenario only continues when the status is COMPLETED, and stops or flags an error when it's FAILED. A job moves through four statuses: QUEUED, PROCESSING, COMPLETED, and FAILED, and the result URLs only appear once it reaches COMPLETED. This is the same polling pattern described in Apiframe's docs, 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 status checks, and you hear back the moment a job finishes. Add webhookUrl and webhookEvents to your original generation request body:

json
{
  "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 scenario that starts with a Custom Webhook module using that same URL. Make's free plan allows two active scenarios at a time, so a submit scenario plus a listener scenario will use both. Apiframe sends a POST request with a JSON body when the job completes:

json
{
  "event": "completed",
  "jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
  "status": "COMPLETED",
  "progress": 100,
  "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. The signature is an HMAC-SHA256 of the request body, and the signing secret is the SHA-256 hash of your API key. Make doesn't check signatures for you the way a custom backend would, so verifying one inside a scenario means adding a Tools > Set variable module and a hashing function. For internal automations, keeping the webhook URL private is usually enough. For anything public-facing, verify the signature before you act on the payload. Apiframe also retries completed and failed deliveries up to 10 times with a growing delay, so a short outage on your side won't lose the result. Full details are in Apiframe's webhooks documentation, and our walkthrough on setting up webhook callbacks for media generation covers the pattern more generally.

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

Once you have the finished 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 and map the image or video URL from the job result. Add a Slack > Create a message module after it, posting either the original file URL or the new 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 barely changes between them. The differences that matter for AI generation workflows come down to pricing and flexibility:

Pricing model. Make bills in "credits". It renamed the unit from "operations" in August 2025, but the accounting is much the same: most module runs count as one. Zapier bills in "tasks", counted per action step. Make's free plan includes 1,000 credits a month and two active scenarios, against Zapier's 100 tasks, and Make's entry paid tier tends to stretch further per dollar. That matters for a workflow that runs several modules per generation: submit, then poll or receive a webhook, then route the result to a destination.

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

When each is the better fit. If your team has already standardized on Zapier for other integrations, staying there avoids spreading your automations across two 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 the current numbers before committing to one for a high-volume workflow. Our roundup of AI media generation APIs is a useful companion read if you're still deciding on the generation side of the stack, not just the automation layer.

Common Errors and Troubleshooting

401 authentication errors. This usually means the X-API-Key header is missing, or that it wasn't attached to the HTTP module correctly. Check that it's set as a header rather than a query parameter or a body field, and that the key is still active in your dashboard.

Timeouts on long-running jobs. Video and music jobs often take longer than a single sleep-and-check cycle. Raise the Repeater's iteration count, or switch to the webhook pattern so you aren't bound by a fixed polling window. Our AI avatar API guide explains why webhooks tend to win out at production volume, and the same reasoning applies here.

Malformed request bodies. A 400 response comes back with a details object listing the fields that failed validation, usually because a required parameter such as prompt or model is missing or misspelled. Compare your JSON against the image, video, or music examples in the docs for the model you're using.

429 rate limit errors. Apiframe allows 500 authenticated requests per minute per user. A single scenario rarely gets close, but a fast polling loop running across many scenarios at once can, which is another reason to prefer webhooks at scale.

FAQ

Is Make.com free to use with Apiframe?

Make.com has a free plan with a monthly credit allowance, and Apiframe runs its own usage-based credit system for generation requests. You can build and test a scenario on Make's free tier, but real production volume on either side will need a paid plan sooner or later, so check both pricing pages before you scale up. Our guide to estimating the monthly cost of AI video generation is a good place to start on the generation side.

Can I generate images, video, and music in the same scenario?

Yes. Each type of media uses its own endpoint (/v2/images/generate, /v2/videos/generate, /v2/music/generate), but they share the same authentication and the same job pattern. One scenario can call more than one endpoint, for example generating a video and a matching music track from the same trigger, using two parallel HTTP modules and two matching webhook or polling branches. Our text-to-video API tutorial is a useful reference for the video half of that pattern, and our AI music API guide covers the music half. Both are written for direct code integrations rather than Make, but the request shapes are identical.

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 the Apiframe API documentation.

Power your next AI product with Apiframe.

Instant access to 70+ media models through a single API. Start free and scale when you're ready.