Forem: Javid Jamae

How to Use FFmpeg with Node.js (No Installation Required)

Javid Jamae — Sat, 02 May 2026 10:14:30 +0000

Originally published at ffmpeg-micro.com.

You need to process video in your Node.js app. Maybe you're building a SaaS that generates thumbnails, transcoding user uploads, or automating video workflows. The first thing you Google is "ffmpeg node.js." And that's where the pain starts.

FFmpeg is the most capable video processing tool out there. But getting it to work reliably in a Node.js environment means dealing with binary dependencies, platform-specific builds, memory management, and deployment headaches. There are several ways to approach this, each with real tradeoffs.

Using child_process.spawn with FFmpeg

The most direct approach. Install FFmpeg on your system, then call it from Node.js:

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

const ffmpeg = spawn('ffmpeg', [
  '-i', 'input.mp4',
  '-c:v', 'libx264',
  '-crf', '23',
  '-preset', 'medium',
  '-c:a', 'aac',
  '-b:a', '192k',
  'output.mp4'
]);

ffmpeg.stderr.on('data', (data) => {
  console.log(`FFmpeg: ${data}`);
});

ffmpeg.on('close', (code) => {
  console.log(`FFmpeg exited with code ${code}`);
});

This works fine. But you're responsible for everything: installing FFmpeg on every machine that runs your code, parsing stderr for progress, handling errors when the binary isn't found, and making sure the right codecs are compiled in. On Docker, you're adding 80-200MB to your image just for the FFmpeg binary.

Using fluent-ffmpeg in Node.js

fluent-ffmpeg is the most popular Node.js wrapper for FFmpeg, with over 2 million weekly npm downloads. It gives you a chainable API instead of raw command-line arguments:

const ffmpeg = require('fluent-ffmpeg');

ffmpeg('input.mp4')
  .videoCodec('libx264')
  .audioCodec('aac')
  .size('1280x720')
  .on('end', () => console.log('Done'))
  .on('error', (err) => console.error('Error:', err.message))
  .save('output.mp4');

The API is cleaner, but fluent-ffmpeg still requires FFmpeg installed on the host machine. It's a wrapper, not a replacement. You'll also run into maintenance concerns. The GitHub repo has hundreds of open issues and updates are infrequent.

Running FFmpeg in the Browser with ffmpeg.wasm

ffmpeg.wasm compiles FFmpeg to WebAssembly, so it runs entirely in the browser or in Node.js without a native binary:

const { FFmpeg } = require('@ffmpeg/ffmpeg');

const ffmpeg = new FFmpeg();
await ffmpeg.load();
await ffmpeg.writeFile('input.mp4', inputData);
await ffmpeg.exec(['-i', 'input.mp4', '-c:v', 'libx264', 'output.mp4']);
const data = await ffmpeg.readFile('output.mp4');

No installation needed. But the tradeoffs are significant: processing speed is 10-20x slower than native FFmpeg, memory is limited (large files will crash the tab), and not all codecs are available in the WASM build. It works for lightweight client-side operations like trimming a clip or extracting a frame. Don't try to transcode a 2GB file with it.

Processing Video with a Cloud API (Zero Install)

If you don't want to manage FFmpeg binaries at all, you can offload video processing to a cloud API. FFmpeg Micro gives you full FFmpeg capabilities through simple HTTP requests:

const response = await fetch('https://api.ffmpeg-micro.com/v1/transcodes', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    inputs: [{ url: 'https://example.com/input.mp4' }],
    outputFormat: 'mp4',
    preset: { quality: 'high', resolution: '1080p' }
  })
});

const job = await response.json();
console.log(`Job ${job.id} queued, status: ${job.status}`);

No binary to install. No Docker image bloat. No memory management. You send a URL, pick your output format, and get results back. For advanced use cases, pass raw FFmpeg options instead of presets:

const response = await fetch('https://api.ffmpeg-micro.com/v1/transcodes', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    inputs: [{ url: 'https://example.com/input.mp4' }],
    outputFormat: 'webm',
    options: [
      { option: '-c:v', argument: 'libvpx-vp9' },
      { option: '-crf', argument: '30' },
      { option: '-b:v', argument: '0' }
    ]
  })
});

The API handles scaling, codec management, and infrastructure. You write a fetch call.

Which Approach Should You Use

child_process.spawn if you need full control and you're comfortable managing FFmpeg installations across all your environments.

fluent-ffmpeg if you want a nicer API on top of child_process and don't mind the native FFmpeg dependency.

ffmpeg.wasm if you need client-side processing for small files and can accept slower performance.

A cloud API like FFmpeg Micro if you want zero operational overhead, your app processes video at any scale, or you're deploying to serverless environments where installing FFmpeg isn't practical.

Common Pitfalls with FFmpeg in Node.js

Binary not found errors. The most common issue. Your code works locally but fails in CI or production because FFmpeg isn't in the PATH. With child_process and fluent-ffmpeg, always verify the binary exists before processing.

Memory spikes on large files. Spawning FFmpeg as a child process for a 2GB video can spike your Node.js process memory. Stream the output instead of buffering it all at once.

Codec mismatches. Your local FFmpeg build might include libx265 but the production server's build doesn't. Always run ffmpeg -codecs on your deployment target to confirm.

Silent failures. FFmpeg writes most of its output to stderr, not stdout. If you're only listening to stdout, you'll miss errors entirely.

Frequently Asked Questions

Do I need to install FFmpeg to use it with Node.js?

It depends on the approach. child_process and fluent-ffmpeg both require FFmpeg installed on the machine. ffmpeg.wasm bundles a WebAssembly version so no install is needed, but it's 10-20x slower. Cloud APIs like FFmpeg Micro handle processing entirely server-side, so your Node.js app never touches FFmpeg.

Is fluent-ffmpeg still maintained?

fluent-ffmpeg has over 2 million weekly npm downloads, but the GitHub repository has limited recent activity and hundreds of open issues. It works for common use cases, but you may hit edge cases that won't get patched quickly.

Can I use FFmpeg in a serverless function like AWS Lambda?

You can bundle a static FFmpeg binary in your deployment package. But Lambda functions have memory limits (256MB-10GB), execution time limits (15 minutes max), and cold start penalties from the large binary. A cloud API is a better fit for serverless architectures because you offload the heavy processing entirely.

What's the fastest way to add video processing to a Node.js app?

A cloud API gets you from zero to processing video in under 10 minutes. One fetch call. No installation, no configuration, no infrastructure. FFmpeg Micro's free tier gives you enough processing time to build and test your integration. For a deeper look at FFmpeg concepts, check out the Learn FFmpeg course.

How to Convert MP4 to GIF with FFmpeg (High Quality, Small File)

Javid Jamae — Fri, 01 May 2026 10:15:18 +0000

Originally published at ffmpeg-micro.com.

Converting an MP4 to a GIF with FFmpeg sounds simple until you actually try it. The default output is either a blurry mess or a 50MB file that nobody wants to load. The trick is knowing which FFmpeg flags control quality and file size independently.

The Basic Command (and Why It Looks Bad)

The most basic FFmpeg conversion looks like this:

ffmpeg -i input.mp4 output.gif

This technically works. But the result will look terrible.

GIFs are limited to 256 colors per frame. FFmpeg's default color selection doesn't pick the right 256 to keep, so you get banding, dithering artifacts, and washed-out colors. The file will also be massive because there's no compression optimization happening. A 10-second 1080p clip can easily produce a 100MB+ GIF.

High-Quality GIFs with Palette Generation

The fix is FFmpeg's palettegen and paletteuse filters. This two-pass approach first analyzes your video to build an optimal 256-color palette, then converts using that palette instead of guessing.

# Pass 1: Generate the optimal color palette
ffmpeg -i input.mp4 -vf "fps=10,scale=480:-1:flags=lanczos,palettegen" palette.png

# Pass 2: Convert using that palette
ffmpeg -i input.mp4 -i palette.png -filter_complex "fps=10,scale=480:-1:flags=lanczos[x];[x][1:v]paletteuse" output.gif

The difference is dramatic. Colors stay vibrant, gradients are smooth, and dithering artifacts mostly disappear.

What each flag does:

fps=10 reduces the frame rate from the source (usually 24-30fps) to 10fps, cutting file size significantly
scale=480:-1 resizes to 480px wide while maintaining aspect ratio
flags=lanczos uses Lanczos resampling for sharper downscaling
palettegen analyzes all frames and builds the best 256-color palette
paletteuse applies that palette during conversion

You can also do this in a single command using split to avoid the intermediate palette file:

ffmpeg -i input.mp4 -filter_complex "[0:v] fps=10,scale=480:-1:flags=lanczos,split [a][b];[a] palettegen [p];[b][p] paletteuse" output.gif

Same quality, one command, no temp files.

Controlling File Size

GIF files get big fast. Three things control the size: duration, resolution, and frame rate.

Trim to a specific clip with -ss (start time) and -t (duration):

ffmpeg -ss 00:00:05 -t 3 -i input.mp4 -filter_complex "[0:v] fps=10,scale=320:-1:flags=lanczos,split [a][b];[a] palettegen [p];[b][p] paletteuse" output.gif

This extracts 3 seconds starting at the 5-second mark.

Sizing reference:

Resolution	FPS	5s clip	10s clip
320px wide	10	~1-3MB	~2-6MB
480px wide	10	~3-6MB	~5-12MB
640px wide	15	~8-15MB	~15-30MB
1080px wide	24	~30-80MB	~60-150MB

For web use, 480px wide at 10fps is the sweet spot. Anything over 640px is usually overkill for a GIF.

Loop Control

GIFs loop forever by default. Control this with the -loop output option:

# Play 3 times then stop
ffmpeg -i input.mp4 -filter_complex "[0:v] fps=10,scale=480:-1:flags=lanczos,split [a][b];[a] palettegen [p];[b][p] paletteuse" -loop 3 output.gif

# Play once, no loop
ffmpeg -i input.mp4 -filter_complex "[0:v] fps=10,scale=480:-1:flags=lanczos,split [a][b];[a] palettegen [p];[b][p] paletteuse" -loop -1 output.gif

-loop 0 is infinite (the default). -loop -1 plays once. -loop N plays N+1 times total.

Common Pitfalls

The 256-color limit hits hardest on gradients and transitions. If your video has rapid color changes between scenes, you'll see color flickering. Adding dither=bayer:bayer_scale=5 to the paletteuse filter smooths this out: paletteuse=dither=bayer:bayer_scale=5.

GIF transparency is binary. No semi-transparent pixels. If you're converting video with an alpha channel, expect hard edges instead of smooth blending.

Audio gets silently dropped. GIFs don't support audio and FFmpeg won't warn you about it. If you need sound, stick with MP4 or WebM.

Skipping palette generation is the single biggest mistake. The quality difference between a naive conversion and the palette method is night and day. Always use palettegen + paletteuse unless file size truly doesn't matter.

Convert MP4 to GIF with an API

If you'd rather skip the FFmpeg installation and two-pass workflow, FFmpeg Micro converts videos to GIF with a single API call:

curl -X POST https://api.ffmpeg-micro.com/v1/transcodes \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "inputs": [{"url": "https://example.com/video.mp4"}],
    "outputFormat": "gif",
    "options": [
      {"option": "-vf", "argument": "fps=10,scale=480:-1:flags=lanczos"}
    ]
  }'

You get back a job ID, poll for completion, and download the result. No infrastructure to manage, no FFmpeg to install, no server resources to worry about when processing volume spikes.

Trim the source video before conversion with input-level options:

curl -X POST https://api.ffmpeg-micro.com/v1/transcodes \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "inputs": [{
      "url": "https://example.com/video.mp4",
      "options": [
        {"option": "-ss", "argument": "5"},
        {"option": "-t", "argument": "3"}
      ]
    }],
    "outputFormat": "gif",
    "options": [
      {"option": "-vf", "argument": "fps=10,scale=480:-1:flags=lanczos"}
    ]
  }'

FFmpeg Micro handles the infrastructure and auto-scales with your workload. Pay per minute of video processed, with a free tier to start. Create your free account to get an API key.

For a deeper dive on FFmpeg encoding fundamentals, check out the Learn FFmpeg course.

Frequently Asked Questions

What's the best resolution for a web GIF?

480px wide at 10fps works for most use cases. Short clips stay under 5MB, which loads quickly on any connection. Drop to 320px if the GIF is for chat or messaging apps where bandwidth matters more than detail.

Why does my FFmpeg GIF look grainy or washed out?

You're probably running ffmpeg -i input.mp4 output.gif without palette generation. FFmpeg's default color quantization produces poor results with only 256 colors to work with. The two-pass palettegen and paletteuse method described above fixes this completely.

Can I convert a GIF back to MP4 with FFmpeg?

Yes. Run ffmpeg -i input.gif -movflags faststart -pix_fmt yuv420p output.mp4. The MP4 will be much smaller because H.264 compression is far more efficient than GIF's LZW compression. Platforms like Twitter and Imgur convert uploaded GIFs to MP4 behind the scenes for this exact reason.

Is animated WebP better than GIF?

For most cases, yes. Animated WebP supports 24-bit color (16.7 million colors vs GIF's 256), produces smaller files at equivalent quality, and handles transparency with proper alpha blending. GIF's advantage is universal compatibility: it works in email clients, legacy browsers, and systems where WebP isn't supported.

How do I make a GIF from just part of a video?

Use -ss for the start time and -t for duration before the input: ffmpeg -ss 00:00:30 -t 5 -i input.mp4 output.gif. This grabs 5 seconds starting at the 30-second mark. Combine it with the palette method for the best quality.

How to Merge and Concatenate Videos with FFmpeg

Javid Jamae — Thu, 30 Apr 2026 10:10:54 +0000

Originally published at ffmpeg-micro.com

You need to join two or more video files into one. Maybe you're stitching together clips from a multi-camera shoot, assembling a highlight reel, or building an automated video pipeline. FFmpeg can do it, but the syntax trips up even experienced developers.

FFmpeg has three different ways to concatenate videos: the concat demuxer, the concat filter, and the concat protocol. Each one works differently, and picking the wrong one will give you corrupted output, missing audio, or a file that won't play. This guide covers all three methods, shows you when to use each, and includes working API examples so you can skip the CLI entirely.

The Concat Demuxer (Same Codec, Fastest Method)

The concat demuxer is the fastest way to merge videos because it doesn't re-encode. It copies the streams directly, which means zero quality loss and near-instant processing. The catch: all your input files need the same codec, resolution, and frame rate.

Create a text file listing your inputs:

# concat-list.txt
file 'clip1.mp4'
file 'clip2.mp4'
file 'clip3.mp4'

Then run:

ffmpeg -f concat -safe 0 -i concat-list.txt -c copy output.mp4

The -c copy flag tells FFmpeg to copy streams without re-encoding. The -safe 0 flag allows absolute file paths. This approach processes a 10-minute video in seconds because it's just copying data.

When the concat demuxer breaks

If your clips have different codecs (one is H.264, another is H.265), different resolutions, or different audio sample rates, the demuxer will either fail or produce a broken file. You won't always get a clear error message. Sometimes the output just freezes at the transition point between clips.

The Concat Filter (Different Codecs or Resolutions)

When your input files don't match, you need the concat filter. It re-encodes everything, which takes longer but handles mismatched inputs gracefully.

Here's how to merge two videos with different codecs:

ffmpeg \
  -i clip1.mp4 \
  -i clip2.mov \
  -filter_complex "[0:v][0:a][1:v][1:a]concat=n=2:v=1:a=1[v][a]" \
  -map "[v]" -map "[a]" \
  -c:v libx264 -crf 23 -preset medium \
  -c:a aac -b:a 192k \
  output.mp4

The n=2 tells FFmpeg you have 2 segments. v=1 means one video stream per segment, a=1 means one audio stream. If your clips don't have audio, drop the audio parts:

ffmpeg \
  -i clip1.mp4 \
  -i clip2.mp4 \
  -filter_complex "[0:v][1:v]concat=n=2:v=1[v]" \
  -map "[v]" \
  -c:v libx264 -crf 23 -preset medium \
  -an \
  output.mp4

Merging three or more videos

Scaling beyond two clips follows the same pattern. For three clips with audio:

ffmpeg \
  -i clip1.mp4 \
  -i clip2.mov \
  -i clip3.avi \
  -filter_complex "[0:v][0:a][1:v][1:a][2:v][2:a]concat=n=3:v=1:a=1[v][a]" \
  -map "[v]" -map "[a]" \
  -c:v libx264 -crf 23 \
  -c:a aac -b:a 192k \
  output.mp4

The Concat Protocol (MPEG-TS Only)

The concat protocol is the simplest syntax but the most limited. It only works with MPEG-TS files:

ffmpeg -i "concat:segment1.ts|segment2.ts|segment3.ts" -c copy output.ts

You'll rarely use this unless you're working with HLS segments or transport streams. For most video formats (MP4, MOV, WebM), use the demuxer or filter instead.

Which Method Should You Use?

Scenario	Method	Why
Same codec, resolution, frame rate	Concat demuxer	No re-encoding, fastest
Different codecs or resolutions	Concat filter	Handles mismatches, re-encodes
Need transitions (fade, slide)	Concat filter + xfade	Only filter supports transitions
MPEG-TS segments	Concat protocol	Simplest for transport streams
Automated pipeline	FFmpeg Micro API	No CLI, handles infrastructure

Concatenating Videos with the FFmpeg Micro API

If you're building a pipeline that merges videos programmatically, you don't need to manage FFmpeg on a server. FFmpeg Micro is a cloud API that lets you add video processing to any app with a single HTTP call. No FFmpeg installation, no server management.

The API accepts multiple inputs natively. Pass all your video URLs in the inputs array and use filters for the concat filter:

curl -X POST https://api.ffmpeg-micro.com/v1/transcodes \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "inputs": [
      {"url": "https://storage.example.com/clip1.mp4"},
      {"url": "https://storage.example.com/clip2.mp4"}
    ],
    "outputFormat": "mp4",
    "filters": [
      {"filter": "[0:v][0:a][1:v][1:a]concat=n=2:v=1:a=1[v][a]"}
    ],
    "options": [
      {"option": "-map", "argument": "[v]"},
      {"option": "-map", "argument": "[a]"}
    ]
  }'

For three clips, add another input and adjust the filter:

curl -X POST https://api.ffmpeg-micro.com/v1/transcodes \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "inputs": [
      {"url": "https://storage.example.com/clip1.mp4"},
      {"url": "https://storage.example.com/clip2.mp4"},
      {"url": "https://storage.example.com/clip3.mov"}
    ],
    "outputFormat": "mp4",
    "filters": [
      {"filter": "[0:v][0:a][1:v][1:a][2:v][2:a]concat=n=3:v=1:a=1[v][a]"}
    ],
    "options": [
      {"option": "-map", "argument": "[v]"},
      {"option": "-map", "argument": "[a]"}
    ]
  }'

The API supports up to 10 input files per request. Check job status with GET /v1/transcodes/{id} and download the result with GET /v1/transcodes/{id}/download.

Common Pitfalls When Concatenating Videos

Resolution mismatch silently fails. If you use the concat demuxer with files at different resolutions, the output might play fine in VLC but break on mobile or in browsers. Always check with ffprobe -v error -select_streams v:0 -show_entries stream=width,height on each input.

Audio channel mismatch causes sync drift. One clip in stereo, another in mono. FFmpeg won't always warn you. The output audio can go out of sync after the first transition. Fix it by normalizing audio channels before concatenating:

ffmpeg -i input.mp4 -ac 2 -c:v copy normalized.mp4

Missing audio stream crashes the concat filter. If one clip has audio and another doesn't, the concat filter fails because it expects the same number of streams per segment. Either add a silent audio track to the video-only clip or use v=1:a=0 and handle audio separately.

Container format matters. MP4 puts the moov atom at the end by default. If your pipeline streams the concatenated output, add -movflags +faststart to move the moov atom to the beginning so playback can start before the full download completes.

FAQ

Can I merge MP4 and MOV files with FFmpeg?

Yes. Use the concat filter (not the demuxer). The concat filter re-encodes both inputs into a common format, so different containers and codecs work fine. FFmpeg Micro handles this automatically when you pass multiple URLs in the inputs array with a concat filter.

What's the fastest way to join videos without re-encoding?

The concat demuxer with -c copy is the fastest method. It copies streams directly with zero quality loss. But all inputs must share the same codec, resolution, and frame rate. If they don't match, you'll need the concat filter, which re-encodes.

How do I add a fade transition between concatenated clips?

Use the xfade filter instead of concat. For a 1-second crossfade between two 10-second clips: [0:v][1:v]xfade=transition=fade:duration=1:offset=9[v]. FFmpeg supports over 30 transition types including fade, wipeleft, slidedown, and dissolve.

Does FFmpeg concat work with audio-only files?

Yes. The concat demuxer and filter both work with audio files like MP3, AAC, and WAV. For the filter, use a=1:v=0 to specify audio-only concatenation. The demuxer approach with -c copy works if all audio files share the same codec and sample rate.

How many videos can I concatenate at once?

FFmpeg itself has no hard limit. The concat demuxer handles hundreds of files via the file list. The concat filter gets complex beyond 5-10 inputs because you need to map every stream. FFmpeg Micro's API supports up to 10 inputs per request, which covers most production workflows.

For a deeper dive on FFmpeg filters and encoding fundamentals, check out the Learn FFmpeg course.

If you want to concatenate videos programmatically without managing FFmpeg servers, try FFmpeg Micro for free. Send a JSON request, get a merged video back.

How to Compress Video with FFmpeg Without Losing Quality

Javid Jamae — Wed, 29 Apr 2026 10:15:29 +0000

Originally published at ffmpeg-micro.com

You've got a 500MB video that needs to be 50MB. The catch? You can't make it look terrible. This is the most common FFmpeg problem developers run into, and the solution is simpler than you'd think.

FFmpeg gives you precise control over the quality-to-size tradeoff through a setting called CRF (Constant Rate Factor). Get it right, and you'll cut file sizes by 50-80% with no visible quality loss.

What Is CRF and Why Does It Matter for Video Compression?

CRF stands for Constant Rate Factor. It tells the encoder how much quality you're willing to sacrifice for a smaller file. Lower CRF = higher quality = bigger file. Higher CRF = lower quality = smaller file.

For H.264 (libx264), the CRF scale runs from 0 (lossless) to 51 (worst). The sweet spot for most developers is CRF 18-28:

CRF 18: Visually lossless. You won't see the difference from the original. Files are still large.
CRF 23: The default. Good balance between quality and size. Most projects should start here.
CRF 28: Noticeable quality loss on close inspection, but perfectly fine for web delivery and social media.

Every 6 CRF points roughly doubles or halves the file size. So going from CRF 18 to CRF 24 cuts your file size by about 75%.

How to Compress Video with FFmpeg Using CRF

The basic command is one line:

ffmpeg -i input.mp4 -c:v libx264 -crf 23 -c:a aac -b:a 128k output.mp4

That takes your input video, re-encodes it with H.264 at CRF 23, and compresses the audio to 128kbps AAC. For most 1080p content, this drops a 500MB file down to roughly 50-100MB.

Want better quality? Lower the CRF:

ffmpeg -i input.mp4 -c:v libx264 -crf 18 -preset slow -c:a aac -b:a 192k output.mp4

Presets control how much time FFmpeg spends optimizing compression. Slower presets produce smaller files at the same quality. In practice, slow gives you about 5-10% better compression than medium with a meaningful increase in encoding time.

H.264 vs H.265 vs AV1: Which Codec Should You Use?

The codec you choose has a bigger impact on file size than almost any other setting.

Codec	FFmpeg encoder	Size reduction vs H.264	Browser support
H.264	libx264	Baseline	Universal
H.265	libx265	25-50% smaller	Partial
AV1	libsvtav1	30-50% smaller	Chrome, Firefox, Edge

H.264 is the safe default. H.265 is great when you control playback. AV1 is the future but encoding is slow.

Two-Pass Encoding for Target File Size

Sometimes you need to hit a specific file size. Two-pass encoding analyzes the video first, then encodes with a target bitrate:

# Pass 1: Analyze
ffmpeg -i input.mp4 -c:v libx264 -b:v 3200k -pass 1 -an -f null /dev/null

# Pass 2: Encode
ffmpeg -i input.mp4 -c:v libx264 -b:v 3200k -pass 2 -c:a aac -b:a 128k output.mp4

Common Gotchas

CRF values mean different things for different codecs
Hardware encoding trades quality for speed
Don't re-encode already compressed video
Container format matters (MP4 vs WebM vs MKV)

Compress Video with the FFmpeg Micro API

If you don't want to manage FFmpeg servers, FFmpeg Micro handles compression with a single API call:

curl -X POST https://api.ffmpeg-micro.com/v1/transcodes \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "inputs": [{"url": "https://example.com/video.mp4"}],
    "outputFormat": "mp4",
    "options": [
      {"option": "-c:v", "argument": "libx264"},
      {"option": "-crf", "argument": "23"}
    ]
  }'

Read the full guide with more examples at ffmpeg-micro.com/blog.

How to Trim and Cut Video with FFmpeg (CLI + API Guide)

Javid Jamae — Tue, 28 Apr 2026 10:13:06 +0000

Originally published at ffmpeg-micro.com.

You need to extract a 30-second clip from a 2-hour video. Or trim the first 5 seconds of dead air. Or cut everything after the outro. FFmpeg handles all of this, but the syntax trips people up more than it should.

This guide covers every way to trim and cut video with FFmpeg, from basic -ss/-t flags to keyframe-accurate cutting. Then we'll show how to do the same thing with a single API call using FFmpeg Micro.

How to Trim Video with FFmpeg Using -ss and -t

The two core flags for trimming are -ss (seek to a start time) and -t (set the duration).

To extract 30 seconds starting at the 1-minute mark:

ffmpeg -ss 00:01:00 -t 00:00:30 -i input.mp4 -c copy output.mp4

Breaking this down:

-ss 00:01:00 seeks to 1 minute into the video
-t 00:00:30 limits the output to 30 seconds
-c copy copies the streams without re-encoding (fast, but see the gotchas below)

You can also use seconds instead of timestamps. This does the same thing:

ffmpeg -ss 60 -t 30 -i input.mp4 -c copy output.mp4

FFmpeg -ss Before vs After -i (This Matters)

Where you place -ss relative to -i changes how FFmpeg seeks.

Before -i (input seeking, fast):

ffmpeg -ss 00:01:00 -i input.mp4 -t 30 -c copy output.mp4

FFmpeg seeks to the nearest keyframe before your timestamp, then starts decoding. This is fast because it doesn't decode the entire file from the beginning.

After -i (output seeking, accurate):

ffmpeg -i input.mp4 -ss 00:01:00 -t 30 -c copy output.mp4

FFmpeg decodes from the start and discards frames until it hits your timestamp. Slower, but frame-accurate.

For most use cases, put -ss before -i. It's fast and accurate enough. If you need frame-perfect cuts (like editing dialogue), put it after -i and drop -c copy so FFmpeg re-encodes:

ffmpeg -i input.mp4 -ss 00:01:00 -t 30 -c:v libx264 -c:a aac output.mp4

How to Cut Video with FFmpeg Using -to

The -to flag specifies an end timestamp instead of a duration. To extract from 1:00 to 1:30:

ffmpeg -ss 00:01:00 -to 00:01:30 -i input.mp4 -c copy output.mp4

The difference between -t and -to: -t 30 means "30 seconds of output." -to 00:01:30 means "stop at the 1:30 mark of the input." If you use -ss with -to, the -to timestamp is relative to the seeked position when -ss is before -i.

Stream Copy vs Re-encode: The Trim Quality Tradeoff

When you trim with -c copy, FFmpeg doesn't re-encode. It just copies the compressed data. This is 10-100x faster, but there's a catch.

Video is compressed in groups of pictures (GOPs), and each GOP starts with a keyframe. When you seek to a specific time, the nearest keyframe might be a few seconds earlier. With -c copy, your trim point snaps to that keyframe, so the actual start time might not match your -ss value exactly.

If precise cuts matter, re-encode:

ffmpeg -ss 00:01:00 -t 30 -i input.mp4 -c:v libx264 -crf 23 -c:a aac -b:a 192k output.mp4

This decodes and re-encodes every frame, giving you an exact cut at the cost of processing time and a slight quality change.

When to use -c copy: Quick rough cuts, splitting long recordings, removing dead air at the start or end. Speed matters more than frame accuracy.

When to re-encode: Editing dialogue, creating clips for social media, any time a few extra frames at the start would look wrong.

Common Gotchas When Trimming with FFmpeg

Audio drift with stream copy. Some containers store audio and video with slightly different timebase references. When you -c copy a trim, the audio can shift by a fraction of a second relative to the video. Re-encoding fixes this, or you can re-encode just the audio: -c:v copy -c:a aac.

Container format matters. MP4 and MKV handle seeking differently. MP4 stores its index (moov atom) either at the start or end of the file. If the moov atom is at the end, FFmpeg has to read the entire file before it can seek. Use -movflags +faststart when outputting MP4 to move the moov atom to the front.

Negative timestamps. When trimming with -c copy and -ss before -i, FFmpeg might produce frames with negative timestamps. Add -avoid_negative_ts make_zero to fix this:

ffmpeg -ss 00:01:00 -t 30 -i input.mp4 -c copy -avoid_negative_ts make_zero output.mp4

Duration mismatch with -to and -ss before -i. When -ss appears before -i, the -to timestamp is relative to the seeked position, not the original file. So -ss 60 -to 90 gives you 30 seconds, not the segment from 1:00 to 1:30 as you might expect. If that's confusing, just use -t for duration instead.

How to Trim Video with FFmpeg Micro's API

All the examples above work great locally, but running FFmpeg on a server means managing binaries, scaling infrastructure, and handling edge cases yourself. FFmpeg Micro is a cloud API that handles all of this with a single HTTP request.

To trim a video to 30 seconds starting at the 1-minute mark:

curl -X POST https://api.ffmpeg-micro.com/v1/transcodes \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "inputs": [{"url": "https://example.com/video.mp4"}],
    "outputFormat": "mp4",
    "options": [
      {"option": "-ss", "argument": "00:01:00"},
      {"option": "-t", "argument": "30"},
      {"option": "-c", "argument": "copy"}
    ]
  }'

You can also pass -ss and -t as input-level options to get the fast input-seeking behavior:

curl -X POST https://api.ffmpeg-micro.com/v1/transcodes \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "inputs": [{
      "url": "https://example.com/video.mp4",
      "options": [
        {"option": "-ss", "argument": "00:01:00"},
        {"option": "-t", "argument": "30"}
      ]
    }],
    "outputFormat": "mp4",
    "options": [
      {"option": "-c", "argument": "copy"}
    ]
  }'

For frame-accurate trimming with re-encoding, drop the -c copy and specify codecs:

curl -X POST https://api.ffmpeg-micro.com/v1/transcodes \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "inputs": [{"url": "https://example.com/video.mp4"}],
    "outputFormat": "mp4",
    "options": [
      {"option": "-ss", "argument": "00:01:00"},
      {"option": "-t", "argument": "30"},
      {"option": "-c:v", "argument": "libx264"},
      {"option": "-crf", "argument": "23"},
      {"option": "-c:a", "argument": "aac"}
    ]
  }'

FFmpeg Micro handles the infrastructure, scaling, and edge cases. You get the full power of FFmpeg's trimming capabilities without managing servers.

For a deeper dive on FFmpeg encoding fundamentals, check out our Learn FFmpeg: Transcoding lesson.

FAQ

What's the difference between FFmpeg -t and -to?

-t sets a duration (how long the output should be). -to sets an end timestamp (where to stop). If you use -ss 60 -t 30, you get 30 seconds of output starting at the 1-minute mark. If you use -ss 60 -to 90, you also get 30 seconds, but -to 90 is interpreted relative to the seek position when -ss is placed before -i.

Can I trim video without re-encoding in FFmpeg?

Yes. Use -c copy to copy streams without re-encoding. This is fast but trims to the nearest keyframe, so the start point might be off by a few frames. For exact cuts, you need to re-encode with -c:v libx264 -c:a aac.

How do I trim the last 10 seconds off a video with FFmpeg?

First, get the total duration with ffprobe -v error -show_entries format=duration -of csv=p=0 input.mp4. Then use -t with the duration minus 10 seconds. There's no native "trim from end" flag in FFmpeg.

Does FFmpeg Micro support -to for trimming?

FFmpeg Micro supports -ss (seek) and -t (duration) for trimming. The -to flag is not currently in the supported options list. Use -t with the desired duration instead, which achieves the same result.

How do I trim multiple sections from a video?

You can't do it in a single FFmpeg command without -filter_complex. The simplest approach: run separate trim commands for each section, then concatenate the results. With FFmpeg Micro, you'd make separate API calls for each segment.

How to Compress Video with FFmpeg API (No Server Required)

Javid Jamae — Mon, 27 Apr 2026 10:10:57 +0000

Originally published at ffmpeg-micro.com.

You need to compress video in your app. Maybe users are uploading 500MB screen recordings. Maybe you're batch-processing marketing clips that need to be half their current size. Either way, you're staring down FFmpeg's compression flags and wondering how long this rabbit hole goes.

It doesn't have to be a rabbit hole. You can compress video with a single API call, no FFmpeg binary on your server, no worker queues, no guessing at CRF values.

Why Video Compression Gets Complicated Fast

FFmpeg is the gold standard for video compression. But "gold standard" comes with baggage. You need to pick the right codec (libx264, libx265, libvpx-vp9), choose a CRF value that balances quality against file size, decide on a resolution, and handle edge cases like variable frame rates or audio stream mismatches.

Then there's infrastructure. Running FFmpeg on a server means CPU-intensive processes that block other work. You either overprovision (expensive) or queue jobs and hope things don't back up. And if you're on a serverless platform like Vercel or Cloudflare Workers, you can't run FFmpeg at all.

Compress Video with FFmpeg Micro's API

FFmpeg Micro is a cloud API that lets you compress video with a single HTTP request. No FFmpeg installation, no server management. You send the video URL, specify the output format and quality, and get back a compressed file.

The simplest compression call looks like this:

curl -X POST https://api.ffmpeg-micro.com/v1/transcodes \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "inputs": [{"url": "https://example.com/large-video.mp4"}],
    "outputFormat": "mp4",
    "preset": {"quality": "medium", "resolution": "1080p"}
  }'

That's it. The API returns a job ID, and your video gets compressed in the cloud. You poll for status or set up a webhook, then download the result.

Quality presets map to FFmpeg CRF values under the hood: low (CRF 28, smallest files), medium (CRF 23, good balance), and high (CRF 18, near-lossless). If you've ever spent an afternoon testing CRF values, you know how much time this saves.

How to Reduce Video File Size with Custom FFmpeg Options

Presets cover 90% of use cases. But sometimes you need more control. Maybe you want VP9 encoding for WebM output, or you need a specific bitrate cap for streaming.

FFmpeg Micro's advanced mode lets you pass raw FFmpeg options:

curl -X POST https://api.ffmpeg-micro.com/v1/transcodes \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "inputs": [{"url": "https://example.com/large-video.mp4"}],
    "outputFormat": "webm",
    "options": [
      {"option": "-c:v", "argument": "libvpx-vp9"},
      {"option": "-crf", "argument": "30"},
      {"option": "-b:v", "argument": "0"}
    ]
  }'

This gives you full FFmpeg power without managing a single server. The API validates your options, runs the transcode on auto-scaling infrastructure, and handles cleanup.

Compress Video in Python (No FFmpeg Install)

If you're building in Python, the same API call works with requests:

import requests

response = requests.post(
    "https://api.ffmpeg-micro.com/v1/transcodes",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={
        "inputs": [{"url": "https://example.com/raw-upload.mp4"}],
        "outputFormat": "mp4",
        "preset": {"quality": "medium", "resolution": "720p"}
    }
)

job = response.json()
print(f"Job ID: {job['jobId']}")

No subprocess.run(["ffmpeg", ...]). No checking if FFmpeg is installed on the container. No dealing with stdout parsing to track progress.

Compress Video in Node.js Without a Server

Same idea in Node.js with fetch:

const response = await fetch("https://api.ffmpeg-micro.com/v1/transcodes", {
  method: "POST",
  headers: {
    "Authorization": "Bearer YOUR_API_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    inputs: [{ url: "https://example.com/raw-upload.mp4" }],
    outputFormat: "mp4",
    preset: { quality: "medium", resolution: "1080p" }
  })
});

const job = await response.json();
console.log(`Job ID: ${job.jobId}`);

This works in Next.js API routes, Express servers, Deno, Bun, or any environment that supports fetch. No native dependencies to install.

Uploading Videos Before Compression

If your video isn't already hosted at a public URL, upload it first using the three-step upload flow:

Get a presigned URL: POST /v1/upload/presigned-url with filename, contentType, and fileSize
Upload the file: PUT the file bytes to the returned uploadUrl
Confirm the upload: POST /v1/upload/confirm with filename and fileSize to get back a fileUrl

Use that fileUrl as the input URL in your transcode request. The whole flow takes four HTTP calls total: presigned URL, upload, confirm, transcode.

FFmpeg Video Compression API vs. Self-Hosted FFmpeg

Running FFmpeg yourself means managing servers, scaling workers, and debugging codec issues at 3am. FFmpeg Micro handles all of that. You pay per minute of video processed, starting with a free tier.

	Self-Hosted FFmpeg	FFmpeg Micro API
Setup time	Hours to days	Minutes
Infrastructure	Your servers, your problem	Auto-scaling cloud
Codec updates	Manual	Automatic
Cost model	Fixed server costs	Pay per use
Scaling	Manual provisioning	Automatic

For teams processing fewer than 10,000 videos a month, the API approach is almost always cheaper than running your own infrastructure. And you skip the maintenance entirely.

FAQ

Can I compress video without installing FFmpeg?

Yes. FFmpeg Micro is a cloud API that runs FFmpeg on managed infrastructure. You send an HTTP request with your video URL and compression settings, and get back a compressed file. No local FFmpeg installation needed.

What video formats does FFmpeg Micro support for compression?

FFmpeg Micro supports MP4, WebM, AVI, MOV, MKV, and FLV for video output. Audio formats include MP3, M4A, AAC, WAV, OGG, Opus, and FLAC. You can convert between formats and compress in the same request.

How do I choose the right compression quality?

Use the quality preset: low for maximum compression (smallest files), medium for a balanced tradeoff, and high for near-original quality. If you need exact control, pass raw FFmpeg options like -crf 23 directly through the API.

Is there a free tier for video compression?

Yes. FFmpeg Micro includes a free tier so you can test compression without committing. Sign up at ffmpeg-micro.com and get an API key in minutes.

Can I batch compress multiple videos?

You can submit multiple transcode requests in parallel. Each request processes independently on auto-scaling infrastructure, so compressing 100 videos takes roughly the same time as compressing one.

Sign up for FFmpeg Micro and compress your first video in minutes. No server setup, no FFmpeg installation, no infrastructure to manage.

How to Process Video with a JSON API (FFmpeg Micro Request Examples)

Javid Jamae — Sun, 26 Apr 2026 10:12:26 +0000

Originally published at ffmpeg-micro.com.

You want to process video in your app, but you don't want to install FFmpeg, wrangle dependencies, or manage a transcoding server. You just want to send some JSON and get a result back. That's exactly what FFmpeg Micro does.

This post walks through real JSON request payloads for the most common video operations: compressing, converting formats, adding text overlays, and using custom FFmpeg options. Every example uses the actual FFmpeg Micro API, and every request is a single HTTP call.

How the FFmpeg Micro JSON API Works

FFmpeg Micro is a cloud API that lets you add video processing to any app with a single HTTP call. No FFmpeg installation, no server management.

The core endpoint is POST /v1/transcodes. You send a JSON body with your input video URL, the output format you want, and optionally a preset or custom FFmpeg options. The API returns a job ID, and you poll for the result.

Every request needs an Authorization: Bearer <YOUR_API_KEY> header. You get an API key when you sign up for a free account at ffmpeg-micro.com.

Compress a Video (Simple Preset Mode)

Most developers start here. You have a large MP4 and you need a smaller one. With the preset mode, you don't need to know any FFmpeg flags.

{
  "inputs": [{"url": "https://example.com/raw-video.mp4"}],
  "outputFormat": "mp4",
  "preset": {
    "quality": "medium",
    "resolution": "720p"
  }
}

Send that to POST /v1/transcodes and you get back a job object with an id. The quality field maps to FFmpeg's CRF values: low (CRF 28, smallest file), medium (CRF 23, balanced), and high (CRF 18, best quality). Resolution options are 480p, 720p, and 1080p.

The response looks like this:

{
  "id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
  "status": "processing",
  "outputFormat": "mp4"
}

Poll GET /v1/transcodes/{id} until status is completed, then hit GET /v1/transcodes/{id}/download to get a signed download URL.

Convert Video Format (MP4 to WebM)

Format conversion is one line different. Change outputFormat and the API handles codec selection automatically.

{
  "inputs": [{"url": "https://example.com/video.mp4"}],
  "outputFormat": "webm"
}

FFmpeg Micro supports MP4, WebM, AVI, MOV, MKV, and FLV for video. For audio, you can output to MP3, M4A, AAC, WAV, OGG, Opus, and FLAC. Image extraction supports JPEG, PNG, GIF, and WebP.

No preset means the API uses sensible defaults for the target format.

Advanced Mode: Custom FFmpeg Options

Presets cover the common cases, but sometimes you need full control. The options array lets you pass raw FFmpeg flags as key-value pairs.

To compress with a specific codec and bitrate:

{
  "inputs": [{"url": "https://example.com/video.mp4"}],
  "outputFormat": "mp4",
  "options": [
    {"option": "-c:v", "argument": "libx264"},
    {"option": "-crf", "argument": "20"},
    {"option": "-c:a", "argument": "aac"},
    {"option": "-b:a", "argument": "128k"}
  ]
}

This gives you the same flexibility as a raw FFmpeg command line, but without the server. The API validates your options before processing, so you get clear error messages if something is wrong.

Add a Text Overlay with Virtual Options

FFmpeg Micro has "virtual options" for operations that would normally require complex filter chains. The @text-overlay virtual option adds text to your video with a single request.

{
  "inputs": [{"url": "https://example.com/video.mp4"}],
  "outputFormat": "mp4",
  "options": [
    {"option": "@text-overlay", "argument": "{\"text\": \"Subscribe!\", \"position\": \"bottom-center\", \"fontSize\": 48, \"fontColor\": \"white\"}"}
  ]
}

No filter graph syntax. No escaped colons. Just a JSON string describing what you want. The API translates it to the correct FFmpeg drawtext filter internally.

Upload Your Own Files First

The examples above use public HTTP URLs for the input video. If you need to process a file from your local system or a private source, use the three-step upload flow:

Step 1: Request a presigned upload URL.

curl -X POST https://www.ffmpeg-micro.com/v1/upload/presigned-url \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"filename": "my-video.mp4", "contentType": "video/mp4", "fileSize": 10485760}'

Step 2: PUT your file to the returned uploadUrl (direct to cloud storage).

Step 3: Confirm the upload to get a fileUrl you can use in your transcode request.

curl -X POST https://www.ffmpeg-micro.com/v1/upload/confirm \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"filename": "my-video.mp4", "fileSize": 10485760}'

The fileUrl from Step 3 is a gs:// URL you pass as the url in your inputs array.

Putting It All Together with cURL

A complete cURL example that compresses a video to 720p:

curl -X POST https://www.ffmpeg-micro.com/v1/transcodes \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "inputs": [{"url": "https://example.com/video.mp4"}],
    "outputFormat": "mp4",
    "preset": {"quality": "medium", "resolution": "720p"}
  }'

One HTTP call, and your video is being processed in the cloud. No FFmpeg binary, no Docker container, no scaling headaches.

CLI vs. JSON API: A Quick Comparison

If you're used to FFmpeg on the command line, the mental model shift looks like this:

FFmpeg CLI	FFmpeg Micro JSON API
`ffmpeg -i input.mp4 -c:v libx264 -crf 23 output.mp4`	`{"inputs": [{"url": "..."}], "outputFormat": "mp4", "options": [{"option": "-c:v", "argument": "libx264"}, {"option": "-crf", "argument": "23"}]}`
Install FFmpeg on every machine	One API key, works from anywhere
Scale = more servers	Scale = more API calls
Debug FFmpeg errors yourself	API validates options before processing

The JSON is more verbose, but it's also portable. Any language or platform that can make HTTP requests can process video. That includes no-code tools like Make.com and n8n, not just backend services.

Frequently Asked Questions

Can I process video from any URL or only uploaded files?

Both. You can pass any public HTTP/HTTPS URL as the input, or upload files through the presigned URL flow to get a private gs:// URL. Most developers start with public URLs for testing and switch to uploads for production.

What happens if I send invalid FFmpeg options?

The API validates your options before starting the job. You get a 400 error with a clear description of what went wrong, instead of a cryptic FFmpeg stderr dump.

How do I check if my video is done processing?

Poll GET /v1/transcodes/{id}. The status field will be processing, completed, or failed. For completed jobs, GET /v1/transcodes/{id}/download returns a signed URL to grab the output file.

Is there a free tier?

Yes. Sign up at ffmpeg-micro.com and you get free processing minutes to test the API. Paid plans start at $19/month for production workloads.

What formats does the API support?

Video: MP4, WebM, AVI, MOV, MKV, FLV. Audio: MP3, M4A, AAC, WAV, OGG, Opus, FLAC. Images: JPEG, PNG, GIF, WebP. You can also extract audio from video or generate thumbnails.

Self-Hosting FFmpeg vs. Using an API: What Developers Get Wrong

Javid Jamae — Sat, 25 Apr 2026 10:11:03 +0000

Originally published at ffmpeg-micro.com

You spun up a Docker container, installed FFmpeg, and got your first video to transcode. It works. Ship it, right?

Not so fast. Self-hosting FFmpeg feels simple at first. But the gap between "it works on my machine" and "it works in production at 3am when traffic spikes" is where most teams get burned.

The Docker Image Problem

A minimal FFmpeg Docker image starts around 80MB. That's the version without most codecs. Once you add libx264, libx265, libvpx, and audio codecs like AAC and Opus, you're looking at 300-500MB images. Some teams end up with 1GB+ images after adding font rendering for subtitles or hardware acceleration libraries.

Every deploy pulls that image. Every autoscale event pulls that image. At scale, your container registry becomes a bottleneck you never planned for.

And that's before codec licensing enters the picture. H.264 and H.265 are patent-encumbered. If you're encoding video commercially with self-hosted FFmpeg, you technically owe royalties to the MPEG-LA patent pool. Most startups ignore this. Some get letters from lawyers.

Scaling Is Not Just "Add More Containers"

Video processing is CPU-intensive. A single 1080p transcode can peg an entire core for minutes. If three users upload simultaneously, you need three cores available right now, not in 90 seconds when Kubernetes finishes pulling your 500MB image.

The typical self-hosted setup looks like this: a queue (Redis or SQS), a pool of workers, and a prayer that the queue doesn't back up during peak hours. You end up building retry logic, dead letter queues, progress tracking, and health checks. That's weeks of engineering work before you process a single production video.

Compare that to an API call:

curl -X POST https://api.ffmpeg-micro.com/v1/transcodes \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "inputs": [{"url": "https://storage.example.com/raw-upload.mp4"}],
    "outputFormat": "mp4",
    "preset": {"quality": "high", "resolution": "1080p"}
  }'

That's it. No worker pool. No queue. No container orchestration. FFmpeg Micro handles the scaling, the codec licensing, and the infrastructure. You get back a job ID, poll for completion, and download the result.

Library Drift Will Bite You

FFmpeg releases new versions constantly. Your Docker image pins a specific version, which means you're responsible for tracking security patches, codec updates, and breaking changes. Skip an update for six months and you'll find that the bug you're debugging was fixed three releases ago.

Worse, different FFmpeg builds have different codec support. An image built on Ubuntu might behave differently than one built on Alpine. A filter that works locally might fail in CI because the CI image was built with a different configuration flag. I've seen teams spend days debugging transcoding failures that turned out to be a missing --enable-libfreetype flag in their Docker build.

With an API, you don't think about any of this. The service maintains the FFmpeg version, the codec support, and the build configuration. Your code stays the same.

When Self-Hosting Actually Makes Sense

Self-hosting isn't always wrong. If you process millions of videos per month and have a dedicated infrastructure team, running your own FFmpeg cluster can be cost-effective. If you need custom FFmpeg patches or exotic codecs that no API supports, self-hosting is your only option.

But for most teams building a SaaS product, a content platform, or an automation workflow, self-hosting FFmpeg is a distraction. You don't self-host your database anymore. You don't self-host your email delivery. Video processing shouldn't be different.

What a Cloud FFmpeg API Actually Gives You

When you use a service like FFmpeg Micro instead of self-hosting, you're not just outsourcing compute. You're skipping an entire category of problems:

No Docker images to maintain. No 500MB pulls, no codec licensing headaches, no Alpine-vs-Ubuntu debugging.
Automatic scaling. Ten videos or ten thousand. The API handles it.
No worker infrastructure. No Redis queues, no dead letter handling, no retry logic to build.
Always-current codecs. H.264, H.265, VP9, AV1, Opus. All supported, all licensed.
Pay per job, not per server. No idle instances burning money at 2am.

For advanced use cases, you still get full FFmpeg power. Pass raw FFmpeg options directly:

curl -X POST https://api.ffmpeg-micro.com/v1/transcodes \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "inputs": [{"url": "https://storage.example.com/raw-upload.mp4"}],
    "outputFormat": "webm",
    "options": [
      {"option": "-c:v", "argument": "libvpx-vp9"},
      {"option": "-crf", "argument": "30"},
      {"option": "-b:v", "argument": "0"},
      {"option": "-c:a", "argument": "libopus"}
    ]
  }'

Same flexibility as running FFmpeg yourself. None of the infrastructure overhead.

FAQ

Is self-hosted FFmpeg free?

FFmpeg itself is open source, but running it in production isn't free. You pay for compute, storage, container orchestration, and engineer time. H.264 and H.265 encoding also carries patent licensing obligations for commercial use.

Can I use FFmpeg in Docker without managing infrastructure?

You can use a cloud FFmpeg API like FFmpeg Micro to skip Docker entirely. Send an HTTP request with your video URL and desired output format, and the service handles everything. Works from any language, any platform, including no-code tools like n8n and Make.com.

How does FFmpeg Micro compare to AWS MediaConvert?

FFmpeg Micro gives you FFmpeg's full power at API-call pricing, without the complexity and cost of AWS MediaConvert. MediaConvert requires IAM roles, S3 bucket policies, and CloudWatch monitoring. FFmpeg Micro requires one API key and one HTTP call.

What's the biggest risk of self-hosting FFmpeg?

The biggest risk is maintenance burden creeping up over time. Codec updates, security patches, Docker image bloat, and scaling challenges all compound. Most teams underestimate the ongoing cost by 3-5x compared to initial setup.

FFmpeg Micro is a cloud API that lets you add video processing to any app with a single HTTP call. No FFmpeg installation, no server management. Try the free tier and run your first transcode in under five minutes.

How to Merge Audio and Video with FFmpeg (CLI and API)

Javid Jamae — Fri, 24 Apr 2026 10:12:14 +0000

Originally published at ffmpeg-micro.com

You have a video file and a separate audio file. Maybe it's an AI voiceover you generated with ElevenLabs. Maybe it's a podcast intro you recorded separately. Either way, you need to combine them into one file, and FFmpeg is the tool that does it.

The problem? FFmpeg's muxing syntax is confusing. You need -map, -shortest, codec flags, and a server to run it on. If you're building this into an app or automation, you also need to figure out scaling, error handling, and file storage.

You can skip all of that with an API call.

What does "muxing" actually mean in FFmpeg?

Muxing (short for multiplexing) is the process of combining separate media streams into a single container file. When you merge an audio track with a video track, you're muxing them together into one MP4, WebM, or MKV file.

FFmpeg handles this with the -map flag, which tells it which streams to pull from which inputs. A typical CLI command looks like this:

ffmpeg -i video.mp4 -i voiceover.mp3 -map 0:v:0 -map 1:a:0 -c:v libx264 -c:a aac -shortest -y output.mp4

That command takes the video stream from the first input and the audio stream from the second input, then combines them. The -shortest flag cuts the output to match whichever input is shorter, so you don't get trailing silence or a frozen frame.

It works. But deploying this on a server, handling file uploads, and managing FFmpeg installations across environments is where things get painful.

How to merge audio and video with the FFmpeg Micro API

FFmpeg Micro is a cloud API that lets you run FFmpeg operations with a single HTTP call. No FFmpeg installation, no server management. You send your files, specify the operation, and get the result back.

For muxing, you pass two inputs (your video and your audio) and use the options array to control how the streams are mapped.

Step 1: Upload your files

FFmpeg Micro uses a 3-step upload flow. First, get a presigned URL. Then upload your file directly. Then confirm the upload.

# Get presigned URL for the video
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": "video.mp4", "contentType": "video/mp4", "fileSize": 15000000}'

# Upload to the returned URL
curl -X PUT "PRESIGNED_URL_FROM_RESPONSE" \
  -H "Content-Type: video/mp4" \
  --data-binary @video.mp4

# Confirm the upload
curl -X POST https://api.ffmpeg-micro.com/v1/upload/confirm \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"filename": "video.mp4", "fileSize": 15000000}'

Repeat for your audio file. Each confirm response returns a fileUrl (a gs:// URL) that you'll use in the transcode request.

Step 2: Run the mux job

Now send both files to the transcode endpoint with -map options to control which streams go where:

POST /v1/transcodes
Authorization: Bearer YOUR_API_KEY

{
  "inputs": [
    {"url": "gs://your-bucket/video.mp4"},
    {"url": "gs://your-bucket/voiceover.mp3"}
  ],
  "outputFormat": "mp4",
  "options": [
    {"option": "-map", "argument": "0:v:0"},
    {"option": "-map", "argument": "1:a:0"},
    {"option": "-c:v", "argument": "libx264"},
    {"option": "-c:a", "argument": "aac"},
    {"option": "-shortest", "argument": ""}
  ]
}

This does exactly what the CLI command does, but without any server setup. The API accepts up to 10 inputs per job, so you could mux multiple audio tracks or combine several video segments in one request.

Step 3: Download the result

Poll the job status until it's complete, then grab the download URL:

# Check job status
curl https://api.ffmpeg-micro.com/v1/transcodes/JOB_ID \
  -H "Authorization: Bearer YOUR_API_KEY"

# Get download URL when status is "completed"
curl https://api.ffmpeg-micro.com/v1/transcodes/JOB_ID/download \
  -H "Authorization: Bearer YOUR_API_KEY"

The download endpoint returns a signed URL. Your file is ready.

Common muxing scenarios developers run into

Replacing audio on a video. This is the most common case. You have a screen recording or stock footage and need to swap in a different audio track. The -map 0:v:0 -map 1:a:0 pattern handles this.

Adding a voiceover to a silent video. Same approach, but your source video has no audio track at all. FFmpeg doesn't care. It pulls the video from input 0 and audio from input 1 regardless.

Keeping original audio and adding a second track. If you want both the original audio and a new track (like background music), you'd adjust the mapping to include both audio streams. That's a more advanced use case involving -filter_complex amix, but the API supports it through the options array.

Why not just run FFmpeg on your server?

You can. Plenty of teams do. But if you're building this into a product or automation, you'll hit a few walls:

FFmpeg takes 500MB+ of disk space and has platform-specific dependencies
Video processing is CPU-intensive. One mux job won't kill your server, but ten concurrent ones will
Error handling for FFmpeg processes is tedious. Exit codes, stderr parsing, timeout management
File storage and cleanup become your problem

FFmpeg Micro handles all of this. You pay per minute of video processed, and the infrastructure scales automatically. For a 1-minute video mux job, you're looking at a few seconds of processing time and a fraction of a cent.

FAQ

Can I merge audio and video files that are different lengths?

Yes. Use the -shortest option to cut the output to the shorter input's duration. Without it, FFmpeg will pad the shorter stream. In the API, add {"option": "-shortest", "argument": ""} to your options array.

What audio formats work with FFmpeg muxing?

FFmpeg supports MP3, AAC, WAV, OGG, FLAC, Opus, and M4A. FFmpeg Micro supports all of these as inputs. For the output container, MP4 works best with AAC audio, and WebM works best with Opus.

Do I need to re-encode the video when muxing?

Not always. If you use -c:v copy instead of -c:v libx264, FFmpeg copies the video stream without re-encoding. This is faster but only works if the codec is compatible with the output container. MP4 in, MP4 out with H.264 is a safe bet for stream copying.

How many inputs can I combine in one API call?

FFmpeg Micro accepts up to 10 inputs per transcode job. You can mux multiple audio tracks, combine video segments, or mix and match. Each input gets its own index for -map references.

Is there a file size limit?

FFmpeg Micro supports files up to 500MB on the free tier. Paid plans handle larger files. Check the pricing page for current limits.

Sign up for a free FFmpeg Micro account and try muxing your first audio and video file. The free tier includes 10 minutes of processing per month, which is plenty for testing.

How to Use FFmpeg in Python Without Installing It

Javid Jamae — Thu, 23 Apr 2026 14:58:12 +0000

Originally published at ffmpeg-micro.com

You've written a Python script that processes video. It works on your laptop. You deploy it to Lambda (or Render, or Vercel) and get the dreaded error: FileNotFoundError: [Errno 2] No such file or directory: 'ffmpeg'.

The problem is simple: FFmpeg is a system binary, and most cloud platforms don't ship it. The typical fix involves Docker layers, custom build packs, or static binaries crammed into a Lambda layer. It works, but it's fragile and annoying to maintain.

There's a better approach. Instead of installing FFmpeg on every platform, call it as an API. Python's requests library is all you need.

The Subprocess Approach (And Why It Breaks)

Most Python FFmpeg tutorials show something like this:

import subprocess

subprocess.run([
    "ffmpeg", "-i", "input.mp4",
    "-c:v", "libx264", "-crf", "23",
    "output.mp4"
])

Locally, this is fine. But it assumes FFmpeg is installed at the OS level. On AWS Lambda, Google Cloud Functions, Vercel serverless functions, or any container without FFmpeg pre-installed, this fails instantly.

The workarounds are all painful:

Lambda layers with a static FFmpeg binary (70MB+ zip, architecture-specific)
Docker images with apt-get install ffmpeg in the Dockerfile
Python wrappers like ffmpeg-python or imageio-ffmpeg that still need the binary underneath

Every one of these adds deployment complexity. And when FFmpeg updates or you switch platforms, you're rebuilding the whole thing.

Using FFmpeg as an API from Python

FFmpeg Micro is a cloud API that runs FFmpeg for you. One HTTP call, and your Python code can transcode, resize, or watermark video. No binary, no Docker, no Lambda layer.

The entire integration is just Python's requests library:

import requests

API_KEY = "your-api-key"
BASE_URL = "https://api.ffmpeg-micro.com"

response = requests.post(
    f"{BASE_URL}/v1/transcodes",
    headers={"Authorization": f"Bearer {API_KEY}"},
    json={
        "inputs": [{"url": "https://example.com/video.mp4"}],
        "outputFormat": "mp4",
        "preset": {"quality": "medium", "resolution": "720p"}
    }
)

job = response.json()
print(f"Job ID: {job['jobId']}")

That's it. No subprocess, no binary, no system dependency. This runs the same way on Lambda, Render, Vercel, your laptop, or anywhere Python runs.

Checking Job Status and Downloading Results

Transcoding takes a few seconds to a few minutes depending on file size. Poll the job status:

import time

job_id = job["jobId"]

while True:
    status_response = requests.get(
        f"{BASE_URL}/v1/transcodes/{job_id}",
        headers={"Authorization": f"Bearer {API_KEY}"}
    )
    status = status_response.json()

    if status["status"] == "completed":
        print("Done!")
        break
    elif status["status"] == "failed":
        print(f"Failed: {status.get('error')}")
        break

    time.sleep(2)

Once complete, grab the download URL:

download_response = requests.get(
    f"{BASE_URL}/v1/transcodes/{job_id}/download",
    headers={"Authorization": f"Bearer {API_KEY}"}
)

download_url = download_response.json()["url"]
print(f"Download: {download_url}")

Advanced: Custom FFmpeg Options

The preset mode covers most cases, but you can pass raw FFmpeg options for full control:

response = requests.post(
    f"{BASE_URL}/v1/transcodes",
    headers={"Authorization": f"Bearer {API_KEY}"},
    json={
        "inputs": [{"url": "https://example.com/video.mp4"}],
        "outputFormat": "webm",
        "options": [
            {"option": "-c:v", "argument": "libvpx-vp9"},
            {"option": "-crf", "argument": "30"},
            {"option": "-b:v", "argument": "0"},
            {"option": "-c:a", "argument": "libopus"}
        ]
    }
)

This converts MP4 to WebM using VP9 and Opus codecs. The same FFmpeg flags you'd use on the command line, just passed as structured data.

Uploading Files First

If your video isn't already hosted at a public URL, upload it through the API first. It's a three-step process:

# Step 1: Get a presigned upload URL
presign = requests.post(
    f"{BASE_URL}/v1/upload/presigned-url",
    headers={"Authorization": f"Bearer {API_KEY}"},
    json={
        "filename": "my-video.mp4",
        "contentType": "video/mp4",
        "fileSize": 15000000
    }
).json()

# Step 2: Upload directly to cloud storage
with open("my-video.mp4", "rb") as f:
    requests.put(
        presign["uploadUrl"],
        headers={"Content-Type": "video/mp4"},
        data=f
    )

# Step 3: Confirm the upload
confirm = requests.post(
    f"{BASE_URL}/v1/upload/confirm",
    headers={"Authorization": f"Bearer {API_KEY}"},
    json={
        "filename": presign["filename"],
        "fileSize": 15000000
    }
).json()

# Now use the file URL for transcoding
file_url = confirm["fileUrl"]

The fileUrl from the confirm step is what you pass in the inputs array when creating a transcode job.

When to Use an API vs. Local FFmpeg

Local FFmpeg still makes sense for some cases. If you're running batch processing on a dedicated server that you control, a local install is simpler and cheaper at high volumes.

But if you're building a web app, running serverless functions, or deploying to platforms where you don't control the OS, an API removes an entire category of deployment problems. You also don't have to think about FFmpeg version mismatches, codec availability, or scaling compute for video-heavy workloads.

FFmpeg Micro has a free tier with 10 minutes of processing per month. Enough to build and test your integration before you commit to anything. Sign up and get your API key to try the examples above.

n8n Execute Command Node vs. FFmpeg API: Why Cloud Users Are Switching

Javid Jamae — Wed, 22 Apr 2026 10:11:12 +0000

Originally published at ffmpeg-micro.com.

You built a video processing workflow in n8n using the Execute Command node. It worked on your laptop. Then you deployed to n8n Cloud and nothing happened.

That's because n8n Cloud doesn't include FFmpeg. And even if you're self-hosting, the Execute Command node is disabled by default since n8n v2.0 for security reasons. You can re-enable it, but now you're maintaining a custom Docker image with FFmpeg baked in, managing dependencies, and hoping nothing breaks on the next update.

There's a simpler approach: skip Execute Command entirely and call an FFmpeg API from an HTTP Request node.

Why the Execute Command Node Breaks for FFmpeg

The Execute Command node runs shell commands on the n8n server. For FFmpeg, that means the server needs FFmpeg installed, enough CPU and RAM to process video, and disk space for temp files.

On n8n Cloud, this is a non-starter. The hosted environment doesn't ship FFmpeg, and you can't install system packages. Your workflow just fails silently or throws a "command not found" error.

On self-hosted n8n, you have two problems. First, the Execute Command node is disabled by default in n8n v2.0 and later. The n8n team locked it down because arbitrary shell execution is a security risk in shared environments. You need to set the NODES_EXCLUDE environment variable or use N8N_COMMUNITY_PACKAGES_ALLOW_TOOL_USAGE=true plus additional config to re-enable it.

Second, even after re-enabling it, you need FFmpeg on the server. The official n8n Docker image doesn't include it. So you're building a custom Dockerfile, installing FFmpeg, keeping it updated, and making sure your server has enough resources to handle video transcoding alongside your n8n workflows.

If you're processing one video a week, that might be fine. If you're building anything production-grade, it becomes a maintenance headache fast.

How an FFmpeg API Replaces Execute Command

Instead of running FFmpeg on your n8n server, you offload the processing to a cloud API. The workflow stays in n8n, but the heavy lifting happens somewhere else.

FFmpeg Micro is a cloud API built specifically for this. One HTTP request, and your video gets processed on auto-scaling infrastructure. No FFmpeg install. No Docker customization. Works on n8n Cloud and self-hosted identically.

The pattern is simple: replace your Execute Command node with an HTTP Request node that calls the FFmpeg Micro API.

Setting Up FFmpeg Processing in n8n (Without Execute Command)

You need two things: an FFmpeg Micro API key (free tier available at ffmpeg-micro.com) and an HTTP Request node in your n8n workflow.

Start a Transcode Job

Add an HTTP Request node with these settings:

Method: POST
URL: https://api.ffmpeg-micro.com/v1/transcodes
Authentication: Header Auth, name Authorization, value Bearer YOUR_API_KEY
Body (JSON):

{
  "inputs": [{"url": "https://your-bucket.s3.amazonaws.com/video.mp4"}],
  "outputFormat": "mp4",
  "preset": {"quality": "medium", "resolution": "720p"}
}

The inputs field takes an array of objects, each with a url pointing to your source video. The API supports MP4, WebM, MOV, AVI, MKV, and more.

For finer control, swap preset for raw FFmpeg options:

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

This gives you the same power as a raw FFmpeg command line, without installing anything.

Check Job Status

Add a second HTTP Request node (or use a loop with a Wait node):

Method: GET
URL: https://api.ffmpeg-micro.com/v1/transcodes/{{ $json.jobId }}
Authentication: Same Bearer token

The response includes status (queued, processing, completed, failed) and a progress percentage. When status is completed, the output is ready for download.

Download the Result

Method: GET
URL: https://api.ffmpeg-micro.com/v1/transcodes/{{ $json.jobId }}/download
Authentication: Same Bearer token

This returns a signed download URL for your processed video.

n8n Execute Command vs. FFmpeg API: Side by Side

Factor	Execute Command + FFmpeg	HTTP Request + FFmpeg Micro
n8n Cloud	Not supported	Works out of the box
n8n v2.0+	Disabled by default	No restrictions
FFmpeg install	Required on server	Not needed
Server resources	CPU/RAM used for processing	Offloaded to cloud
Scaling	Limited by server capacity	Auto-scales
Maintenance	Custom Docker image, updates	Zero
Setup time	Hours (Docker, FFmpeg, config)	Minutes (API key + HTTP node)

When to Keep Using Execute Command

If you're running n8n self-hosted, have FFmpeg installed already, and your processing volume is low and predictable, Execute Command still works. It's free (beyond your server costs) and keeps everything local.

But the moment you hit any of these, it's time to switch: deploying to n8n Cloud, processing more than a handful of videos per day, needing consistent output quality across different input formats, or wanting your workflow to survive an n8n version upgrade without breaking.

FAQ

Can I install FFmpeg on n8n Cloud?

No. n8n Cloud is a managed environment and you can't install system packages. The only way to use FFmpeg from n8n Cloud is through an external API like FFmpeg Micro.

Is the Execute Command node safe to re-enable?

It depends on your setup. The n8n team disabled it by default in v2.0 because arbitrary shell execution is a security risk, especially in multi-user environments. If you're the only user on a locked-down server, the risk is lower. But the API approach avoids the question entirely.

How much does FFmpeg Micro cost for n8n workflows?

FFmpeg Micro has a free tier that covers light usage. Paid plans start at $19/month for higher volumes. You pay per minute of video processed, so costs scale with actual usage rather than server uptime.

Can I use FFmpeg Micro with n8n's webhook triggers?

Yes. A common pattern is: webhook receives a video URL, HTTP Request node sends it to FFmpeg Micro for processing, a Wait/loop polls for completion, then another HTTP Request downloads the result. The entire workflow runs in n8n with zero local FFmpeg dependency.

What video formats does FFmpeg Micro support?

FFmpeg Micro supports MP4, WebM, AVI, MOV, MKV, FLV for video, plus MP3, AAC, WAV, OGG, FLAC and more for audio. You can also output to image formats like JPEG, PNG, and WebP for thumbnail extraction.

FFmpeg Micro gives you FFmpeg's full processing power through a simple API. Sign up for a free account and swap out that Execute Command node in about five minutes.

Best FFmpeg API Services Compared (2026)

Javid Jamae — Tue, 21 Apr 2026 10:14:25 +0000

Originally published at ffmpeg-micro.com

You need video processing in your app. You don't want to manage FFmpeg servers. So which FFmpeg API do you actually pick?

There are more options than you'd think. Some wrap FFmpeg behind a REST endpoint. Others bolt on AI features or template engines. The pricing models are all over the place.

I tested the major FFmpeg API services available in 2026. This is what I found.

What Makes a Good FFmpeg API

Before comparing services, know what actually matters.

Flexibility. Can you pass custom FFmpeg options, or are you stuck with presets? Some services only expose a handful of operations. Others give you full FFmpeg control through the API.

Pricing clarity. GB-based pricing sounds simple until you realize a 4K file burns through your quota 10x faster than 720p. Per-minute or per-video pricing is more predictable.

Automation support. If you're building workflows in n8n, Make.com, or Zapier, the API needs to play nice with HTTP modules and webhooks.

Concurrency. Processing one video at a time doesn't cut it for batch workloads. Check how many parallel jobs each tier supports.

The Contenders

These are the main players in the FFmpeg-as-a-Service space right now.

FFmpeg Micro

FFmpeg Micro is a cloud API that lets you add video processing to any app with a single HTTP call. No FFmpeg installation, no server management.

Pricing:

Free: 100 minutes/month, 1 concurrent job
Starter ($19/mo): 2,000 minutes, 3 concurrent jobs
Pro ($89/mo): 12,000 minutes, 10 concurrent jobs
Scale ($349/mo): 60,000 minutes, 40 concurrent jobs

Billing is per input minute (rounded up, minimum 1 minute per job). Annual plans save 40%.

Standout features: Full FFmpeg option passthrough via the options array, virtual options for complex effects like text overlays and quote cards, an MCP server for AI agent integration with Claude, Cursor, and Windsurf, native n8n and Make.com integration guides, and preset mode for simple jobs where you just pick quality and resolution.

Supported formats: MP4, WebM, AVI, MOV, MKV, FLV, MP3, M4A, AAC, WAV, OGG, Opus, FLAC, JPEG, PNG, GIF, WebP.

curl -X POST https://api.ffmpeg-micro.com/v1/transcodes \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "inputs": [{"url": "https://example.com/video.mp4"}],
    "outputFormat": "webm",
    "preset": {"quality": "high", "resolution": "1080p"}
  }'

Rendi

Rendi is the most established name in the FFmpeg API space. You send standard FFmpeg command strings through their REST endpoint, and they execute them on optimized hardware.

Pricing:

Free: 50 GB processing/month, 1-minute max command runtime, 4 commands/minute
Pro ($25/mo): 100 GB processing, 10-minute runtime, unlimited commands, webhooks, chained commands
Enterprise: Custom pricing with SLAs

Rendi uses GB-based pricing instead of time-based. A 100 MB file costs the same whether it takes 5 seconds or 5 minutes to process. Good for quick operations on large files, less predictable for heavy transcoding.

The free tier caps command runtime at 1 minute, which rules out most real transcoding jobs. You're essentially forced to Pro for anything beyond format detection or thumbnail extraction.

ffmpegapi.net

ffmpegapi.net takes a different approach: pre-built endpoints for specific operations rather than raw FFmpeg command passthrough.

Pricing: Three tiers from free to $99/month. Free tier includes a guest API key for testing.

Standout features: AI-powered caption generation using OpenAI Whisper, animated captions via Remotion, picture-in-picture overlays, and YouTube downloading. The Whisper integration is unique among FFmpeg API services.

The trade-off? You don't get raw FFmpeg access. Each operation (merge, trim, split, convert) has its own endpoint with fixed parameters. Great if your use case matches their menu. Limiting if it doesn't.

Eranol

Eranol focuses on video creation rather than general-purpose processing. Their main product is a slideshow API that merges images with audio into video.

Pricing: Pay-per-video at $5 per 50 videos (10 min each). No monthly subscription. New users get $1 free credit.

Best for programmatic video generation from images and audio. Think product slideshows, social content from image templates, or automated video ads from a spreadsheet.

Not for general-purpose video transcoding, format conversion, or custom FFmpeg operations beyond their specific endpoints.

Side-by-Side Comparison

Feature	FFmpeg Micro	Rendi	ffmpegapi.net	Eranol
Pricing model	Per minute	Per GB	Tiered monthly	Per video
Free tier	100 min/mo	50 GB/mo	Yes (guest key)	$1 credit
Paid from	$19/mo	$25/mo	~$29/mo	$0.10/video
Raw FFmpeg passthrough	Yes	Yes	No	No
Preset mode	Yes	No	N/A	N/A
n8n / Make.com support	Guides included	Yes	Not documented	No
MCP / AI agent support	Yes (OAuth 2.1)	No	No	No
Concurrent jobs	Up to 40	Not published	Not published	Async
AI captions	No	No	Yes (Whisper)	No
Format support	20+ formats	All FFmpeg	Limited set	Video only

Which One Should You Pick

Pick FFmpeg Micro if you want full FFmpeg flexibility with predictable per-minute pricing. Especially strong if you're building automation workflows with n8n or Make.com, or integrating video processing into AI agents via MCP.

Pick Rendi if you're already comfortable writing FFmpeg CLI commands and want to send raw command strings to the cloud. The GB-based pricing works well for quick operations on large files.

Pick ffmpegapi.net if your use case is covered by their pre-built endpoints and you want AI caption generation out of the box.

Pick Eranol if you're specifically building slideshow-style videos from images and audio at scale.

Self-host if you have DevOps capacity, need sub-second latency, or process enough volume that API pricing doesn't make sense. But budget for the engineering time. Most teams underestimate how much work FFmpeg infrastructure actually is.

Frequently Asked Questions

What is the best FFmpeg API for developers in 2026?

FFmpeg Micro and Rendi are the two strongest options for developers who need full FFmpeg flexibility through an API. FFmpeg Micro offers per-minute pricing and automation-first integrations. Rendi offers GB-based pricing and raw command passthrough.

Is there a free FFmpeg API?

Yes. FFmpeg Micro offers 100 free compute minutes per month. Rendi offers 50 GB of free processing with a 1-minute command runtime cap. ffmpegapi.net provides a free guest API key for testing.

Can I use FFmpeg in Make.com or n8n without installing it?

You can. FFmpeg Micro and Rendi both work as external APIs called from Make.com HTTP modules or n8n HTTP Request nodes. FFmpeg Micro has dedicated integration guides for both platforms.

What's the difference between an FFmpeg API and self-hosted FFmpeg?

FFmpeg API services handle the infrastructure: scaling, updates, monitoring, and failover. Self-hosted FFmpeg gives you full control but requires managing servers, keeping FFmpeg updated, and handling concurrency yourself. For most teams, the API cost is cheaper than the engineering time.

Do any FFmpeg APIs support AI agent integration?

FFmpeg Micro has an MCP (Model Context Protocol) server that works with Claude Desktop, Claude Code, Cursor, Windsurf, and VS Code. This lets AI coding agents transcode video directly. No other FFmpeg API service currently offers MCP support.

FFmpeg Micro is free to start with 100 compute minutes per month. Sign up here and run your first transcode in under a minute.