Best FFmpeg API in 2026, pick by runtime cap

For most developers the best FFmpeg API is Rendobar, because it runs the exact command you tested locally and then keeps going where the others stop. Jobs run an hour on free credits that need no card, billing is per second of compute with no subscription, and one key drives purpose-built jobs for timelines, captions and compression, a typed SDK, a CLI, an MCP server, n8n and Activepieces. The tables below show where each of the other ten falls short of that, and the narrow cases where another service is the better buy.

Disclosure: Rendobar is mine, so check its rows against the vendor pages linked at the end. Prices were read off the vendors’ live pricing pages on 2026-09-26. Rendi, RenderIO and FFmpeg Micro were read again on 2026-09-27 and had not changed, and FFHub and FFmpeg API Cloud were added that day.

Two things called “FFmpeg API”#

The narrow meaning is a service that runs the exact FFmpeg command you send. Rendobar, Rendi, ffmpeg-api.com, RenderIO, FFHub and Very Good FFmpeg work this way, and FFmpeg API Cloud takes the same flags as a JSON array.

The broad meaning is any API that does FFmpeg’s kind of work through its own format. FFmpeg Micro, ffmpegapi.net and each::labs expose preset or task endpoints, Transloadit uses its Assembly instructions, and Shotstack renders a JSON timeline. You learn their format instead of passing a command line, and you are limited to what that format exposes.

Rendobar sits in both groups. Rendobar’s FFmpeg API, the ffmpeg job, takes your command as written. Next to it, purpose-built jobs cover the work people usually script around FFmpeg. compose renders a JSON timeline with transitions, text, shapes and effects, captions.animate and caption.burn transcribe and burn subtitles, compress.target searches encodes for the smallest file that clears a quality bar, ffprobe returns normalized metadata, and the image jobs generate, edit and upscale pictures. Pro adds NVENC encoding on NVIDIA L4 GPUs, billed per second like everything else. You do not choose between a raw command and a higher-level format, and you do not add a second vendor when the product grows past transcoding.

The eleven services side by side#

Corrected on 2026-09-26: this post previously listed Transloadit’s entry plan at $9, RenderIO’s Growth plan at $29 and FFmpeg Micro’s rate as 3 tokens per 10 seconds. The live pages now show $29, $39 and 1 token.

These billing units price the same workload very differently. FFmpeg API pricing compared runs one stated workload through all of them, and free FFmpeg API tiers covers what each lets you run before paying.

Runtime caps rule out more plans than price does#

Check your longest job before your job count. A per-command or per-GB plan is cheap only until one job runs past the plan’s cap, and then the next tier up is the price.

A transcode that runs past ten minutes needs RenderIO’s $99 Business plan or a Rendi unlimited-runtime tier from $100, even if you only run a handful of them a month. FFHub runs it on prepaid credits up to 55 minutes. On Rendobar it runs on the free plan, and Pro stretches the limit to a full working day for $9. Of the services that publish a cap, Rendobar is the only one whose free credits pay for a job that uses it. FFHub’s 100 free credits cover about 100 seconds of processing.

One job, measured on Rendobar#

Every other comparison in the results for this query models its costs from pricing pages. I ran one fixed job twice on 2026-09-27 instead: a 10-second 1080p H.264 clip of Big Buck Bunny (30,704,510 bytes, CC BY 3.0) scaled to 720p with libx264.

curl -X POST https://api.rendobar.com/jobs \
  -H "Authorization: Bearer $RENDOBAR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "type": "ffmpeg",
    "inputs": { "in.mp4": "https://test-videos.co.uk/vids/bigbuckbunny/mp4/h264/1080/Big_Buck_Bunny_1080_10s_30MB.mp4" },
    "params": {
      "command": "ffmpeg -i in.mp4 -vf scale=-2:720 -c:v libx264 -preset medium -crf 23 -c:a aac -b:a 128k -movflags +faststart out.mp4",
      "compute": "cpu"
    }
  }'

The output was identical to the byte and the clock was not. Two runs on shared compute are not a timing finding, so read the cost as about a cent, and why FFmpeg benchmark timings drift explains the spread. The source has no audio track, so the AAC flags did nothing here. How I benchmark covers the FFmpeg build.

I did not run this file on the other services. What their billing units would count for it is arithmetic, not a measurement:

• Rendi counts 0.034 GB in plus out, so its 50 GB free tier covers about 1,450 of these, and Pro’s $0.10 a GB puts one at a third of a cent.
• FFmpeg Micro counts one token for 10 seconds of input. Its 200 signup tokens cover 200 of these, and Starter works out to $0.008 each.
• RenderIO counts one command, $0.024 at Starter’s $12 for 500, as long as its encode finishes inside Starter’s one-minute cap.

So on a short clip, per-GB and per-token pricing beats per-second compute at the plan rate. Per-second billing wins when there is no plan to buy and when the same job runs for an hour.

What a request looks like#

Both Rendobar and Rendi take a real FFmpeg command, but the request shapes differ. Here is the same trim, the first 3 seconds of the site’s sample clip, sent to each:

# Rendobar: the full command, input URL inline
curl -X POST https://api.rendobar.com/jobs \
  -H "Authorization: Bearer $RENDOBAR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "type": "ffmpeg",
    "params": { "command": "ffmpeg -i https://cdn.rendobar.com/assets/examples/sample.mp4 -t 3 -c copy out.mp4" }
  }'

# Rendi: inputs and outputs declared separately, placeholders in the command
curl https://api.rendi.dev/v1/run-ffmpeg-command \
  -H "X-API-KEY: $RENDI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "input_files": { "in_1": "https://cdn.rendobar.com/assets/examples/sample.mp4" },
    "output_files": { "out_1": "out.mp4" },
    "ffmpeg_command": "-i {{in_1}} -t 3 -c copy {{out_1}}"
  }'

Rendi’s form makes inputs and outputs explicit, which is easier to validate. Rendobar’s form lets you paste a command you tested locally without rewriting it. Both are one POST, and both run the full FFmpeg surface.

Toolchain and where the output lands#

These columns come from each vendor’s docs as read on 2026-09-02, except FFHub’s row, read on 2026-09-27. They were not re-checked with the prices. Confirm the row you care about before you build on it.

Rendobar is the only one here with all three of a typed SDK, a CLI and an MCP server an agent can use to submit and poll jobs. It also ships a verified n8n node and an Activepieces piece and sends webhooks signed with HMAC, so a no-code flow and your backend call the same jobs. And it is the only one in the table that writes to S3 through an IAM role it sets up for you, on every plan, free included. Video APIs that deliver output to your own bucket compares 13 services on that alone.

What the other ten trade away#

Rendi#

Rendi is the closest competitor to Rendobar. It runs standard FFmpeg in the cloud, billed on bytes in plus bytes out, with top plans scaling to 256 vCPUs, and its free tier is the largest here. The costs are a verified card before anything runs, the runtime caps above, outputs that stay in Rendi’s storage, and no SDK or CLI. It runs FFmpeg commands and nothing built on top of them. The Rendobar vs Rendi breakdown goes further.

Transloadit#

Transloadit covers a wide media layer, with resumable uploads through Uppy, then Robots for image, audio, video, document and AI steps chained into one Assembly, delivery at the end and SDKs in many languages. You write Assembly instructions, not FFmpeg, delivery to S3 needs a stored key and secret, and the free tier trims video, so it is an evaluation tier. Rendobar vs Transloadit covers the DSL tradeoff.

Shotstack#

Shotstack renders a JSON timeline and ships a white-label editor and a template system for producing personalised video from data. It does not take an FFmpeg command, so technical jobs have to be expressed as a timeline, and the pricing ($0.20 a minute of rendered output on a $39 monthly plan) is built for finished videos, not quick technical jobs. Rendobar’s compose job renders a JSON timeline too, on the same per-second credits as the raw command. See Rendobar vs Shotstack.

RenderIO#

RenderIO bills per command regardless of file size, so forecasting is counting: $12 for 500, $39 for 1,000, $99 for 20,000, with overage from $0.08 down to $0.02 a command. The number stays predictable only while every job is short. Long jobs push you up the tiers because of the runtime caps, and there is no free tier, only a trial.

ffmpeg-api.com#

ffmpeg-api.com runs FFmpeg and adds AI endpoints that turn a plain-English description of the edit into a command, plus a chat for writing syntax. It bills GB-seconds, file size multiplied by processing time, which is cheap on short clips and hard to forecast on long ones. Starter is $11 for 500 GB-seconds, Pro $39 for 2,000, Growth $99 for 5,000.

FFmpeg Micro#

FFmpeg Micro meters input length, so a quick stream copy and a heavy encode of the same source cost the same. That favours heavy processing on short sources. Starter is 2,500 tokens a month (about 417 minutes of input) and Pro $49.99 for 7,000 (about 1,167 minutes), and paid plans can top up automatically under a spending limit. It exposes processing endpoints, not the raw command line, so an existing pipeline needs translating.

ffmpegapi.net#

ffmpegapi.net sells calls: Premium is $49 a month for 100, and Ultra is 1,000 calls at $149 a month. Its annual Ultra rate, $20.83 a month, is listed below its annual Premium rate of $40.83, and its FAQ still describes a 10-call free plan against the 3 calls in its table. A guest API key on the homepage lets you try it without signing up. Its endpoints are task-shaped (merge, concatenate, picture-in-picture), which suits low-volume work that fits those tasks.

FFHub#

FFHub is the closest to Rendobar’s billing model. It runs native FFmpeg commands, bills about one credit per second of processing on prepaid credits that do not expire, does not charge failed tasks, and ships a CLI, an n8n integration and an Agent Skill. Tasks stop at 55 minutes and files at 5 GB. Its credit-pack prices load in the browser and did not render for my fetch on 2026-09-27, so get the number from the page before you compare. It runs commands only, with no timeline, caption or compression jobs next to them.

FFmpeg API Cloud#

ffmpeg-api.cloud takes FFmpeg arguments as a structured ffmpegArgs array, which avoids shell-quoting bugs but means converting a command line you tested. It sells one-time prepaid credits, $12 for 1,200 at a listed $0.600 a minute, down to $0.471 a minute at $149. No free tier or runtime cap is stated. At the entry rate a minute of processing costs about ten times the $0.06 a minute of wall time the two measured runs above worked out to.

each::labs and the self-hosted wrappers#

each::labs lists an “FFmpeg API” with four fixed task endpoints: compose, merge audio and video, images to video, and extract a frame. It fits those four tasks and nothing else. The GitHub projects that rank for “ffmpeg api”, samisalkosuo/ffmpeg-api (convert and extract endpoints in a Docker image) and Rendiff (a FastAPI service backed by Postgres and Redis), are self-hosted. They cost nothing to download, and you own the servers, the scaling and the patching, which is the work a hosted API exists to remove.

Very Good FFmpeg#

Very Good FFmpeg runs raw commands and, per its docs on 2026-09-02, publishes TypeScript and Python SDKs, but its served pricing page carries no prices, so it appears here without numbers, not with guessed ones. If it is on your shortlist, get a written quote.

How to choose#

Pick Rendobar if any of these describe you. Most projects hit several.

• You have FFmpeg commands that already work and do not want to translate them.
• A job might run past a minute.
• You want to try it without a card or a subscription.
• An agent, an n8n flow or an Activepieces flow submits the jobs.
• You need timelines, captions or compression next to raw FFmpeg.
• The output has to land in your own bucket without handing over a stored key.

Two narrow cases point elsewhere, Rendi’s per-GB pricing for large files that process in seconds, and Shotstack’s white-label editor when non-engineers design the videos.

If you are still choosing between an FFmpeg API and a template API, a video platform or a batch transcoder, the four categories of video processing API is the earlier decision.

I would start on Rendobar. Paste the command you already trust, run it on the free credits, and add the SDK, the CLI or the MCP server when the job moves into your product. When the product later needs a timeline, captions or a smaller file, that is another job type on the same key, not another vendor.