Make + reelsdk

Render videos from one Make HTTP module

Make has no module that runs ffmpeg, and its HTTP module stops waiting after 300 s at most. reelsdk renders on its own machines and holds your request for up to 280 s, so a 30 s narrated slideshow with captions comes back as a finished mp4 link in 40 to 45 s, in the same module. Slideshows and captions cost $0.02 per output minute, plus $0.05 per 1,000 characters of voiceover.

Get an API key Slideshow API

One module from request to mp4 link
The key lives in Make's keychain
A second call or a webhook covers long renders

What a Make scenario shows when a render outlasts the HTTP module

The operation timed out

The request has exceeded the allotted timeout.

Source: Make Community: common errors

The same job as one call to reelsdk

curl -X POST "https://api.reelsdk.com/v1/slideshow?wait=280" \
  -H "Authorization: Bearer rk_live_xxx" \
  -H "Content-Type: application/json" \
  -d '{
    "images": ["https://example.com/1.jpg", "https://example.com/2.jpg"],
    "voiceover": { "text": "Three rooms, one view, move in this spring." },
    "captions": "bold"
  }'

200 with job.outputs.video after 40 to 45 s, inside Make's 300 s timeout

Why ffmpeg breaks here

No shell, and 300 seconds per request

A Make scenario has no shell and nowhere to install a binary, so ffmpeg has to run somewhere else and Make has to call it. The HTTP Make a request module waits for an answer for a Timeout you set between 1 and 300 seconds. A render service that answers later fails the module with The operation timed out or The request has exceeded the allotted timeout.

Most render APIs answer with a job id and leave the waiting to you, which in Make means a Sleep module, a loop and an operation spent on every check. reelsdk holds the request open instead: with ?wait=280 a slideshow, captions job or faceless short comes back finished in one module, and a render that runs longer returns a job you can pick up with one more call.

Make next to reelsdk

Make next to reelsdk
Topic	Make	reelsdk
Running ffmpeg	No module runs binaries	ffmpeg 8.1 through `POST /v1/ffmpeg`, $0.01 per compute minute
Request timeout	1 to 300 s on the HTTP module	`?wait=` holds the request up to 300 s, 280 s fits Make
Long renders	Sleep modules and polling loops	A 202 with `poll_url`, or a webhook when the job ends
Credentials	Keychain, API key in a header or query	`Authorization: Bearer rk_live_...`

Make limits from Make HTTP app, checked October 2026.

Set it up

One module, with a fallback for long renders

You need a reelsdk key. The first module does the whole job for most renders. A filter and one more call cover anything that runs past 280 s.

Store the key in the keychain
Create a key in the reelsdk dashboard. In the HTTP Make a request module, set Authentication type to API key and add a credential. Make sends the Key exactly as typed, so include the Bearer prefix.
API key credential
Key
Bearer rk_live_...
API key placement
Header
API key parameter name
authorization
Send the render and wait
Point the module at /v1/slideshow?wait=280, paste the body below and map your photos and script into it. With Parse response on, the module ends with status 200 and the mp4 link in data.job.outputs.video. If a script can contain quotes or line breaks, build the body as a Data structure instead, so Make writes valid JSON.
HTTP Make a request
URL
https://api.reelsdk.com/v1/slideshow?wait=280
Method
POST
Body content type
application/JSON
Body input method
JSON string
Parse response
Yes
Timeout
300
Body
```
{
  "images": ["{{1.photo_1}}", "{{1.photo_2}}", "{{1.photo_3}}"],
  "size": "9:16",
  "motion": "kenburns",
  "transition": "fade",
  "voiceover": { "text": "{{1.script}}" },
  "captions": "bold"
}
```
Pick up renders that run longer
A render still running at 280 s answers 202 with the job. Add a filter for status code 202 and a second module that calls the first module's data.job.poll_url with ?wait=280 added, using the same credential; it returns 200 once the video is done. For big batches, send ?wait=0 with a webhook_url pointing at a Custom webhook scenario, and fetch GET /v1/jobs/{id} with your key before you trust what arrives.

FAQ

Video on Make, answered

Can I run ffmpeg directly inside a Make scenario?

No. Make has no module that runs shell commands or binaries. Send the arguments to reelsdk's POST /v1/ffmpeg from the HTTP module instead: it runs ffmpeg 8.1 without a shell on a machine that is ready in about 1.9 s at the median, for $0.01 per compute minute.

How do I avoid Make's 300-second HTTP timeout when rendering video?

Add ?wait=280 to the reelsdk URL and set the module's Timeout to 300. A 30 s slideshow takes 40 to 45 s and a faceless short about 100 s, so most renders return 200 in one module. A 202 means the job is still running: call its poll_url with ?wait=280, or send ?wait=0 with a webhook_url.

How do I check that a webhook really came from reelsdk in Make?

Don't use the webhook body as the result. Take the job id from it and call GET /v1/jobs/{id} with your key: reelsdk answers 404 for any job that isn't yours, so a forged request gets nothing. Every webhook also carries a Reel-Signature HMAC header if you would rather check it in your own code.

How do I add word-by-word captions to a video in Make?

Send the video URL to POST /v1/captions with a style such as karaoke. Transcription is included, and a 30 s clip takes 30 to 43 s at $0.02 per output minute. The response links the burned-in mp4 plus srt, vtt and ass files and a JSON transcript, all kept for 7 days.

What does it cost, and what are the limits?

There is no subscription and the first $1 is free. Slideshows and captions cost $0.02 per output minute, faceless shorts $0.25 up to 60 s or $0.35 up to 90 s, and raw ffmpeg $0.01 per compute minute. Each key runs 3 jobs at once and 500 a day, with inputs up to 500 MB each and media up to 15 minutes long.

All integrations