DEV Community: Javid Jamae

From Zero to Automated: Building Video Workflows That Scale

Javid Jamae — Sat, 11 Apr 2026 15:44:27 +0000

Originally published at ffmpeg-micro.com

You've shipped your MVP. Users are uploading videos. Everything works. Until it doesn't.

Processing one video manually? Fine. Ten videos? Annoying but manageable. A hundred videos? You're burning hours on repetitive tasks that should be automated.

How to build video workflows that scale from dozens to thousands of videos without the manual grind.

The Manual Workflow Trap

Most video workflows start manual because it's "just a few videos." You download the file, open your editor, apply the same transformations you did last time, export, and upload.

Repeat 50 times.

The problem isn't the first video.
It's video 10, 20, 50, 100. Each one takes the same 5-10 minutes. Each one follows the same steps. Each one is an opportunity for human error. Wrong resolution, missed watermark, inconsistent encoding settings.

You're not building features. You're a human video processing script.

Common manual workflows that waste time:

Creating social media clips from long-form content
Adding watermarks and branding to every video
Converting videos to multiple formats for different platforms
Generating thumbnails from specific frames
Trimming, cropping, or resizing batches of videos
Adding intro/outro sequences to user-generated content

Every one of these can be automated.

Step 1: Define Your Transformation

First, figure out what you're doing manually. Write it down as a recipe:

Example: Social media clips from podcast episodes

Input: 60-minute podcast video (1080p, horizontal)
Extract 10 highlight clips (30-60 seconds each)
Convert to vertical 9:16 format for Instagram/TikTok
Add branded intro (3 seconds)
Add captions overlay
Export as MP4, 1080x1920, H.264

Example: Product demo videos for different platforms

Input: Product demo (1920x1080, landscape)
Output 1: YouTube version (1080p, add intro/outro)
Output 2: Twitter version (720p, square 1:1, max 2:20)
Output 3: Instagram version (1080x1350, 4:5, max 60s)
Add company watermark to all versions

Once you have the recipe, you can code it.

Step 2: Build the Pipeline

A video workflow is just a series of API calls. No servers, no infrastructure, no complex setup.

Simple example: Watermark automation

async function addWatermark(inputUrl, outputUrl) {
  const response = await fetch('https://api.ffmpeg-micro.com/v1/jobs', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${process.env.FFMPEG_API_KEY}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      input: inputUrl,
      output: outputUrl,
      ffmpeg_args: [
        '-i', 'watermark.png',
        '-filter_complex', '[0:v][1:v]overlay=W-w-10:H-h-10',
        '-c:a', 'copy'
      ]
    })
  });

  return await response.json();
}

Multi-platform example: One video, three formats

async function createMultiPlatformVersions(videoUrl) {
  const platforms = [
    {
      name: 'youtube',
      ffmpeg_args: ['-vf', 'scale=1920:1080', '-c:v', 'libx264', '-preset', 'medium']
    },
    {
      name: 'twitter',
      ffmpeg_args: ['-vf', 'scale=720:720:force_original_aspect_ratio=decrease,pad=720:720:(ow-iw)/2:(oh-ih)/2', '-t', '140']
    },
    {
      name: 'instagram',
      ffmpeg_args: ['-vf', 'scale=1080:1350:force_original_aspect_ratio=decrease,pad=1080:1350:(ow-iw)/2:(oh-ih)/2', '-t', '60']
    }
  ];

  const jobs = platforms.map(platform =>
    fetch('https://api.ffmpeg-micro.com/v1/jobs', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${process.env.FFMPEG_API_KEY}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        input: videoUrl,
        output: `${videoUrl.replace('.mp4', '')}-${platform.name}.mp4`,
        ffmpeg_args: platform.ffmpeg_args
      })
    })
  );

  return await Promise.all(jobs);
}

Process one video, get three platform-specific versions. Automatically.

Step 3: Trigger It

Now that you have the transformation code, trigger it when you need it:

Option 1: Webhook from your app
User uploads video, your backend triggers workflow, processed videos ready

// In your upload handler
app.post('/upload', async (req, res) => {
  const videoUrl = await uploadToS3(req.file);

  // Trigger async processing
  await processVideoWorkflow(videoUrl);

  res.json({ status: 'processing', url: videoUrl });
});

Option 2: Watch a folder
New file in S3/Dropbox triggers Lambda function which processes video

// AWS Lambda triggered by S3 event
export async function handler(event) {
  const bucket = event.Records[0].s3.bucket.name;
  const key = event.Records[0].s3.object.key;
  const inputUrl = `https://${bucket}.s3.amazonaws.com/${key}`;

  await addWatermark(inputUrl, inputUrl.replace('.mp4', '-watermarked.mp4'));
}

Option 3: Scheduled batch processing
Every night at 2 AM, process all videos uploaded that day

// Cron job / GitHub Action
async function nightly() {
  const videos = await getVideosUploadedToday();

  for (const video of videos) {
    await createMultiPlatformVersions(video.url);
  }
}

Option 4: No-code automation
Connect Zapier/Make, trigger on Google Drive upload, process video, save to Dropbox

No code required. Just connect the pieces.

Step 4: Handle Failures Gracefully

Video processing fails. Files get corrupted. Networks time out. Your workflow needs to handle this.

Poll for completion:

async function waitForJob(jobId) {
  while (true) {
    const response = await fetch(`https://api.ffmpeg-micro.com/v1/jobs/${jobId}`);
    const job = await response.json();

    if (job.status === 'completed') return job;
    if (job.status === 'failed') throw new Error(job.error);

    await sleep(5000); // Check every 5 seconds
  }
}

Retry transient failures:

async function processWithRetry(videoUrl, maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await processVideo(videoUrl);
    } catch (err) {
      if (i === maxRetries - 1) throw err;
      await sleep(1000 * Math.pow(2, i)); // Exponential backoff
    }
  }
}

Log everything:

async function processVideoWorkflow(videoUrl) {
  console.log(`[WORKFLOW] Starting: ${videoUrl}`);

  try {
    const job = await createMultiPlatformVersions(videoUrl);
    console.log(`[WORKFLOW] Success: ${job.id}`);
    return job;
  } catch (err) {
    console.error(`[WORKFLOW] Failed: ${err.message}`);
    // Send to error tracking (Sentry, etc.)
    throw err;
  }
}

From Manual to Automated

The difference between manual workflows and automated workflows isn't complexity. It's leverage.

Manual workflow: 5 minutes per video × 100 videos = 8+ hours of work
Automated workflow: 30 minutes to build + 0 minutes per video = ship and forget

Real examples from FFmpeg Micro users:

Content agency processes 500+ client videos per week, zero manual work
SaaS product auto-generates preview clips for every user upload
AI automation tool creates 50 social media clips daily from podcast feeds
EdTech platform converts course videos to 3 formats on upload

They're not video experts. They just automated the boring parts.

Start Simple, Scale Later

You don't need to automate everything on day one. Start with the most painful manual task. Build the workflow. Test it. Then automate the next one.

Week 1: Automate watermarking
Week 2: Add multi-platform export
Week 3: Add thumbnail generation
Week 4: Integrate with your content calendar

Before you know it, your video workflow runs itself.

Ready to automate your video workflows?
FFmpeg Micro gives you powerful video processing through a simple API. No infrastructure, no complexity.
Start automating in 5 minutes

Building a Production-Ready Video Transcoding Pipeline (Without the DevOps Nightmare)

Javid Jamae — Sat, 11 Apr 2026 15:44:11 +0000

Originally published at ffmpeg-micro.com

You know that moment when your product manager casually mentions "Oh, and users should be able to upload videos in any format"? That's when the FFmpeg rabbit hole begins.

I've been there. What starts as "just run FFmpeg in a Docker container" quickly spirals into managing worker pools, debugging codec compatibility, handling edge cases, and waking up at 2 AM because your video processing queue is backed up.

What actually building a production video transcoding pipeline looks like and how to avoid the common traps.

The Real Complexity Nobody Tells You About

FFmpeg is incredibly powerful. It's also incredibly unforgiving. The learning curve isn't just steep. It's a cliff.

The syntax alone will slow you down.
Want to transcode a video to H.264 with AAC audio at 720p?

ffmpeg -i input.mp4 -c:v libx264 -preset medium -crf 23 -c:a aac -b:a 128k -vf scale=-2:720 output.mp4

And that's a simple one. Add watermarks, trim clips, adjust frame rates, or handle multiple audio tracks, and you're staring at commands 10 lines long that you copied from Stack Overflow three months ago and are too afraid to touch.

Error messages are cryptic.
"Codec not supported" could mean a dozen different things. Is it the container format? The codec? A missing library? A misconfigured build? Good luck figuring it out.

Edge cases are everywhere.
Videos come in thousands of combinations of containers, codecs, resolutions, frame rates, aspect ratios, and metadata. Users will upload files that break assumptions you didn't even know you made. Portrait videos. Vertical videos. Videos with no audio. Videos with 6 audio tracks. Videos encoded by software from 2003.

The Infrastructure Problem

So you've mastered FFmpeg syntax. Great. Now you need to run it at scale.

Option 1: Roll your own infrastructure.
Spin up EC2 instances, set up a queue (SQS? RabbitMQ?), build a worker pool, handle retries, monitor jobs, autoscale based on load, and pray your workers don't crash mid-transcode. You're now maintaining a distributed video processing system instead of building your actual product.

Option 2: Use AWS MediaConvert or similar.
These services work, but they're expensive and inflexible. You're limited to their presets. Need a custom FFmpeg filter chain? Too bad. Want to overlay dynamic text? Not supported. And the pricing? $0.0075 per minute adds up fast when you're processing thousands of videos.

Option 3: Serverless functions.
Lambda has a 15-minute timeout and 10GB ephemeral storage limit. Good luck processing anything longer than a few minutes or larger than a few hundred MB. Plus, cold starts mean your first transcode takes 30 seconds before FFmpeg even starts.

All three options require significant engineering time, ongoing maintenance, and trade-offs you'll regret later.

What Production-Ready Actually Means

A real production video pipeline needs:

Reliability.
Jobs need to complete successfully or fail gracefully with actionable errors. Transient failures (network hiccups, temporary resource constraints) should retry automatically. Permanent failures (corrupt video files) should fail fast with clear diagnostics.

Observability.
You need to know what's happening. How many jobs are queued? What's the average processing time? Which jobs failed and why? Where are the bottlenecks?

Scalability.
Handle 10 videos per hour or 1,000 videos per hour without changing your architecture. Auto-scale workers based on queue depth. Process jobs in parallel without coordination headaches.

Cost efficiency.
Pay for what you use. Don't run idle workers sitting around waiting for jobs. Don't overprovision for peak load that happens 5% of the time.

Developer experience.
Ship features fast. Test changes without deploying infrastructure. Integrate video processing into your app without becoming an FFmpeg expert.

The API-First Approach

The secret: video transcoding is infrastructure, not a competitive advantage. Unless you're building a video platform, your users don't care how you process videos. They care that it works.

Instead of building and maintaining your own pipeline, use an API:

const response = await fetch('https://api.ffmpeg-micro.com/v1/jobs', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${API_KEY}`,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    input: 'https://your-bucket.s3.amazonaws.com/input.mov',
    output: 'https://your-bucket.s3.amazonaws.com/output.mp4',
    preset: 'web-720p'
  })
});

That's it. No infrastructure, no worker pools, no debugging codec issues at midnight.

Full FFmpeg power.
Need custom operations? Pass any FFmpeg command:

{
  input: 'input.mp4',
  output: 'output.mp4',
  ffmpeg_args: [
    '-c:v', 'libx264',
    '-preset', 'medium',
    '-crf', '23',
    '-vf', 'scale=1280:720,drawtext=text="© YourBrand":x=10:y=10',
    '-c:a', 'aac'
  ]
}

You get FFmpeg's full flexibility without FFmpeg's operational burden.

Pay per minute processed.
No idle servers. No upfront costs. Process 10 videos or 10,000 videos with the same code and the same predictable pricing.

From Weeks to Hours

I've seen teams spend weeks building video infrastructure. Evaluating services, provisioning servers, writing worker code, debugging edge cases, monitoring jobs, handling retries.

The alternative? Integrate an API in an afternoon. Focus on your product. Ship features that matter to your users.

Your video pipeline should be boring infrastructure that just works. The exciting stuff (what you do with the processed videos) is where you should spend your time.

Ready to skip the DevOps nightmare?
FFmpeg Micro gives you production-ready video transcoding through a simple API. Full FFmpeg power, zero infrastructure.
Start processing videos in 5 minutes

FFmpeg Batch Processing: How to Process Hundreds of Videos

Javid Jamae — Sat, 11 Apr 2026 15:37:44 +0000

Originally published at ffmpeg-micro.com

You have 500 videos that need transcoding. Maybe you are resizing them for different platforms. Maybe you are adding watermarks before distributing to clients. Maybe you just need to convert everything from MOV to MP4 because someone on your team insists on recording with QuickTime.

Whatever the reason, you are not going to sit there and run ffmpeg 500 times by hand.

This guide covers three approaches to batch processing with FFmpeg, from basic bash loops to parallel execution to API-based pipelines. Pick the one that matches your scale.

The Bash Loop (Simple, Slow)

The most common approach. Loop through a directory and run ffmpeg on each file:

for file in input/*.mp4; do
  ffmpeg -i "$file" -vf scale=1280:720 -c:v libx264 -crf 23 \
    "output/$(basename "$file")"
done

This works. It processes one video at a time, sequentially. For 10 files, fine. For 500 files on a machine with 16 cores, you are using 6% of your available compute.

The other problem: error handling. If file 247 fails because it has a corrupt header, the loop either stops (if you used set -e) or silently skips it and you find out three hours later when the output directory has 499 files instead of 500.

GNU Parallel (Fast, Fragile)

GNU parallel lets you run multiple ffmpeg processes simultaneously:

find input/ -name "*.mp4" | parallel -j 4 \
  ffmpeg -i {} -vf scale=1280:720 -c:v libx264 -crf 23 \
  output/{/}

The -j 4 flag runs 4 jobs concurrently. On a machine with 8 cores, this is a reasonable default. Push it higher and you risk running out of memory, because each ffmpeg process loads the entire input file into memory for decoding.

Parallel processing introduces new failure modes:

Memory pressure. Four concurrent transcodes of 4K video can easily consume 16GB+ of RAM.
Disk I/O bottleneck. Reading and writing 4 video streams simultaneously saturates most SSDs.
Partial failures. If 2 of 4 parallel jobs fail, your output directory has a mix of completed and incomplete files with no clear indication of which is which.

You can add logging, retry logic, and health checks. But at that point you are building a job queue, not running a bash script.

xargs for Quick Parallel Runs

If you do not have GNU parallel installed, xargs works for simple cases:

find input/ -name "*.mp4" -print0 | xargs -0 -P 4 -I {} \
  ffmpeg -i {} -vf scale=1280:720 -c:v libx264 -crf 23 \
  output/$(basename {})

Same parallel execution, fewer features. No progress tracking, no retry, no job logging. Fine for a one-off batch, not for a production pipeline.

The API Approach (Scale Without Infrastructure)

At some point, the bash script approach breaks down. Maybe you need to process thousands of videos. Maybe you need to run jobs from a web application. Maybe you are tired of debugging memory issues on your local machine.

A video processing API handles the infrastructure for you. You send a request, the API processes the video on its own servers, and you get the result back.

With FFmpeg Micro, a batch job looks like this:

const videos = ["video1.mp4", "video2.mp4", "video3.mp4"];

const jobs = await Promise.all(
  videos.map(video =>
    fetch("https://api.ffmpeg-micro.com/v1/jobs", {
      method: "POST",
      headers: {
        "Authorization": "Bearer YOUR_API_KEY",
        "Content-Type": "application/json"
      },
      body: JSON.stringify({
        input: video,
        output_format: "mp4",
        options: { scale: "1280:720", codec: "libx264", crf: 23 }
      })
    })
  )
);

No memory management. No disk I/O tuning. No infrastructure to maintain. The API auto-scales based on your workload.

When to Use Each Approach

Approach	Best For	Limitations
Bash loop	Under 50 videos, simple transforms	Slow, sequential, no error recovery
GNU parallel	50-500 videos, local processing	Memory limits, needs monitoring, fragile
API	Any volume, production pipelines	Requires network, per-job cost

The decision usually comes down to frequency. If you batch process videos once a quarter, a bash script is fine. If you do it daily or it is part of a product workflow, the infrastructure overhead of managing ffmpeg locally costs more than an API.

Cost Comparison

Processing 1,000 one-minute videos (1080p to 720p transcode):

Method	Time	Cost
Bash loop (single core)	~8 hours	$0 (your machine)
GNU parallel (4 cores)	~2 hours	$0 (your machine)
Cloud VM (c5.2xlarge)	~1 hour	~$3.40 (on-demand)
FFmpeg Micro API	~30 min	~$25 (pay per job)

The API costs more per run. But factor in the engineering time to set up parallel processing, handle failures, manage a cloud VM, and maintain the pipeline over months. At $150/hour engineering time, the API pays for itself after the first batch.

Getting Started

If you are processing under 50 videos occasionally, start with the bash loop. If you need parallel processing, try GNU parallel with conservative concurrency (-j 2 to start).

If you are building a product that processes user-uploaded videos, or you need to batch process at scale without managing infrastructure, try FFmpeg Micro. Sign up for free and run your first job in under a minute.

Getting Started with FFmpeg Micro: 5 API Examples

Javid Jamae — Sat, 11 Apr 2026 15:37:29 +0000

Originally published at ffmpeg-micro.com

You signed up for FFmpeg Micro. You have an API key. Now what?

This tutorial walks through five real use cases with working code. Each example builds on the same upload-transcode-download workflow, so once you get the pattern down, you can adapt it to pretty much anything.

The Basic Workflow

Every FFmpeg Micro job follows the same five steps:

Request a presigned upload URL
Upload your video file
Confirm the upload
Create a transcode job
Poll for completion and download

Steps 1 through 3 are identical for every example below. I'll show them once here, then focus on the transcode configuration for each use case.

# Step 1: Get a presigned upload URL
RESPONSE=$(curl -s -X POST https://api.ffmpeg-micro.com/v1/upload/presigned-url \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $API_KEY" \
  -d '{
    "filename": "input.mp4",
    "contentType": "video/mp4",
    "fileSize": 15728640
  }')

UPLOAD_URL=$(echo $RESPONSE | jq -r '.result.uploadUrl')
FILENAME=$(echo $RESPONSE | jq -r '.result.filename')

# Step 2: Upload the file
curl -X PUT "$UPLOAD_URL" \
  -H "Content-Type: video/mp4" \
  --data-binary @input.mp4

# Step 3: Confirm upload
curl -s -X POST https://api.ffmpeg-micro.com/v1/upload/confirm \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $API_KEY" \
  -d "{\"filename\": \"$FILENAME\", \"fileSize\": 15728640}"

One thing to watch out for: fileSize must be a JSON number, not a string. Sending "15728640" instead of 15728640 will get you a 400 error.

Example 1: Transcode MP4 to WebM

WebM is the go-to format for web video. Smaller files, better browser support, and VP9 encoding gives you solid quality at lower bitrates.

JOB=$(curl -s -X POST https://api.ffmpeg-micro.com/v1/transcodes \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $API_KEY" \
  -d '{
    "inputs": [{"url": "gs://YOUR_BUCKET/'"$FILENAME"'"}],
    "outputFormat": "webm",
    "preset": {
      "quality": "medium",
      "resolution": "1080p"
    }
  }')

JOB_ID=$(echo $JOB | jq -r '.id')
echo "Job created: $JOB_ID"

The preset approach is the simplest way to transcode. You pick a quality level (low, medium, high) and a resolution, and FFmpeg Micro handles the codec settings.

For most web video, medium quality at 1080p hits the sweet spot between file size and visual quality.

Example 2: Resize Video to 720p

Maybe you're building a platform where users upload 4K footage but you only need to serve 720p. The preset system handles this cleanly.

JOB=$(curl -s -X POST https://api.ffmpeg-micro.com/v1/transcodes \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $API_KEY" \
  -d '{
    "inputs": [{"url": "gs://YOUR_BUCKET/'"$FILENAME"'"}],
    "outputFormat": "mp4",
    "preset": {
      "quality": "high",
      "resolution": "720p"
    }
  }')

This re-encodes the video at 720p with high quality settings. The output file will be significantly smaller than the original 4K source, and for most screens, your users won't notice the difference.

Example 3: Extract Audio from Video

Need just the audio track? Maybe you're building a podcast clipper or pulling voiceovers from video content. Switch the output format to an audio container and use advanced mode to control the codec.

JOB=$(curl -s -X POST https://api.ffmpeg-micro.com/v1/transcodes \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $API_KEY" \
  -d '{
    "inputs": [{"url": "gs://YOUR_BUCKET/'"$FILENAME"'"}],
    "outputFormat": "mp3",
    "options": [
      {"option": "-vn", "argument": ""},
      {"option": "-c:a", "argument": "libmp3lame"},
      {"option": "-b:a", "argument": "192k"}
    ]
  }')

The -vn flag strips the video stream. -c:a libmp3lame sets the audio codec to MP3, and -b:a 192k gives you good audio quality without bloating the file. If you want lossless audio, swap mp3 for flac and drop the bitrate flag.

Example 4: Add a Text Watermark

Branding your videos before distribution? FFmpeg Micro supports text overlays through the @text-overlay virtual option. No need to mess with raw FFmpeg filter syntax.

JOB=$(curl -s -X POST https://api.ffmpeg-micro.com/v1/transcodes \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $API_KEY" \
  -d '{
    "inputs": [{"url": "gs://YOUR_BUCKET/'"$FILENAME"'"}],
    "outputFormat": "mp4",
    "options": [
      {"option": "-c:v", "argument": "libx264"},
      {"option": "-crf", "argument": "23"},
      {"option": "@text-overlay", "argument": {
        "text": "© My Company 2026",
        "style": {
          "fontSize": 24,
          "fontColor": "white",
          "x": "w-text_w-20",
          "y": "h-text_h-20"
        }
      }}
    ]
  }')

The x and y values use FFmpeg expression syntax. w-text_w-20 positions the text 20 pixels from the right edge. h-text_h-20 puts it 20 pixels from the bottom. You can place text anywhere on the frame using these expressions.

This is one of those things that takes 30 minutes to figure out in raw FFmpeg. With the @text-overlay virtual option, it's just a JSON object.

Example 5: Generate a Thumbnail

Every video platform needs thumbnails. You can grab a single frame from any point in the video by outputting to an image format.

JOB=$(curl -s -X POST https://api.ffmpeg-micro.com/v1/transcodes \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $API_KEY" \
  -d '{
    "inputs": [{"url": "gs://YOUR_BUCKET/'"$FILENAME"'"}],
    "outputFormat": "jpg",
    "options": [
      {"option": "-ss", "argument": "00:00:05"},
      {"option": "-frames:v", "argument": "1"},
      {"option": "-q:v", "argument": "2"}
    ]
  }')

-ss 00:00:05 seeks to 5 seconds into the video. -frames:v 1 grabs exactly one frame. -q:v 2 sets JPEG quality (lower number means higher quality, range is 2 to 31).

If you don't know which frame will look best, you could create multiple jobs seeking to different timestamps and let your users pick.

Polling for Completion

After creating any transcode job, poll the status endpoint until it's done.

while true; do
  STATUS=$(curl -s https://api.ffmpeg-micro.com/v1/transcodes/$JOB_ID \
    -H "Authorization: Bearer $API_KEY" | jq -r '.status')

  if [ "$STATUS" = "completed" ]; then
    echo "Done! Downloading..."
    DOWNLOAD=$(curl -s https://api.ffmpeg-micro.com/v1/transcodes/$JOB_ID/download \
      -H "Authorization: Bearer $API_KEY" | jq -r '.url')
    curl -o output.mp4 "$DOWNLOAD"
    break
  elif [ "$STATUS" = "failed" ]; then
    echo "Job failed"
    break
  fi

  echo "Status: $STATUS. Waiting..."
  sleep 5
done

Most jobs finish within a couple of minutes depending on file size and the complexity of your transcode settings.

What to Build Next

These five examples cover the most common video processing tasks, but they're just the starting point. You can chain operations together, use custom FFmpeg flags for fine-grained control, or integrate these API calls into automation platforms like n8n or Make.

If you don't have an account yet, sign up for free and grab your API key from the dashboard. The free tier gives you enough processing minutes to test all five examples above.

How to Use FFmpeg with n8n for Video Editing Workflows

Javid Jamae — Sat, 11 Apr 2026 15:30:55 +0000

Originally published at ffmpeg-micro.com

Half your business is already automated with n8n. Emails, CRM updates, Slack notifications, data pipelines. But every time a video needs processing, the automation stops and a human takes over.

Resize this for Instagram. Transcode that for the website. Add the watermark. Convert the format.

That gap in your workflow doesn't need to exist.

This tutorial walks through building a complete video editing workflow in n8n using FFmpeg Micro's API. No servers, no FFmpeg installation, no Docker containers. Just HTTP Request nodes.

Why Running FFmpeg in n8n Doesn't Work

If you've tried this, you know.

n8n.cloud doesn't have FFmpeg installed. The Execute Command node doesn't exist on cloud. Self-hosted? You'd need FFmpeg on every worker, codec libraries maintained, updates handled. And when someone uploads a video encoded by software from 2003, you're debugging cryptic errors at midnight.

Binary data handling is painful too. Moving large video files between n8n nodes, converting buffers to files, managing temp storage. It breaks at scale.

And FFmpeg syntax is its own language:

ffmpeg -i input.mov -i watermark.png -filter_complex "[0:v][1:v]overlay=W-w-10:H-h-10,scale=1280:720" -c:v libx264 -preset medium -crf 23 -c:a aac output.mp4

Nobody wants to debug that inside a Code node.

The fix: treat FFmpeg as an API call. FFmpeg Micro runs FFmpeg in the cloud and exposes it as REST. In n8n, that's just an HTTP Request node. Same as calling any other API.

What You'll Build

By the end of this, you'll have an n8n workflow that:

Uploads a video file to FFmpeg Micro's secure storage
Transcodes it to web-optimized H.264/AAC
Resizes it for different platforms (1080p, 720p, vertical for Reels/TikTok)
Adds a watermark overlay
Batch processes multiple videos in a loop

Each step is one HTTP Request node.

Prerequisites

n8n.cloud account (or self-hosted, both work)
FFmpeg Micro account. Sign up free, 100 minutes included
Your API key from the FFmpeg Micro dashboard

That's it. No FFmpeg installation. No Docker.

Step 1: Set Up Credentials in n8n

Store your API key as a credential so you don't hardcode it everywhere.

In n8n, go to Credentials, then Add Credential
Choose Header Auth
Header name: Authorization. Value: Bearer YOUR_API_KEY
Name it "FFmpeg Micro API" and save

Every HTTP Request node can now reference this credential.

Step 2: Upload a Video File

FFmpeg Micro uses presigned URLs for secure uploads. Request an upload URL, then PUT your file to it.

Get Upload URL (HTTP Request node):

Method: POST
URL: https://api.ffmpeg-micro.com/v1/upload/presigned-url
Authentication: your FFmpeg Micro API credential
Body (JSON):

{
  "filename": "input.mov",
  "contentType": "video/quicktime",
  "fileSize": 52428800
}

The response gives you a uploadUrl for uploading and a filename for later steps.

Upload the File (second HTTP Request node):

Method: PUT
URL: {{ .uploadUrl }}
Body: Binary, select your video file
Headers: Content-Type matching the file type

Video is now in FFmpeg Micro's cloud storage, ready for processing.

Step 3: Transcode a Video

Most common operation. Any format to web-optimized MP4.

HTTP Request node:

Method: POST
URL: https://api.ffmpeg-micro.com/v1/transcodes
Authentication: FFmpeg Micro API credential
Body:

{
  "inputs": [{"url": "{{ .item.json.fileUrl }}"}],
  "outputFormat": "mp4",
  "options": [
    {"option": "-s", "argument": "1280x720"},
    {"option": "-c:v", "argument": "libx264"},
    {"option": "-preset", "argument": "medium"},
    {"option": "-c:a", "argument": "aac"}
  ]
}

One node. FFmpeg Micro handles codec detection, format conversion, optimization. The web-720p preset outputs H.264 video with AAC audio at 720p.

Need more control? Use custom FFmpeg arguments:

{
  "inputs": [{"url": "{{ .item.json.fileUrl }}"}],
  "options": [
    "-c:v", "libx264",
    "-preset", "medium",
    "-crf", "23",
    "-c:a", "aac",
    "-b:a", "128k"
  ]
}

Full FFmpeg power. 400+ options. No installation.

Step 4: Resize for Multiple Platforms

One video, three platform-specific versions. This is where n8n's visual workflow shines. Add three parallel HTTP Request nodes after your transcode step, one per platform.

YouTube (1080p landscape):

{
  "inputs": [{"url": "{{ .item.json.fileUrl }}"}],
  "options": [
    "-vf", "scale=1920:1080:force_original_aspect_ratio=decrease,pad=1920:1080:(ow-iw)/2:(oh-ih)/2",
    "-c:v", "libx264",
    "-preset", "medium",
    "-c:a", "aac"
  ]
}

Instagram Reels / TikTok (1080x1920 vertical):

{
  "inputs": [{"url": "{{ .item.json.fileUrl }}"}],
  "options": [
    "-vf", "scale=1080:1920:force_original_aspect_ratio=decrease,pad=1080:1920:(ow-iw)/2:(oh-ih)/2",
    "-c:v", "libx264",
    "-preset", "medium",
    "-t", "60",
    "-c:a", "aac"
  ]
}

The -t 60 caps it at 60 seconds. Reels max at 90s but shorter clips perform better.

Twitter / X (720p square):

{
  "inputs": [{"url": "{{ .item.json.fileUrl }}"}],
  "options": [
    "-vf", "scale=720:720:force_original_aspect_ratio=decrease,pad=720:720:(ow-iw)/2:(oh-ih)/2",
    "-c:v", "libx264",
    "-t", "140",
    "-c:a", "aac"
  ]
}

Connect all three as parallel branches from the same source node. They run concurrently.

Step 5: Add a Watermark

Logo overlay using FFmpeg's overlay filter. FFmpeg Micro supports it natively.

{
  "inputs": [{"url": "{{ .item.json.fileUrl }}"}],
  "options": [
    "-i", "https://yourdomain.com/logo.png",
    "-filter_complex", "[0:v][1:v]overlay=W-w-10:H-h-10",
    "-c:a", "copy"
  ]
}

This puts your logo bottom-right with a 10px margin. Other positions:

Top-left: overlay=10:10
Top-right: overlay=W-w-10:10
Bottom-left: overlay=10:H-h-10
Center: overlay=(W-w)/2:(H-h)/2

The watermark image gets fetched via URL. No separate upload needed. Host it on S3, your CDN, wherever.

Step 6: Wait for Job Completion

FFmpeg Micro processes asynchronously. Two ways to handle this in n8n.

Polling (simpler):

Use a Wait node + IF node in a loop:

Wait node: pause 10 seconds
HTTP Request: GET https://api.ffmpeg-micro.com/v1/transcodes/{{ .id }}
IF node: check if {{ .status }} equals completed
If true, continue to download. If false, loop back to Wait.

Webhook (better for production):

Include a webhook URL when creating the job:

{
  "inputs": [{"url": "{{ .item.json.fileUrl }}"}],
  "outputFormat": "mp4",
  "options": [
    {"option": "-s", "argument": "1280x720"},
    {"option": "-c:v", "argument": "libx264"},
    {"option": "-preset", "argument": "medium"},
    {"option": "-c:a", "argument": "aac"}
  ],
  "webhook_url": "https://your-n8n-instance.app.n8n.cloud/webhook/ffmpeg-complete"
}

Create a separate n8n workflow with a Webhook trigger. FFmpeg Micro POSTs the result when the job finishes. No polling.

Step 7: Batch Process Multiple Videos

This is where the investment pays off. 10, 50, 500 videos. Zero manual work.

Loop over a list. Start with a Google Sheets node containing video URLs. Each row flows through your processing nodes automatically:

Google Sheets > Upload > Transcode > Resize > Watermark > Save Result

Add a row, get a processed video.

Watch a folder. Google Drive Trigger or S3 Trigger detects new uploads. Video lands in the folder, workflow fires.

Schedule it. Schedule Trigger runs your batch at specific times. Process everything uploaded during the day in one overnight run.

Skip the Setup: Download Pre-Built Workflows

We built the whole thing for you.

Download the complete n8n workflow templates. The ZIP contains four ready-to-import n8n workflows:

MAIN Controller. Orchestrates the full pipeline.
[SUB] Upload File. Handles secure file upload via presigned URL.
[SUB] Extract Metadata. Pulls video info before processing.
[SUB] Wait for Transcode. Manages async job completion with polling.

Import into n8n, add your API key, done. There's also a video walkthrough showing the entire setup end to end.

What It Costs

Component	Cost
n8n.cloud	$20/month (free trial available)
FFmpeg Micro	Free tier: 100 min/month. Starter: $19/month for 2,000 min
Total	Free to start. $39/month covers most use cases.

No server maintenance. No DevOps time.

100 videos per month at 2 minutes each = 200 minutes. That fits in the $19/month Starter plan.

Workflow Ideas

Social media repurposing. Podcast drops into Google Drive. n8n extracts highlight clips, resizes for YouTube Shorts, Reels, and TikTok, adds branded intro, pushes to scheduling tools.

Agency video processing. Client uploads raw footage to a shared folder. n8n transcodes to delivery specs, adds watermark, emails a download link, logs the job in Airtable for billing.

E-commerce product videos. Team uploads demos. n8n creates web-optimized versions, generates thumbnails, cuts social clips, updates product listings via Shopify API.

Course content pipeline. Instructor records a lesson. n8n transcodes to multiple quality levels, extracts audio for a podcast feed, generates a thumbnail, publishes to the course platform.

Troubleshooting

Job stays in "processing" for a long time.
Processing time depends on file size and complexity. A 10-minute 1080p video usually takes 1-3 minutes. Over 10 minutes? Check the job status endpoint for error details.

Watermark looks blurry.
Use a PNG with transparency, at least 200-300px wide. FFmpeg won't upscale a tiny logo to look good at 1080p.

Vertical video has black bars.
That's the pad filter working correctly. It prevents stretching. If you want to crop instead, swap pad for crop in the filter chain.

n8n says "connection refused."
Check your API key in the credential settings. It should be Bearer YOUR_API_KEY with the word Bearer and a space before the key.

Go Deeper

Video walkthrough + downloadable workflows. Full setup in about 10 minutes.
API docs. Complete reference for all endpoints.
Pricing. Find the right plan for your volume.

FFmpeg Micro turns FFmpeg commands into API calls. No servers, no installation. 100 free minutes to start. Create your free account.

FFmpeg Auth Headers: How to Use Authorization Bearer with FFmpeg

Javid Jamae — Sat, 11 Apr 2026 15:30:42 +0000

Originally published at ffmpeg-micro.com

You need to pull a video from behind auth. You’ve got the URL, you’ve got the token, and FFmpeg keeps throwing a 401. You Google it, find three Stack Overflow answers that all look slightly different, try each one, and none of them work.

I’ve wasted more time on this than I’d like to admit. The problem is almost always the same thing: FFmpeg’s -headers flag has quirks that nobody explains clearly. So here’s everything I know about passing auth headers in FFmpeg, distilled into examples you can actually copy-paste.

The Syntax (And the One Detail Everyone Misses)

FFmpeg sends custom HTTP headers with the -headers flag. Straightforward enough. But here’s the thing that trips up almost everyone: each header must end with \r\n (carriage return + newline). Miss that, and FFmpeg silently drops your header. No error, no warning. Just a 401 and confusion.

ffmpeg -headers "Authorization: Bearer YOUR_TOKEN\r\n" -i "https://example.com/protected-video.m3u8" -c copy output.mp4

That’s the whole thing. But there are a handful of gotchas that’ll bite you depending on your use case.

HLS Streams (The Most Common Scenario)

If you’re pulling a protected .m3u8 stream, good news: FFmpeg sends your header on every segment request automatically. You set it once and it propagates to every .ts chunk.

ffmpeg \
  -headers "Authorization: Bearer eyJhbGciOiJIUzI1NiIs...\r\n" \
  -i "https://cdn.example.com/stream/playlist.m3u8" \
  -c copy \
  -bsf:a aac_adtstoasc \
  output.mp4

I’ve seen people try to intercept segment requests and inject headers individually. You don’t need to do that. FFmpeg handles it.

Downloading from an API Endpoint

Sometimes the video isn’t a stream—it’s a file behind a REST API. Same approach, you can stack multiple headers:

ffmpeg \
  -headers "Authorization: Bearer sk_live_abc123\r\n" \
  -headers "Accept: video/mp4\r\n" \
  -i "https://api.example.com/v1/videos/download/42" \
  -c copy \
  output.mp4

You can also combine headers into one flag separated by \r\n, but multiple flags is easier to read and less error-prone.

Multiple Headers

Need to pass several headers? Two options:

ffmpeg \
  -headers "Authorization: Bearer YOUR_TOKEN\r\n" \
  -headers "X-API-Key: your-api-key\r\n" \
  -headers "User-Agent: MyApp/1.0\r\n" \
  -i "https://api.example.com/video.mp4" \
  -c copy \
  output.mp4

Or combine them:

ffmpeg \
  -headers "Authorization: Bearer YOUR_TOKEN\r\nX-API-Key: your-api-key\r\n" \
  -i "https://api.example.com/video.mp4" \
  -c copy \
  output.mp4

Both work. I prefer separate flags because debugging a 200-character header string at 11pm is not my idea of a good time.

Basic Auth

Some older services use HTTP Basic instead of Bearer tokens:

ffmpeg -i "https://username:password@example.com/video.mp4" -c copy output.mp4

That’s the easiest approach. If you need the header explicitly:

ffmpeg \
  -headers "Authorization: Basic dXNlcm5hbWU6cGFzc3dvcmQ=\r\n" \
  -i "https://example.com/video.mp4" \
  -c copy \
  output.mp4

The Base64 value is just username:password encoded:

echo -n "username:password" | base64

Why It’s Not Working

I’ve debugged this enough times to know the usual suspects. Here they are, in order of how often they bite people.

1. Missing \r\n

This is the #1 cause. FFmpeg silently ignores headers without the trailing \r\n. No error message, no hint. Your header just vanishes.

# Broken — header silently dropped
ffmpeg -headers "Authorization: Bearer TOKEN" -i "https://..." -c copy out.mp4

# Fixed
ffmpeg -headers "Authorization: Bearer TOKEN\r\n" -i "https://..." -c copy out.mp4

2. -headers after -i

Order matters in FFmpeg. The -headers flag applies to the next input, so it has to come before -i. Put it after and FFmpeg never sends it.

# Broken — header never sent
ffmpeg -i "https://..." -headers "Authorization: Bearer TOKEN\r\n" -c copy out.mp4

# Fixed
ffmpeg -headers "Authorization: Bearer TOKEN\r\n" -i "https://..." -c copy out.mp4

3. Shell quoting weirdness

Different shells interpret \r\n differently. If you’re on bash or zsh and the header still isn’t working, try:

ffmpeg -headers $'Authorization: Bearer TOKEN\r\n' -i "https://..." -c copy out.mp4

The $'...' syntax forces your shell to interpret the escape sequences literally.

4. Special characters in your token

JWTs can contain !, $, and backticks—all characters your shell loves to interpret. Use single quotes around the header value:

ffmpeg \
  -headers 'Authorization: Bearer eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOi...\r\n' \
  -i "https://..." \
  -c copy output.mp4

5. It’s not actually an FFmpeg problem

Before you spend another hour tweaking FFmpeg flags, test the URL with curl:

curl -H "Authorization: Bearer TOKEN" "https://example.com/video.mp4" -o /dev/null -w "%{http_code}"

If curl also gets a 401, the problem is your token or the URL—not FFmpeg.

Using Auth Headers in Code

If you’re calling FFmpeg from code rather than the terminal, here’s what that looks like.

Bash script:

#!/bin/bash
TOKEN="your-bearer-token-here"
VIDEO_URL="https://api.example.com/videos/stream.m3u8"

ffmpeg \
  -headers "Authorization: Bearer ${TOKEN}\r\n" \
  -i "${VIDEO_URL}" \
  -c copy \
  -movflags +faststart \
  output.mp4

Python:

import subprocess

token = "your-bearer-token-here"
url = "https://api.example.com/videos/stream.m3u8"

subprocess.run([
    "ffmpeg",
    "-headers", f"Authorization: Bearer {token}\r\n",
    "-i", url,
    "-c", "copy",
    "output.mp4"
])

Node.js:

const { execSync } = require('child_process');

const token = 'your-bearer-token-here';
const url = 'https://api.example.com/videos/stream.m3u8';

execSync(`ffmpeg -headers "Authorization: Bearer ${token}\\r\\n" -i "${url}" -c copy output.mp4`);

When This Gets Old

Auth headers work fine when you’re downloading one video. But if you’re building anything production-grade—processing user uploads, pulling from authenticated sources at scale, running batch jobs—the overhead adds up fast.

Token refresh logic. Retry handling for expired credentials. Secret management so tokens don’t leak into logs. Error parsing to tell "bad token" from "network timeout" from "corrupt file." You end up spending more time on auth plumbing than actual video processing.

FFmpeg Micro handles all of this through a simple REST API. Auth is one Bearer token—no \r\n hacks, no flag ordering, no shell escaping:

curl -X POST https://api.ffmpeg-micro.com/v1/jobs \
  -H "Authorization: Bearer fm_sk_your_api_key_here" \
  -H "Content-Type: application/json" \
  -d '{
    "input": "https://example.com/source-video.mp4",
    "ffmpeg_args": ["-vf", "scale=-2:720", "-c:v", "libx264", "-c:a", "aac"]
  }'

No FFmpeg installation. No infrastructure. Pass any source URL and FFmpeg Micro fetches it server-side, processes it, and gives you a download link or webhook when it’s done.

const response = await fetch('https://api.ffmpeg-micro.com/v1/jobs', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer fm_sk_your_api_key_here',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    input: 'https://cdn.example.com/protected/video.m3u8',
    preset: '720p',
    webhook_url: 'https://yourapp.com/webhooks/video-done'
  })
});

const { job_id, status } = await response.json();

Free tier includes 30 minutes of processing. No credit card required.

Try FFmpeg Micro free — auth headers handled automatically.

Quick Reference

Scenario	Command
Bearer token	`ffmpeg -headers "Authorization: Bearer TOKEN\r\n" -i URL -c copy out.mp4`
Basic auth	`ffmpeg -i "https://user:pass@host/video.mp4" -c copy out.mp4`
Multiple headers	`ffmpeg -headers "Auth: Bearer TOKEN\r\n" -headers "X-Key: KEY\r\n" -i URL -c copy out.mp4`
HLS with auth	`ffmpeg -headers "Authorization: Bearer TOKEN\r\n" -i "https://host/stream.m3u8" -c copy -bsf:a aac_adtstoasc out.mp4`

Always put -headers before -i. Always end each header with \r\n. Save yourself the debugging.

How to Transcode Video with an API (Skip the FFmpeg Server Setup)

Javid Jamae — Sat, 11 Apr 2026 15:22:50 +0000

Originally published at ffmpeg-micro.com

You need video transcoding in your app. Maybe users upload MP4s that need converting to WebM. Maybe you are building a course platform and need consistent 720p output. Maybe you just got handed a "video processing" ticket and realized FFmpeg has 400 command-line flags.

The typical path: spin up a server, install FFmpeg, write a job queue, handle failures, scale when traffic spikes. That is weeks of work before you process a single video.

There is a faster way. An API call.

The self-hosted FFmpeg trap

Most developers start by SSH-ing into a VPS and running apt install ffmpeg. Simple enough. Then reality hits.

Your server needs enough RAM to hold the input video in memory during processing. A single 4K video transcode can eat 8GB. Two concurrent users and your $20/month server is swapping to disk.

So you add a job queue. Now you need Redis or RabbitMQ. You need worker processes. You need retry logic for when FFmpeg segfaults on a corrupt input file (and it will). You need monitoring to know when the queue backs up.

Then there is the dependency problem. FFmpeg versions matter. The codec support compiled into your binary matters. That one transcode that works on your Mac but fails in the Docker container because the production image was built without libvpx? You will spend a full day debugging it.

Three weeks in, you have built a video processing platform instead of the product you actually wanted to build.

Upload, transcode, download

FFmpeg Micro wraps all of that infrastructure into five API calls. Get a presigned upload URL, upload your file, confirm the upload, kick off the transcode, and download the result.

In Python, the core workflow looks like this:

import requests

API_KEY = "your-api-key"
BASE = "https://api.ffmpeg-micro.com/v1"
headers = {"Authorization": f"Bearer {API_KEY}", "Content-Type": "application/json"}

# Step 1: Get a presigned upload URL
resp = requests.post(f"{BASE}/upload/presigned-url", headers=headers, json={
    "filename": "input.mp4",
    "contentType": "video/mp4",
    "fileSize": 15728640  # size in bytes
})
upload_url = resp.json()["result"]["uploadUrl"]
server_filename = resp.json()["result"]["filename"]

# Step 2: Upload directly to cloud storage (no API key needed)
with open("input.mp4", "rb") as f:
    requests.put(upload_url, headers={"Content-Type": "video/mp4"}, data=f)

# Step 3: Confirm the upload
requests.post(f"{BASE}/upload/confirm", headers=headers, json={
    "filename": server_filename,
    "fileSize": 15728640
})

# Step 4: Start the transcode
resp = requests.post(f"{BASE}/transcodes", headers=headers, json={
    "inputs": [{"url": f"gs://your-bucket/{server_filename}"}],
    "outputFormat": "mp4",
    "preset": {"quality": "medium", "resolution": "1080p"}
})
job_id = resp.json()["id"]

# Step 5: Poll until done, then download
import time
while True:
    status = requests.get(f"{BASE}/transcodes/{job_id}", headers=headers).json()
    if status["status"] == "completed":
        break
    time.sleep(5)

download = requests.get(f"{BASE}/transcodes/{job_id}/download", headers=headers).json()
print(f"Download your video: {download['url']}")

That is the entire workflow. No server provisioning. No FFmpeg installation. No job queue. The infrastructure scales automatically whether you are processing one video or a thousand.

cURL version for quick testing

If you want to test before writing any application code, the same flow works with cURL:

# Get upload URL
curl -X POST https://api.ffmpeg-micro.com/v1/upload/presigned-url \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"filename": "input.mp4", "contentType": "video/mp4", "fileSize": 15728640}'

# Upload your file to the presigned URL
curl -X PUT "$UPLOAD_URL" \
  -H "Content-Type: video/mp4" \
  --data-binary @input.mp4

# Confirm, then transcode
curl -X POST https://api.ffmpeg-micro.com/v1/transcodes \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"inputs": [{"url": "gs://your-bucket/input.mp4"}], "outputFormat": "mp4", "preset": {"quality": "medium", "resolution": "1080p"}}'

You can go from zero to a transcoded video in under five minutes.

When you need more control

The preset mode handles most use cases. But when you need specific FFmpeg flags, the API accepts them directly:

{
  "inputs": [{"url": "gs://your-bucket/input.mp4"}],
  "outputFormat": "webm",
  "options": [
    {"option": "-c:v", "argument": "libvpx-vp9"},
    {"option": "-crf", "argument": "30"},
    {"option": "-b:v", "argument": "0"}
  ]
}

Same FFmpeg power. You just don't manage the machine running it.

This matters for complex operations like text overlays. The API supports virtual options that abstract away FFmpeg filter graph syntax:

{
  "options": [
    {
      "option": "@text-overlay",
      "argument": {
        "text": "Draft - Do Not Distribute",
        "style": {"fontSize": 48, "x": "0.05*w", "y": "0.05*h"}
      }
    }
  ]
}

Compare that to the raw FFmpeg equivalent: -vf "drawtext=fontfile=/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf:text='Draft':fontsize=48:x=50:y=50". One is JSON you can generate programmatically. The other is a string that breaks if you look at it wrong.

What about cost?

Self-hosting sounds cheaper until you factor in the hidden costs. A dedicated transcoding server runs $50-200/month whether you process 10 videos or 10,000. You pay for idle capacity, and you pay again in engineering time when you need to scale up.

With a usage-based API, you pay per minute of video processed. Light usage costs a few dollars a month. Hit a viral spike and the infrastructure scales without you touching anything. No 3am pages about disk space or OOM kills.

When to self-host vs use an API

Self-hosting makes sense if you process millions of minutes monthly and have a dedicated infrastructure team to maintain it. For everyone else, an API gets you to production faster and costs less until you hit serious scale.

If you are building a SaaS product, a content platform, or any app where video processing is a feature but not the core product, spending weeks on FFmpeg infrastructure is time stolen from the thing that actually makes money.

Get a free API key and start transcoding in minutes.

How to Scale Video Processing to 1000+ Videos Per Day (Without Breaking the Bank)

Javid Jamae — Sat, 11 Apr 2026 15:22:17 +0000

Originally published at ffmpeg-micro.com

Processing 10 videos a day? Easy. Processing 1,000 videos a day? That's where most video pipelines fall apart.

The infrastructure that worked at small scale becomes your bottleneck. Costs balloon. Queues back up. Jobs fail. You're firefighting instead of shipping features.

How to scale video processing from dozens to thousands of videos per day without the complexity or the massive AWS bill.

The Scaling Problem Nobody Warns You About

Small-scale video processing is deceptively simple. Spin up a server, install FFmpeg, process videos as they arrive. Works great until traffic grows.

Then the cracks appear:

Processing times slow down.
When one video is processing, the next one waits. Then the next. Your queue depth grows faster than you can process it. Users wait hours for their videos.

Servers run out of resources.
Video transcoding is CPU and memory intensive. One 4K video can max out a server. Add a few concurrent jobs and you're OOM-killed or swapping to disk (making everything slower).

Costs spike unpredictably.
You overprovision servers to handle peak load but peak load happens 10% of the time. The other 90%, you're paying for idle CPU cycles. Your costs don't match your usage.

Infrastructure becomes brittle.
You add worker pools. Queue managers. Load balancers. Auto-scaling policies. Monitoring. Each new component is a new failure mode. Debugging production issues requires SSH-ing into workers and tailing logs.

The Math That Breaks Your Budget

Run the numbers on a typical DIY approach.

Scenario: Process 1,000 videos/day, average 5 minutes per video

Compute time needed: 1,000 videos × 5 min = 5,000 minutes = 83 hours/day
Servers needed (if processing serially): 83 hours ÷ 24 hours = 4 servers running 24/7
AWS EC2 cost: 4 × c5.2xlarge instances ($0.34/hr) × 730 hrs/mo = $993/month
S3 transfer costs: ~$50-100/month
Total: ~$1,100/month minimum

And that assumes:

Perfect utilization (no idle time)
No failed jobs requiring reruns
No auto-scaling overhead
No redundancy or failover
Zero engineering time for maintenance

In reality, you'll pay more:

Overprovisioned instances to handle peak load
Auto-scaling that spins up extra instances
Network egress fees
Storage costs for intermediate files
Monitoring and logging infrastructure

Easily $1,500-2,000/month before engineering time.

The Hidden Cost: Engineering Time

Infrastructure cost is just money. Engineering time is opportunity cost.

What maintaining video infrastructure actually looks like:

Week 1: Set up EC2 instances, install FFmpeg, configure worker pool
Week 2: Add SQS queue, handle retries, write monitoring scripts
Week 3: Debug why jobs randomly fail, add error handling
Week 4: Implement auto-scaling because queue is backing up
Month 2: Optimize FFmpeg settings to reduce processing time
Month 3: Upgrade to GPU instances for faster encoding (more cost)
Month 4: Investigate why some videos have audio sync issues
Month 5: Handle codec compatibility edge cases
Month 6: Migrate to a new instance type for better cost/performance

You've spent 6+ months building and maintaining video infrastructure instead of building your product.

Even worse: This becomes ongoing maintenance. FFmpeg updates. Library updates. Security patches. Capacity planning. Cost optimization. Someone needs to own this.

How the Pros Scale Video

Companies processing millions of videos (YouTube, Vimeo, TikTok) use specialized infrastructure. But they have dedicated video engineering teams and massive budgets.

For everyone else, there's a better approach: treat video processing like any other API dependency.

You don't run your own email servers (you use SendGrid). You don't run your own payment processing (you use Stripe). You don't run your own CDN (you use Cloudflare).

Why run your own video transcoding infrastructure?

Scaling with an API: The Numbers

Same scenario: 1,000 videos/day, 5 minutes average processing time per video

FFmpeg Micro API pricing:

1,000 videos × 5 min = 5,000 minutes/month
Cost: 5,000 minutes × $0.005/min = $25/month

That's 40x cheaper than running your own infrastructure. And you get:

Automatic scaling (handle 10 videos or 10,000 videos with the same code)
Zero infrastructure maintenance
No upfront provisioning
Pay only for what you process
Built-in retries and error handling
Monitoring and job status included

Better economics at every scale:

Videos/Day	DIY Infrastructure	FFmpeg Micro API	Savings
100	$200/mo	$2.50/mo	98.75%
1,000	$1,500/mo	$25/mo	98.3%
5,000	$7,000/mo	$125/mo	98.2%
10,000	$14,000/mo	$250/mo	98.2%

Even at massive scale, API pricing beats DIY infrastructure. And that's before counting engineering time.

Real-World Scaling Example

What processing 1,000+ videos per day actually looks like with an API-first approach:

// Process a batch of videos in parallel
async function processBatch(videos) {
  const jobs = videos.map(video =>
    fetch('https://api.ffmpeg-micro.com/v1/jobs', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${API_KEY}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        input: video.url,
        output: video.outputUrl,
        preset: 'web-720p'
      })
    })
  );

  // Submit all jobs at once
  const responses = await Promise.all(jobs);
  return responses.map(r => r.json());
}

// Poll for completion
async function waitForBatch(jobIds) {
  const completed = new Set();

  while (completed.size < jobIds.length) {
    await sleep(5000);

    const checks = jobIds
      .filter(id => !completed.has(id))
      .map(id => fetch(`https://api.ffmpeg-micro.com/v1/jobs/${id}`));

    const statuses = await Promise.all(checks);

    for (const status of statuses) {
      const job = await status.json();
      if (job.status === 'completed' || job.status === 'failed') {
        completed.add(job.id);
      }
    }
  }
}

That's it. No servers to manage. No queues to configure. No workers to monitor. Just submit jobs and check status.

Want to process 10,000 videos? Same code. No changes. It scales automatically.

When NOT to Use an API

To be fair, there are edge cases where DIY infrastructure makes sense:

1. You're processing millions of videos per month
At extreme scale (500K+ minutes/month), dedicated infrastructure might be cheaper. But you need a team to build and maintain it.

2. You have extreme latency requirements
If you need sub-second processing times and control over every millisecond, you need your own infrastructure. (But most use cases don't.)

3. You have compliance requirements
Some industries require on-premise processing for regulatory reasons. Fair enough.

For everyone else? API wins on cost, speed, and simplicity.

The Real Cost of Scaling

Infrastructure cost is just one number on a spreadsheet. The real cost is what you don't build while you're maintaining video servers.

Every hour spent on infrastructure is an hour not spent on:

Shipping features users actually want
Improving your core product
Growing your business
Fixing user-facing bugs
Talking to customers

Video processing is not your competitive advantage.
(Unless you're building a video platform, in which case, you probably have a dedicated video team already.)

Your competitive advantage is what you build on top of video processing. The workflows, the integrations, the user experience, the value you deliver.

From 10 to 10,000 Videos

Scaling video processing doesn't require architectural genius. It requires the discipline to recognize that some problems have already been solved.

Start small:

Process a few videos per day
Use simple API calls
Focus on your product

Scale effortlessly:

Same code, more videos
No infrastructure changes
Costs scale linearly with usage

Ship faster:

Stop debugging FFmpeg edge cases
Stop optimizing EC2 instance types
Stop firefighting infrastructure issues
Start building features that matter

The best video infrastructure is the one you don't have to think about.

Ready to scale video processing without the complexity?
FFmpeg Micro handles the infrastructure so you can focus on your product. Process 10 videos or 10,000 videos with the same simple API.
Get started in 5 minutes