How to Choose an FFmpeg REST API in 2026

Originally published at ffmpeg-micro.com

You need video processing in your app. Converting formats, trimming clips, generating thumbnails, adding watermarks. Building this from scratch means installing FFmpeg on a server, managing queues, handling failures, and scaling infrastructure. Or you use an FFmpeg REST API and skip all of that.

The problem: there are at least six services that claim to do this, and they work in fundamentally different ways. Some give you FFmpeg's full command-line power through an API. Others hide FFmpeg behind preset-only interfaces. A few aren't even FFmpeg under the hood.

Picking the wrong one locks you into limitations you won't discover until you're in production.

What makes an FFmpeg API "REST"

A real FFmpeg REST API accepts HTTP requests, processes video with FFmpeg on the backend, and returns results. That sounds simple, but the implementation differences are significant.

Full FFmpeg access means you can pass any FFmpeg option or filter through the API. You're not limited to "resize" or "convert." You can use complex filter graphs, custom codecs, and advanced encoding settings. FFmpeg Micro, ffmpeg-api.com, and Shotstack (in custom mode) offer this.

Preset-only APIs give you a menu of operations. Pick "720p" or "webm" and the service handles the rest. Creatomate and Mux work this way. Faster to start with, but you'll hit walls when you need something the presets don't cover.

Not actually FFmpeg. Services like AWS MediaConvert and Cloudflare Stream do video processing, but they use proprietary transcoders. If you need specific FFmpeg behavior (particular filters, codec options, format quirks), these won't match.

The six options worth considering

AWS MediaConvert, Mux, and Cloudflare Stream are intentionally excluded. They're video infrastructure platforms, not FFmpeg APIs. If you need HLS streaming or a full video CMS, look at those instead.

What to actually evaluate

Can you pass custom FFmpeg options?

This is the first question that matters. If you need to set a specific CRF value, use a particular audio codec, or apply a complex filter graph, preset-only APIs won't work.

FFmpeg Micro lets you send raw options alongside or instead of presets:

{
  "inputs": [{ "url": "https://example.com/input.mp4" }],
  "outputFormat": "mp4",
  "options": [
    { "option": "-c:v", "argument": "libx265" },
    { "option": "-crf", "argument": "28" },
    { "option": "-preset", "argument": "slow" }
  ]
}

That's a POST /v1/transcodes call. You get back a job ID and poll for completion, or set up a webhook.

How does input work?

Some APIs accept URLs only (you host the source file). Others offer direct upload. FFmpeg Micro supports both: pass a public URL in the inputs array, or use the three-step upload flow (get a presigned URL, PUT the file to cloud storage, confirm the upload).

For automation workflows in n8n or Make.com, URL-based input is simpler. You don't have to shuttle files through your automation platform.

What does it actually cost?

Per-minute pricing (FFmpeg Micro, ffmpeg-api.com) scales linearly with video length. A 1-minute video costs the same whether you're outputting 720p or 4K.

Per-file pricing (Rendi) charges per operation regardless of length. Cheap for long videos, expensive if you're processing thousands of short clips.

Per-render pricing (Shotstack, Creatomate) depends on output complexity. Templates with multiple layers cost more.

For most developers processing user-uploaded content, per-minute pricing is the most predictable.

How does it fit your stack?

If you're building with n8n or Make.com, check whether the API has native integrations. FFmpeg Micro has an official Make.com app (live in the Make.com marketplace) and works with n8n via HTTP Request nodes. Rendi also has Make.com support. Creatomate has the deepest Zapier integration.

If you're building a traditional backend in Node.js, Python, or Go, any REST API works. The differentiator becomes documentation quality and error handling.

Do you need multi-input composition?

Stitching multiple videos together, overlaying audio on video, or combining images into a slideshow requires multi-input support. Not every API handles this cleanly.

FFmpeg Micro accepts an array of inputs natively:

{
  "inputs": [
    { "url": "https://example.com/clip1.mp4" },
    { "url": "https://example.com/clip2.mp4" },
    { "url": "https://example.com/clip3.mp4" }
  ],
  "outputFormat": "mp4",
  "preset": { "quality": "high" }
}

This concatenates all three clips into a single output. No filter graph assembly on your end.

The decision framework

Pick based on your actual constraints, not feature lists:

• You need full FFmpeg control and REST simplicity: FFmpeg Micro or ffmpeg-api.com
• You're on Make.com and want native drag-and-drop: FFmpeg Micro (official app) or Rendi
• You're building branded video templates at scale: Creatomate or Shotstack
• You're already on fal.ai for ML inference: fal.ai (convenience, not specialization)
• You need HLS, DRM, or a video CMS: Mux or Cloudflare Stream (these aren't FFmpeg APIs)

If you're reading this post, you probably need actual FFmpeg capabilities through a simple REST interface. That narrows it to FFmpeg Micro, ffmpeg-api.com, or Shotstack in custom mode.

Try it

FFmpeg Micro has a free tier. Grab an API key at ffmpeg-micro.com, send a transcode request, and see your first result in under a minute. No credit card, no server setup, no FFmpeg installation.

FAQ

Is there a free FFmpeg API?

FFmpeg Micro offers a free tier with limited processing minutes per month. Most other services (Shotstack, Creatomate) also have free tiers or trials. ffmpeg-api.com requires payment upfront.

Can I use FFmpeg in a serverless function?

You can, but FFmpeg binaries are 80MB+ and cold starts become painful. An FFmpeg REST API avoids this entirely. Your serverless function makes one HTTP call instead of spawning a local FFmpeg process.

What's the difference between an FFmpeg API and a video encoding service?

An FFmpeg API gives you direct access to FFmpeg's features through HTTP requests. A video encoding service like AWS MediaConvert uses proprietary transcoders and offers a different feature set. If you need specific FFmpeg filters, codecs, or options, you need an actual FFmpeg API.

How fast is cloud-based video processing?

Processing time depends on input length and operation complexity. A 1-minute video typically takes 3-15 seconds for format conversion via API. Complex operations like H.265 encoding with slow presets take longer. Most FFmpeg APIs return results via webhook or polling.

Can I process videos in bulk through a REST API?

Yes. Send multiple transcode requests in parallel and track each by job ID. FFmpeg Micro handles concurrent jobs and returns results independently. For batch workflows, pair with n8n or Make.com to process files from a folder, webhook trigger, or scheduled pipeline.