Compress video in n8n: there is no node, here is the call

n8n Cloud has no shell, no Execute Command node, and since 3.0 the community node you installed from npm stops loading. So the compress step you built last quarter is now a red node with no obvious replacement.
Quick answer: To compress video in n8n, call a video API from the built-in HTTP Request node: POST the job, use a Wait node, then poll the status endpoint until it returns completed and pass the output URL to the next node. There is no FFmpeg or compression node in n8n, and n8n Cloud has no Execute Command node, so here is the call that replaces one: an HTTP job request is the only compress path that survives upgrades.Why the node you had is gone and what replaces the Execute Command node
The Execute Command node is the first thing people reach for, and it has never existed on n8n Cloud. n8n's own docs say it plainly: available on self-hosted, not on Cloud. Since v2.0 it's also disabled by default on self-hosted, and re-enabling it by environment variable is its own forum thread. Even when you win that fight, you still need FFmpeg on the container PATH, and 3.0 made self-hosting Docker-only.
The second thing people reach for is a community node that wraps a hosted FFmpeg API. That worked until 3.0 flipped N8N_UNVERIFIED_PACKAGES_ENABLED to false. Unverified packages no longer install, and ones already installed stop loading. We wrote that up in n8n 3.0 disables community nodes: keep your FFmpeg step alive territory, and the practical conclusion hasn't changed: the HTTP Request node is the only video step no release note can take away from you.
So the shape is an async job call. Submit, wait, poll, branch, hand the URL on. Five nodes, all core.
The working node chain, node by node
Here is the chain that compresses a video from n8n Cloud without any binary anywhere in your instance. It assumes the file already lives somewhere reachable by URL (S3, Drive share link, your own bucket), which is the point: the bytes never enter n8n.
- HTTP Request (submit). POST to
https://api.ffmpeg-micro.com/v1/transcodeswith your key in theAuthorizationheader. Body:
{
"inputs": [{ "url": "{{ $json.fileUrl }}" }],
"outputFormat": "mp4",
"options": [
{ "option": "-c:v", "argument": "libx264" },
{ "option": "-crf", "argument": "28" },
{ "option": "-preset", "argument": "slow" },
{ "option": "-c:a", "argument": "aac" },
{ "option": "-b:a", "argument": "96k" }
]
}
The response comes back immediately with {"id": "job-uuid", "status": "pending"}. Store id in a Set node or just reference {{ $json.id }} downstream.
- Wait (5 seconds). Not decorative. A short clip finishes in a few seconds and you skip a pointless poll. Note that the Wait node only offloads execution data to the database for waits of 65 seconds or more; anything shorter keeps the execution in memory, so don't set 60 seconds and assume you've freed the worker.
- HTTP Request (poll). GET
https://api.ffmpeg-micro.com/v1/transcodes/{{ $json.id }}. While it's running you get"status": "processing". When it's done:
{
"success": true,
"jobId": "job-uuid",
"status": "completed",
"outputUrl": "gs://output-bucket/processed-video.mp4",
"createdAt": "2026-11-19T12:00:00Z",
"completedAt": "2026-11-19T12:00:41Z"
}
- Switch (branch on status). Three outputs:
completedgoes forward,failedgoes to your alert path, anything else loops back to the Wait node. That loop-back edge is the whole trick. n8n will happily cycle Wait and poll until the status changes, and because checking status is free on a per-second meter, a job that takes four minutes costs the same as one that takes forty seconds. Cap the loop with an IF on an attempt counter so a stuck job doesn't spin forever.
- HTTP Request (download URL). GET
/v1/transcodes/{{ $json.jobId }}/downloadreturns{"url": "https://storage.googleapis.com/...?X-Goog-Signature=..."}, a signed HTTPS link with a 10-minute TTL. Hand that URL to your next node: the Telegram upload, the S3 copy, the Whisper call, whatever came next. Call/downloadagain if the link expires.
That's the whole compress step. No binary, no Execute Command, no community package, nothing that an upgrade can delete. If you want this already wired, FFmpeg Micro's n8n integration and the free tier (200 tokens, roughly 33 minutes of video, no card) let you build the chain above and run it today.
CRF, not a quality slider
-crf 28 in that body is the actual compression decision, and it's worth understanding rather than copying. CRF is the constant rate factor for libx264: lower means better quality and a bigger file. FFmpeg's own H.264 guide puts the default at 23, the sane range at roughly 17 to 28, and notes that a change of +6 is about half the bitrate and roughly half the file size.
So 23 to 28 is one halving, give or take. For social uploads and Whisper preprocessing that's usually plenty. -preset slow buys you a smaller file at the same CRF by spending more encoder time, and on a meter billed by input duration rather than CPU seconds, a slower preset costs you nothing extra.
What CRF can't do is hit an exact byte target. If you need to land under a hard ceiling (Whisper's 25 MB, Discord's 10 MB, a CRM's 16 MB), CRF is a guess and you have to check the result. That's arithmetic on duration and bitrate, which we worked through in compress video to a specific size. The n8n version: after the download step, HEAD the output URL, read content-length, and if it's over your cap, re-submit with CRF plus 2. Two retries almost always lands it.
| Approach | Where it runs | Survives n8n 3.0 | Bytes through n8n |
|---|---|---|---|
| Execute Command + FFmpeg | Self-hosted only, off by default since 2.0 | No | Yes, via disk |
| Unverified community node | Anywhere, until the upgrade | No | Depends on node |
| Download, base64, Convert to File | Anywhere | Yes | Yes, all of them |
| HTTP Request job call | Anywhere, including Cloud | Yes | No, URLs only |
Where the usual binary-data advice falls apart
Half the forum answers for video in n8n tell you to download the file into the workflow, do something to it, and write it back out. On a 4 MB clip that works. On real video it fails in three distinct ways, and the failures are not obvious because two of them report success.
Start with the ceiling. n8n's default maximum payload size is 16 MiB, set by N8N_PAYLOAD_SIZE_MAX, with a separate 200 MiB default for form-data file uploads (n8n endpoints configuration). A 40 MB screen recording is already past the first number. And any node that touches the bytes rather than passing a reference loads them into memory: a builder on the n8n forum routing a roughly 1 GB video through the file nodes exhausted the instance, and the answer was to change the architecture instead of raising the heap.
Then base64, which inflates whatever you're carrying by about a third before it even reaches the ceiling. Worse, it used to corrupt quietly. n8n issue #37612 documented Convert to File's "Move Base64 String to File" passing the entire data:video/mp4;base64,... string to the decoder, so the data: prefix landed inside the decoded bytes. The node went green and handed the next step an unplayable file. The fix shipped in 2.45.0 on October 20, 2026, and anyone on 2.44 or earlier producing base64 from an AI model or a REST response is still writing garbage with a checkmark. We walked the whole failure in n8n Convert to File base64 video is corrupt: the data URI fix.
The third one costs money rather than time. A workflow that fires twice compresses twice and bills twice. n8n issue #42070 caught a daily Schedule Trigger double-firing on the DST fall-back night, running the same workflow an hour apart, and the forum carries a steady stream of the same complaint with no DST involved. On a render pipeline that's duplicate output and a doubled bill, which is why we gave it its own post. The defense is a dedupe key: hash the input URL plus the date, check it against a Data Table or Redis before the submit node, and skip the job if you've already compressed that file.
The architecture that avoids all three is the same one: URLs in, URLs out, bytes never inside n8n. Compression is where this matters most, since the input is by definition the biggest file in your pipeline.
When an API job call is the wrong answer
If your video is already small and your instance is self-hosted with FFmpeg on the PATH and Execute Command re-enabled, shelling out is fine and free. Nothing in this article says otherwise. The case for the HTTP shape is n8n Cloud, upgrades you don't control, and files big enough that memory is a real constraint.
An API job call is also the wrong tool when what you actually want is a templated video with text layers and transitions driven by a design. That's a template-rendering service, a different product category, and a compress endpoint will frustrate you. And if your pipeline is one video a month, the five-node chain is more plumbing than the problem deserves: compress it by hand once and move on.
FAQ about compressing video in n8n
Can I compress video in n8n Cloud at all?
Yes, you can compress video in n8n Cloud, but only by calling an external API from the HTTP Request node. n8n Cloud provides no shell, no Execute Command node, and no FFmpeg binary, so every local approach is unavailable there regardless of how you configure the workflow.
Does compressing harder cost more to process?
On a meter billed by input duration it does not. FFmpeg Micro charges one token per 10 seconds of input video, metered per second with no rounding up to the minute, so -crf 28 -preset slow and -crf 23 -preset fast cost exactly the same for the same source clip. Failed jobs are never billed, which makes the poll loop and the failure branch free to run.
How do I handle a compress job that takes longer than one HTTP request will wait?
Submit the job and poll it instead of waiting on a single synchronous request. The HTTP Request node returns a job ID immediately, a Wait node pauses the execution, and a Switch node loops back to the Wait until the status endpoint reports completed or failed. A ten-minute encode and a ten-second encode use the identical node chain.
What file size breaks n8n's binary data path?
n8n's default payload ceiling is 16 MiB via N8N_PAYLOAD_SIZE_MAX, so most real video breaks the binary path well before you reach a gigabyte. Passing URLs between nodes and letting the processing API fetch the file sidesteps the limit entirely, since no node in the workflow ever holds the bytes.
How do I confirm the compressed file landed under my cap?
Request the signed download URL from the job, then send an HTTP Request with the HEAD method and read the content-length header. If the byte count is over your target, re-submit the same input with CRF raised by 2 and check again; two passes usually clear a 25 MB ceiling for a clip of a few minutes.
The next thing to build is that Switch node's loop-back edge, because it's the piece every page-one tutorial skips and the reason their recipes break on anything longer than their wait window. The FFmpeg in n8n Cloud walkthrough builds the chain on screen, and Sign up free gets you a key to run it: no servers to run and no FFmpeg to install, callable from your code, from n8n, Make and Zapier, or from your AI agents, with a free tier to start.
About Javid Jamae
Founder & CEO at FFmpeg Micro
Javid is a software engineer, author, and entrepreneur with over 25 years of professional software development experience across enterprise, startup, and consulting environments. He founded FFmpeg Micro to make video processing accessible to developers through a simple, automation-first REST API.
You might also like

A bash loop can't batch compress 500 videos. Use a job queue.
Batch compress videos without a bash loop: fan out concurrent jobs, keep a job-id ledger, retry only the failures, and size bitrate by each clip's duration.

Compress video to a specific size: it's arithmetic, not two-pass
Compress video to a specific size: the bitrate formula, why you leave 5-8% headroom, why two-pass can't run on a job API, and how to verify the output bytes.

n8n execution crashed, startedAt null? It's a queue mode race
n8n execution crashed with startedAt null is a 2.45.0 queue mode race, not your workflow. Fix: upgrade to 2.45.1+, then stop blocking the worker event loop.
Ready to process videos at scale?
Start using FFmpeg Micro's simple API today. No infrastructure required.
Get Started Free