Originally published at ffmpeg-micro.com

Airtable is great at tracking content. Rows of video files with status columns, due dates, assignees. But when someone changes a status to "Ready to publish" and you still have to manually export, resize, and transcode each video, the automation stops where it matters most.

You can fix this by connecting Airtable's scripting automation to the FFmpeg Micro API. When a record hits a trigger condition, a script fires an HTTP request, FFmpeg Micro processes the video, and the output URL writes back into your Airtable row. No manual step in between.

The Architecture

Airtable automations trigger scripts when records change. Those scripts can make HTTP requests. FFmpeg Micro accepts video URLs over HTTP and returns processed results. The flow:

1. A record in your Airtable base changes (new row, status update, checkbox toggle)
2. Airtable fires an automation trigger
3. A scripting action sends the video URL to the FFmpeg Micro API
4. FFmpeg Micro transcodes the video and returns a job ID
5. A second automation polls for completion and writes the download URL back

No middleware. No Zapier. No n8n. Just Airtable's built-in scripting block talking directly to an API.

Step 1: Get Your FFmpeg Micro API Key

Sign up at ffmpeg-micro.com and grab your API key from the dashboard. The free tier gives you enough minutes to test and run small batches.

Step 2: Set Up Your Airtable Base

You need a table with at least these fields:

The Video URL field should contain a publicly accessible link. FFmpeg Micro needs to download the source file, so private Airtable attachments won't work directly. Use a public cloud storage URL (Google Cloud Storage, S3, or any CDN).

Step 3: Create the Automation

In Airtable, go to Automations and create a new one:

Trigger: "When record matches conditions"

• Table: your video table
• Condition: Status = "Pending"

Action: "Run a script"

Paste this script into the scripting action:

const config = input.config();
const recordId = config.recordId;
const videoUrl = config.videoUrl;
const outputFormat = config.outputFormat || 'mp4';
const quality = config.quality || 'medium';

const API_KEY = 'YOUR_FFMPEG_MICRO_API_KEY';

// Update status to Processing
await config.table.updateRecordAsync(recordId, {
    'Status': {name: 'Processing'}
});

// Send transcode request to FFmpeg Micro
const response = await fetch('https://api.ffmpeg-micro.com/v1/transcodes', {
    method: 'POST',
    headers: {
        'Authorization': `Bearer ${API_KEY}`,
        'Content-Type': 'application/json'
    },
    body: JSON.stringify({
        inputs: [{url: videoUrl}],
        outputFormat: outputFormat,
        preset: {quality: quality}
    })
});

const result = await response.json();

if (response.ok) {
    // Store the job ID for polling later
    await config.table.updateRecordAsync(recordId, {
        'Job ID': result.id
    });
    console.log(`Transcode job created: ${result.id}`);
} else {
    await config.table.updateRecordAsync(recordId, {
        'Status': {name: 'Error'}
    });
    console.error(`FFmpeg Micro error: ${result.error}`);
}

Configure the input variables in the script settings:

• recordId = the record ID from the trigger
• videoUrl = the Video URL field value
• outputFormat = the Output Format field value
• quality = the Quality field value
• table = the table object (Airtable provides this automatically)

Step 4: Poll for Completion

FFmpeg Micro transcodes are asynchronous. The API returns a job ID immediately, and processing happens in the background. Create a second automation to check job status:

Trigger: "When record matches conditions"

• Condition: Status = "Processing" AND Job ID is not empty

Or use a scheduled automation that runs every 5 minutes.

Action: "Run a script"

const config = input.config();
const recordId = config.recordId;
const jobId = config.jobId;
const API_KEY = 'YOUR_FFMPEG_MICRO_API_KEY';

// Check job status
const statusResponse = await fetch(
    `https://api.ffmpeg-micro.com/v1/transcodes/${jobId}`,
    {
        headers: { 'Authorization': `Bearer ${API_KEY}` }
    }
);
const job = await statusResponse.json();

if (job.status === 'completed') {
    // Get downloadable URL (output_url is a gs:// path, not directly fetchable)
    const downloadResponse = await fetch(
        `https://api.ffmpeg-micro.com/v1/transcodes/${jobId}/download`,
        {
            headers: { 'Authorization': `Bearer ${API_KEY}` }
        }
    );
    const download = await downloadResponse.json();

    await config.table.updateRecordAsync(recordId, {
        'Status': {name: 'Done'},
        'Output URL': download.url
    });
} else if (job.status === 'failed') {
    await config.table.updateRecordAsync(recordId, {
        'Status': {name: 'Error'}
    });
}

Most transcodes finish in under a minute for short videos. The polling automation catches results on its next run.

Use Cases That Work Well With This Setup

Batch thumbnail generation. Drop 50 video URLs into Airtable, set all to "Pending," and the automation generates a thumbnail from each one. FFmpeg Micro can extract frames at specific timestamps.

Social media reformatting. Your content team uploads one master video. The automation creates vertical crops for TikTok/Reels, square crops for Instagram feed, and landscape versions for YouTube, all from the same source.

Client delivery. Agencies managing video projects can let clients upload raw footage to a shared Airtable base. The automation transcodes to the client's required format and resolution, then writes the download link back into the record.

Content pipeline tracking. Track every video from draft to published in Airtable, with automated format conversion as part of the workflow. Status columns let your team see exactly where each piece is.

FAQ

Does Airtable's scripting block support fetch/HTTP requests?

Yes. Airtable's scripting automation actions support the standard fetch API for making HTTP requests. You can call any REST API, including FFmpeg Micro, directly from a script.

Can I process Airtable attachment fields directly?

Not directly. Airtable attachment URLs are temporary and authenticated. You need to copy the file to a public storage location first (like Google Cloud Storage or S3), then pass that public URL to FFmpeg Micro.

What happens if the transcode fails?

The polling script checks for failed status and sets the record to "Error." Check the Airtable automation run history for details. Common causes: invalid video URL, unsupported format, or an expired source link.

How many videos can I process at once?

FFmpeg Micro's free tier includes a limited number of processing minutes per month. The API handles concurrent requests, but Airtable automations have their own run limits depending on your plan (25,000 runs/month on Pro).

Is there a way to do this without writing code?

Connect Airtable to FFmpeg Micro through Make.com or Zapier instead of writing scripts. Both platforms have HTTP modules that can call the API without code. But the scripting approach gives you more control over error handling and record updates.

Last verified: June 2026