Hosted FFmpeg API for n8n: Best FFmpeg API Setup

You want a hosted FFmpeg API that plugs into n8n. You are comparing providers because n8n Cloud has no shell, Execute Command is off by default on modern self-hosted installs, and local FFmpeg on a worker is a production risk.

The fix is simple: keep n8n as the orchestrator and offload encode work to a hosted FFmpeg API. This guide shortlists the real options, puts Very Good FFmpeg first for raw FFmpeg in n8n, and walks the full flow: submit job, poll or webhook, download output. Install steps and node ops live in the n8n integration docs.

What Are the Key Takeaways?

n8n needs a hosted FFmpeg API when you are on Cloud (no Execute Command) or when self-host local FFmpeg would block workers, need a custom image, or choke under concurrent encodes. The canonical automation pattern is always the same: submit a job, wait by polling or webhook, then download the output URL.

• Provider camps split into raw FFmpeg (Very Good FFmpeg, Rendi, RenderIO) and preset or convert tools (CloudConvert, ffmpegapi.net).
• Very Good FFmpeg is the default pick: raw commands, per-GB pricing with no monthly minimum, 16-core CPU and Nvidia GPU, up to 6-hour jobs, and the community package @verygoodffmpeg/n8n-nodes-verygoodffmpeg.
• RenderIO fits when you need a verified n8n partner node on Cloud today and jobs stay short (plan caps from about 1 to 20 minutes).
• Rendi is solid raw FFmpeg over HTTP Request, with a Pro floor around $25/mo on many tiers and an n8n curly-brace escape gotcha for placeholders.
• CloudConvert is strong for preset convert, thumb, and watermark work, with an optional ffmpeg command task and a verified n8n node.
• Prefer webhook completion over tight poll loops on paid n8n plans. Fewer execution ticks, fewer timeouts on long encodes.
• Skip Execute Command and self-host-only FFmpeg as your production video backbone unless you already run dedicated media infra.

Why Does n8n Need a Hosted FFmpeg API?

n8n is excellent at triggers, branching, and moving file URLs between systems. It is a poor place to run multi-minute CPU or GPU encodes. A hosted FFmpeg API takes the heavy lift so n8n stays thin and reliable.

Why can't n8n just run FFmpeg locally?

n8n cannot run FFmpeg locally on Cloud at all, and self-host local FFmpeg is fragile. The Execute Command node runs host shell commands, is disabled by default from n8n 2.0 for security, and is not available on n8n Cloud.

On Docker, the official n8n image is Alpine-based. Users hit /bin/sh: ffmpeg: not found until they build a custom image and install the binary. In queue mode the command still runs on the worker container, so every worker needs the binary plus spare CPU and RAM. Long encodes hold worker slots. Concurrent jobs can OOM the host or starve unrelated workflows. Official n8n docs document the missing-binary failure mode and the custom Dockerfile fix. That path works for tiny internal clips. It does not scale cleanly for production video automation.

What does a hosted FFmpeg API mean for automation?

A hosted FFmpeg API accepts a POST with input URLs (or an upload), FFmpeg flags or a preset, and optional callback settings. The cloud service runs the job, then you poll status or receive a webhook and download the result URL.

n8n's job is trigger, map fields, auth, branch on status, and pass file URLs downstream (Drive, S3, Slack, CRM). The API's job is compute, retries, and machine capacity. Raw FFmpeg providers keep your local FFmpeg knowledge. Preset providers are faster when you only need convert, thumbnail, or watermark.

When is self-hosted FFmpeg still OK?

Self-hosted FFmpeg is still OK for tiny internal jobs, short clips, a single quiet worker, and a custom image your team already maintains. Even then, many teams keep self-hosted n8n for data residency and still call a hosted FFmpeg API for media.

That hybrid is the best default architecture: n8n for workflow logic, hosted FFmpeg for spikes, GPU, multi-hour encodes, logs, and retries.

What Should You Look For in a Hosted FFmpeg API for n8n?

You should look for raw command control when you need real FFmpeg, a clean n8n path (node or HTTP), solid async completion, honest runtime limits, and pricing that matches your volume. Fancy marketing pages matter less than whether a 40-minute encode finishes and how the bill looks at 200 GB/month.

Should you poll status or use a webhook?

You should poll for short jobs and use a webhook for long encodes. Poll means POST job, Wait a few seconds, GET status, IF loop until success or failure. It is easy to build and burns n8n executions on every tick.

Webhook means you pass an n8n Webhook URL or a provider Trigger URL when you create the job. The API POSTs the finished job object when done. n8n can also use Wait On Webhook Call with $execution.resumeUrl when the provider can callback mid-execution. Rule of thumb: under about one to two minutes, poll is fine. Longer jobs should use webhook so you avoid timeouts and extra execution cost on paid n8n plans.

How Do Hosted FFmpeg Providers Compare for n8n?

They compare on raw control, n8n install path, price model, max runtime, GPU, and webhook support. For raw FFmpeg inside n8n, Very Good FFmpeg is the top pick. The table below is the shortlist most buyers actually evaluate.

Why is Very Good FFmpeg the top pick for n8n?

Very Good FFmpeg is the top pick because it runs your exact FFmpeg commands on strong machines, bills per GB with no monthly minimum, and ships an official n8n package plus docs. You POST to /api/ffmpeg with input_files, output_files, ffmpeg_commands, optional webhook_url, and machine set to cpu or nvidia. Auth is Bearer token.

Pricing starts with 2 GB free and no card required for the trial path. Then usage tiers are about $0.50/GB (0-10 GB), $0.10/GB (10-100 GB), and $0.08/GB above 100 GB. There is no subscription floor. Specs include 16x5 GHz class vCPU, Nvidia GPU option, up to 6-hour jobs, realtime logs in the dashboard, temp uploads, RBAC, TypeScript and Python SDKs, and MCP.

For n8n, install @verygoodffmpeg/n8n-nodes-verygoodffmpeg. Operations cover Job Run, Get, List, Cancel, File Upload, and a Very Good FFmpeg Trigger webhook node. Short jobs use Wait for Completion on. Long jobs pass the Trigger webhook URL and leave Wait off. Placeholders look like {{input}} and {{output.mp4}}. File Upload returns a download_url you feed into Job Run.

Honest Cloud note: the community node is available on self-hosted n8n today and is submitted for n8n verification for Cloud. Until verification completes, n8n Cloud users call the same REST API with the HTTP Request node. Full install and examples: n8n integration docs.

How does RenderIO fit n8n?

RenderIO fits n8n when you want a verified partner node on Cloud right now and your jobs stay inside short plan ceilings. It markets "any FFmpeg command" with a native package @renderio/n8n-nodes-renderio listed on the n8n integrations directory.

Typical pricing shape is subscription plus command quota: Starter around $12/mo with about 500 commands and a 1-minute max, Growth around $29-39/mo with higher quotas and about 5 minutes, Business around $99/mo with much higher quotas and about 20 minutes. Overage is per command. Poll and webhook both work. No GPU. Strong choice for short social clips and Cloud install convenience. Weak choice for multi-hour encodes, GPU, or pure per-GB billing with no monthly floor.

How does Rendi fit n8n?

Rendi fits n8n as a raw FFmpeg HTTP API with poll or webhook completion and clear automation docs. There is no dedicated verified n8n node in the same sense as RenderIO or CloudConvert; you wire HTTP Request plus an API key header.

Free tier is roughly 4 vCPU, 50 GB/mo process, 1-minute runtime, with card and verification gates on the free path. Pro starts around $25/mo with higher GB and about 10-minute runtime on common SKUs (longer runtime SKUs cost more). n8n users must escape placeholders so n8n expressions do not eat them: Rendi-style {{input_0}} often needs \{\{input_0\}\} in the HTTP body. Fair option if HTTP-only is fine and you already like their GB model. Very Good FFmpeg still wins as the default for an official node package, GPU, 6-hour jobs, and no monthly minimum.

How does CloudConvert fit n8n?

CloudConvert fits n8n when most of the workflow is convert, thumbnail, watermark, merge, or PDF tools, with occasional custom ffmpeg. The verified package is @cloudconvert/n8n-nodes-cloudconvert. Auth is OAuth2 or API key.

The API job model is async. Per-job or account webhooks are preferred for video; sync wait endpoints are a bad idea for long encodes. Pricing is credit-based (free tier is low for video volume; paid packages and subscriptions scale up). The Execute Command operation can run ffmpeg with inputs under /input/... and outputs under /output/. Use CloudConvert when you already live in that convert library. Do not treat it as your primary "hosted FFmpeg CLI" if raw flags and long GPU jobs are the main need.

Where does ffmpegapi.net sit?

ffmpegapi.net sits in the preset camp. It exposes merge, trim, PiP, captions, compress, and similar REST operations. You can call it from n8n HTTP Request for fixed pipelines. It is the wrong primary tool when you need arbitrary filter graphs or full CLI control.

How Do You Run Hosted FFmpeg in n8n?

You run hosted FFmpeg in n8n by submitting a job, waiting with poll or webhook, then downloading the output URL. Prefer the Very Good FFmpeg community node on self-hosted n8n. Use HTTP Request on n8n Cloud until the node is verified, or with any provider that only offers REST.

Path A: Very Good FFmpeg community node (preferred)

1. Create an API key in the Very Good FFmpeg dashboard.
2. On self-hosted n8n, confirm community packages are enabled (N8N_COMMUNITY_PACKAGES_ENABLED=true if Community Nodes is missing).
3. Go to Settings > Community Nodes > Install and enter @verygoodffmpeg/n8n-nodes-verygoodffmpeg.
4. Add a Very Good FFmpeg API credential and paste the API key. Leave Base URL empty unless you were told otherwise.
5. Optional binary path: add File > Upload, map the binary property from HTTP Request, Drive, or Form Trigger, and capture download_url.
6. Add Job > Run:
   • Input Files: key input, URL from prior node or a public sample such as https://storage.verygoodffmpeg.com/sample.mp4
   • Output Files: output.mp4
   • FFmpeg Commands: -i {{input}} -t 5 {{output.mp4}}
   • Machine: cpu or nvidia
7. Short job: turn Wait for Completion on. On success the item includes status: "succeeded" and output_files["output.mp4"].
8. Long job: add a Very Good FFmpeg Trigger (or a standard Webhook), copy the production URL into Webhook URL on Job Run, leave Wait for Completion off. The run node returns the queued job immediately. The trigger workflow receives the full job object when encoding finishes.
9. Download or forward the output: HTTP Request GET on the output URL into a binary property, or pass the URL to S3, Drive, Slack, or email.
10. Errors such as 402: Add credit before submitting another job surface as normal n8n node errors. Use On Error retry/continue or an Error Trigger workflow.

Copy-paste detail and AI Agent / MCP notes are in the n8n integration docs.

Path B: HTTP Request fallback (Cloud or any REST provider)

1. Create Header Auth or generic credential.
   • Very Good FFmpeg: Authorization: Bearer <API_KEY>
   • Other providers: follow their key header (for example X-API-KEY)
2. POST job create. For Very Good FFmpeg the body shape is:

{
  "input_files": {
    "input": "https://example.com/source.mp4"
  },
  "output_files": ["output.mp4"],
  "ffmpeg_commands": ["-i {{input}} -c:v libx264 -crf 23 -c:a aac {{output.mp4}}"],
  "webhook_url": "https://your-n8n.example/webhook/vgf-done",
  "machine": "cpu"
}

3. Capture id from the response.
4. Poll branch: Wait 3-10 seconds, then GET /api/jobs/{id}. IF succeeded continue. IF failed take the error path. Else loop with a max attempt counter.
5. Webhook branch: publish a Webhook workflow, set its production URL as webhook_url on create, and read output_files from the POST payload. Provider payloads usually mirror the GET job object (id, status, output_files, error_message).
6. Download: HTTP Request GET the output URL with response format file. Pass binary to the next node.
7. Optional: import cURL from the provider docs into the HTTP Request node to avoid hand-typing headers and JSON.

For Rendi-style placeholder APIs inside n8n HTTP bodies, escape braces so n8n does not treat them as expressions.

What example workflows should you build first?

Build a short trim first, then a poll-based social asset, then a webhook-based long encode. Those three cover almost every production pattern.

1. Form or webhook intake, trim or compress, store URL. Good smoke test for credentials and placeholders.
2. MP4 to GIF or vertical short. Poll every 10-30 seconds until success (common community template shape on n8n.io).
3. Long batch encode, webhook completion, Slack notify. Production pattern for paid n8n plans.
4. AI Agent tool use. Very Good FFmpeg nodes are marked usableAsTool for AI Agent and MCP Server Trigger setups.

Which FFmpeg commands work well as first tests?

These commands work well as first tests because they are short, deterministic, and easy to validate in the dashboard logs.

Trim five seconds (stream copy when possible):

-i {{input}} -t 5 -c copy {{output.mp4}}

Compress H.264:

-i {{input}} -c:v libx264 -crf 23 -c:a aac {{output.mp4}}

Extract audio:

-i {{input}} -vn -acodec libmp3lame {{output.mp3}}

Scale to vertical 1080x1920:

-i {{input}} -vf scale=1080:1920 {{output.mp4}}

Multiple commands can run in order in the same workspace on Very Good FFmpeg. That keeps multi-step graphs in one job instead of many n8n loops.

Why Not Use Execute Command or Self-Hosted FFmpeg Only?

You should not use Execute Command or self-hosted FFmpeg only as your production video backbone on n8n. On Cloud, Execute Command is unavailable, so local FFmpeg is a dead end. On self-host, the node is disabled by default because arbitrary host shell is a security risk.

Ops cost is real: custom image drift, Alpine packages, PATH issues, and maxBuffer failures when FFmpeg logs are chatty. Scale cost is real too: CPU encode on the n8n worker competes with every other automation, and typical n8n hosts have no GPU path. "Free" local FFmpeg hides larger instance size, idle capacity, failed-job retries, and on-call time.

The hybrid truth still stands. Self-host n8n when you need private networking or data residency. Call a hosted FFmpeg API for the media heavy lift. That is the architecture most teams end up with after the first production outage caused by a stuck encode.

How Should You Price and Size the Integration?

You should price the integration from monthly GB processed and from n8n execution behavior, not from a single demo clip. Sum input plus output sizes across expected n8n runs, then map that volume to each provider's model.

Also count n8n plan cost. A webhook completion path can cut execution count versus a tight poll loop every few seconds. Start by wiring the full Very Good FFmpeg path on free GB: upload or public URL, Job Run, wait or webhook, then download. Only then compare paid invoices against RenderIO command math or Rendi Pro floors.

What Is the Verdict?

The default recommendation for a hosted FFmpeg API in n8n is Very Good FFmpeg. You get raw FFmpeg commands, 16-core CPU and Nvidia GPU machines, up to 6-hour jobs, usage-based per-GB pricing with no monthly minimum, and an official community package with docs at /docs/integrations/n8n.

Choose RenderIO if you need a verified Cloud community node today and jobs stay short. Choose Rendi if HTTP-only is fine and you already like their free/Pro GB model (watch runtime caps and brace escaping). Choose CloudConvert if the workflow is mostly preset convert and document tools with occasional ffmpeg. Avoid preset-only APIs when you need arbitrary graphs. Avoid Execute Command and local-only FFmpeg as the production backbone.

Next step: create a free API key on verygoodffmpeg.com, install the node or wire HTTP Request, run a five-second trim, then switch long jobs to webhook completion. The install path and full examples are in the n8n integration docs.

FAQ

Does n8n Cloud support FFmpeg natively?

No. n8n Cloud does not give you a shell, apt/apk install, or Execute Command. You must call an external hosted FFmpeg or conversion API from HTTP Request or a verified community node.

Can I use Very Good FFmpeg on n8n Cloud without the community node?

Yes. Use the HTTP Request node against POST /api/ffmpeg and GET /api/jobs/{id} with Bearer auth. The dedicated community node is self-hosted today and pending n8n verification for Cloud. The REST API works on every n8n deployment.

Hosted FFmpeg API vs Execute Command: which should I use?

Use a hosted FFmpeg API for production video. Use Execute Command only for tiny internal shell tasks on a hardened self-hosted worker where you accept the security and capacity tradeoffs. Execute Command is unavailable on Cloud and disabled by default on modern self-hosted n8n.

Should I poll or use a webhook for long encodes in n8n?

Use a webhook for long encodes. Poll is fine for short jobs under about one to two minutes. Webhooks reduce n8n execution ticks and avoid workflow timeouts while the encoder runs for many minutes or hours.

How do I upload a binary file from n8n to a hosted FFmpeg API?

With Very Good FFmpeg, use File > Upload on the community node. It takes the item binary property and returns download_url for Job Run. Over plain HTTP, upload to temp storage or object storage first, then pass the public or signed URL in input_files.

Why do Rendi placeholders need extra escaping in n8n?

n8n treats {{...}} as expressions. Provider placeholders that also use double braces can be rewritten before the request leaves n8n. Rendi's n8n docs show escaping placeholders so the remote API still receives {{input_0}} style tokens.

Is there an official Very Good FFmpeg n8n node?

Yes. The package is @verygoodffmpeg/n8n-nodes-verygoodffmpeg. Setup and operations are documented at /docs/integrations/n8n. Self-hosted install works today; Cloud availability waits on n8n verification.

How long can a job run on Very Good FFmpeg vs RenderIO vs Rendi?

Very Good FFmpeg allows up to 6 hours per job. RenderIO plan ceilings are roughly 1 minute (Starter), 5 minutes (Growth), and 20 minutes (Business). Rendi free is about 1 minute; common Pro SKUs are about 10 minutes, with higher SKUs for longer runtimes.

Does Very Good FFmpeg support GPU from n8n?

Yes. Set machine to nvidia on Job Run (node field or JSON machine on HTTP). Pick GPU when the filter graph or codec path benefits from it; otherwise CPU is enough for many H.264 jobs.

How is Very Good FFmpeg priced for n8n automation volume?

Pricing is per GB processed with automatic volume tiers and no monthly minimum. First 2 GB are free. After that, expect about $0.50/GB, then $0.10/GB, then $0.08/GB at higher volume. Map your monthly input-plus-output GB to those tiers.

Can I chain multiple FFmpeg commands in one n8n workflow?

Yes. On Very Good FFmpeg, pass multiple entries in ffmpeg_commands (or multiple command rows in the node). They run in order in the same workspace. You can also chain separate Job Run nodes if later steps depend on earlier output URLs.

What happens when the API returns a credit or auth error in n8n?

The community node surfaces API failures as standard n8n node errors with HTTP status and message (for example 402 credit errors). Configure On Error on the node, or route failures to an Error Trigger workflow for Slack alerts and retries.

References

• Very Good FFmpeg n8n docs: https://verygoodffmpeg.com/docs/integrations/n8n
• Very Good FFmpeg API docs: https://verygoodffmpeg.com/docs
• Very Good FFmpeg webhooks: https://verygoodffmpeg.com/docs/advanced/webhooks
• Very Good FFmpeg site: https://verygoodffmpeg.com
• npm package @verygoodffmpeg/n8n-nodes-verygoodffmpeg: https://www.npmjs.com/package/@verygoodffmpeg/n8n-nodes-verygoodffmpeg
• n8n HTTP Request node: https://docs.n8n.io/integrations/builtin/core-nodes/n8n-nodes-base.httprequest/
• n8n Wait node: https://docs.n8n.io/integrations/builtin/core-nodes/n8n-nodes-base.wait/
• n8n Webhook node: https://docs.n8n.io/integrations/builtin/core-nodes/n8n-nodes-base.webhook/
• n8n Execute Command node: https://docs.n8n.io/integrations/builtin/core-nodes/n8n-nodes-base.executecommand/
• n8n Execute Command common issues: https://docs.n8n.io/integrations/builtin/core-nodes/n8n-nodes-base.executecommand/common-issues/
• n8n community node GUI install: https://docs.n8n.io/integrations/community-nodes/installation-and-management/gui-installation/
• n8n verified community nodes: https://docs.n8n.io/integrations/community-nodes/installation-and-management/install-verified-community-nodes/
• RenderIO: https://renderio.dev
• RenderIO n8n integration: https://renderio.dev/ffmpeg-n8n-integration
• RenderIO n8n Cloud FFmpeg notes: https://renderio.dev/blogs/n8n-ffmpeg-cloud-fix
• RenderIO on n8n directory: https://n8n.io/integrations/renderio/
• n8n MP4 to GIF template (RenderIO): https://n8n.io/workflows/14757-convert-mp4-to-gif-with-ffmpeg-and-renderio/
• Rendi: https://rendi.dev
• Rendi docs: https://rendi.dev/docs
• Rendi n8n docs: https://rendi.dev/docs/n8n
• Rendi pricing: https://rendi.dev/pricing
• CloudConvert on n8n: https://n8n.io/integrations/cloudconvert/
• CloudConvert n8n node GitHub: https://github.com/cloudconvert/n8n-nodes-cloudconvert
• CloudConvert execute commands: https://cloudconvert.com/docs/operations/execute-commands
• CloudConvert jobs API: https://cloudconvert.com/api/v2/jobs
• CloudConvert pricing: https://cloudconvert.com/pricing
• ffmpegapi.net: https://ffmpegapi.net