Airtable + ReelSDK $0.03 per output minute, first $0.50 free

Render videos from Airtable records

An Airtable automation script gives up on a fetch after 30 s and has no way to run ffmpeg. ReelSDK renders the video for $0.03 per output minute: 3 photos and one line of text from a record become a vertical slideshow with voiceover and captions for about 1.2 cents.

  • Run a script starts it, a webhook finishes it
  • Key in automation secrets
  • The finished mp4 lands in an attachment field
Airtable's limits for the Run a script action and the webhook trigger

Airtable scripting API will timeout after 12 seconds.

Fetch will timeout after 30 seconds.

Airtable does not support signature verification in the webhooks automation trigger.

Sources: Airtable: Run a script action, Airtable: When webhook received

The same job as one call to ReelSDK

curl "https://api.reelsdk.com/v1/slideshow?wait=60" \
  -H "Authorization: Bearer $REELSDK_KEY" \
  --json '{
    "images": [
      "https://api.reelsdk.com/f/lib/demo/seville/river.jpg",
      "https://api.reelsdk.com/f/lib/demo/seville/plaza.jpg",
      "https://api.reelsdk.com/f/lib/demo/seville/oranges.jpg"
    ],
    "size": "9:16",
    "voiceover": {
      "text": "Three days in Seville. Plaza de España at noon, orange trees under the Giralda, flamenco after dark, and tapas until midnight."
    },
    "captions": "bold"
  }'
200 in about 25 seconds: an 11-second 1080x1920 slideshow with voiceover and bold captionsTry it

Why ffmpeg breaks here

A 30 s fetch, no binaries, an unsigned webhook

Run a script gives you fetch, the base and input and output, and no way to start a program, so ffmpeg has nowhere to run. Its fetch gives up after 30 s, and an 11-second slideshow already takes about 25 seconds from request to finished mp4, so a longer video would fail inside the automation.

So the first automation only starts the job: it sends the record's photo links with ?wait=0, writes the job id back and ends in about a second. A second automation, triggered by a webhook, receives the finished job. Airtable can't check webhook signatures and anyone with the URL can fire that trigger, so the script treats the call as a doorbell: it fetches the job from ReelSDK with your key and only touches the record that is waiting for that job id.

Slideshows cost $0.03 per output minute plus $0.05 per 1,000 voiceover characters, so an 11-second video with a one-line script costs about 1.2 cents. Failed jobs are free and pricing has the rest. Here is a slideshow made this way.

Airtable automations next to ReelSDK

Airtable automations next to ReelSDK
TopicAirtable Run a scriptReelSDK
Running ffmpegNo way to start a programSlideshows, captions and raw ffmpeg over HTTPS
Waitingfetch stops after 30 s?wait=0 answers at once with the job id
Webhooks inNo signature check, 100 KB, 5 per secondSigned with HMAC-SHA256, up to 6 attempts
Secretsinput.secret() in automationsAuthorization: Bearer with that value
Photo linksAttachment URLs expire after 2 hoursInputs are downloaded as the job starts

Airtable limits from Airtable: Run a script action, checked November 2026.

Set it up

Two automations and one secret

You need a base on a paid plan, since Run a script isn't on Free, and a Videos table with Photos (attachments), Script (long text), Job (text), Status (single select) and Video (attachments) fields.

  1. Add the key as an automation secret

    In the Run a script action open Secrets, add one named REELSDK_KEY and read it with input.secret("REELSDK_KEY"). Only people who can access the secret can edit the script after that.

    Airtable secret
    Name
    REELSDK_KEY
    Value
    rsdk_live_...
  2. Start the render

    Trigger: When a record matches conditions, Status is Render. Action: Run a script with an input recordId set to the record's ID. Paste the webhook URL from the next step into WEBHOOK.

    Start render (Run a script)Try it
    const { recordId } = input.config();
    const key = input.secret("REELSDK_KEY");
    
    const WEBHOOK = "https://hooks.airtable.com/workflows/v1/genericWebhook/...";
    
    const table = base.getTable("Videos");
    const record = await table.selectRecordAsync(recordId, { fields: ["Photos", "Script"] });
    if (!record) throw new Error(`record ${recordId} not found`);
    
    const photos = record.getCellValue("Photos") ?? [];
    if (photos.length === 0) throw new Error("add at least one photo");
    
    // Attachment links expire after 2 hours, ReelSDK downloads them as the job starts
    const res = await fetch("https://api.reelsdk.com/v1/slideshow?wait=0", {
      method: "POST",
      headers: { Authorization: `Bearer ${key}`, "Content-Type": "application/json" },
      body: JSON.stringify({
        images: photos.slice(0, 100).map((photo) => photo.url),
        size: "9:16",
        voiceover: { text: record.getCellValueAsString("Script") },
        captions: "bold",
        webhook_url: WEBHOOK,
      }),
    });
    
    const data = await res.json();
    if (!res.ok) throw new Error(`reelsdk ${res.status}: ${data.error?.message}`);
    
    await table.updateRecordAsync(recordId, { Job: data.job.id, Status: { name: "Rendering" } });
    
  3. Catch the finished job

    Second automation, trigger When webhook received. Send it one test job so Airtable learns the payload, then add a Run a script action with an input jobId set to the body's id. Airtable downloads the mp4 into the Video field, so the 7-day output link stops mattering.

    Finish render (Run a script)
    const { jobId } = input.config();
    const key = input.secret("REELSDK_KEY");
    
    // Anyone with the webhook URL can fire this, so we ask ReelSDK for the job ourselves
    const res = await fetch(`https://api.reelsdk.com/v1/jobs/${encodeURIComponent(jobId)}`, {
      headers: { Authorization: `Bearer ${key}` },
    });
    
    // A failed job answers 422 or 500 and still carries the job
    const { job } = await res.json();
    if (!job) throw new Error(`reelsdk ${res.status} for job ${jobId}`);
    
    const table = base.getTable("Videos");
    const query = await table.selectRecordsAsync({ fields: ["Job"] });
    const record = query.records.find((r) => r.getCellValueAsString("Job") === job.id);
    if (!record) throw new Error(`no record is waiting for ${job.id}`);
    
    if (job.status === "succeeded") {
      await table.updateRecordAsync(record.id, {
        Video: [{ url: job.outputs.video, filename: "video.mp4" }],
        Status: { name: "Done" },
      });
    } else if (job.status === "failed") {
      await table.updateRecordAsync(record.id, { Status: { name: "Failed" } });
      console.log(`${job.id} failed: ${job.error?.message}`);
    }
    

FAQ

Video on Airtable, answered

Can an Airtable script run ffmpeg?

No. Run a script and the Scripting extension run JavaScript with fetch and the base, and there is no way to start a program. Send the photos to ReelSDK instead and write the finished mp4 back into an attachment field.

Why not wait for the video inside the script?

Airtable's fetch gives up after 30 seconds, and an 11-second slideshow takes about 25 seconds to render. Starting the job with ?wait=0 takes about a second, and the webhook trigger picks the result up when it's ready.

Anyone with the webhook URL can trigger the automation. Is that a problem?

Not with the doorbell pattern. The finishing script never trusts the payload: it fetches the job from ReelSDK with your key and only updates a record that is waiting for that job id, so a fake call changes nothing.

Can it use photos from attachment fields?

Yes. Airtable attachment links expire 2 hours after they're read, and ReelSDK downloads inputs as the job starts, so pass them straight through. A slideshow takes 1 to 100 images.

What does it cost?

$0.03 per output minute plus $0.05 per 1,000 voiceover characters, with the first $0.50 free and failed jobs free. Each key runs 3 jobs at once and 500 a day.

All integrations

Ready to build?

Ship video from your app today

Your first $0.50 is free, and one key covers every endpoint.

Moonlit lake with a lit cabin under the mountains