Shotstack's n8n node renders timelines. It can't compress files.

You're running content ops in n8n, you've got a 180 MB MP4 and a platform that caps uploads at 100 MB, and the Shotstack node in the node picker looked like the answer. The Shotstack n8n node renders a new video from a JSON edit, so none of its operations take the file you already have and hand it back smaller, trimmed, captioned or stripped to audio.
- Three operations: Render Asset, Render Template, Get Asset by Render ID
- Every one of them starts from a timeline, not from your file
- Work is billed as rendered output minutes, roughly 15.6 cents on Starter
- n8n Cloud has no Execute Command node, so there's no local FFmpeg
- An HTTP Request node plus a status poll covers all four jobs
Three operations, and all of them render something new
The official node is @shotstack/n8n-nodes-shotstack, it's verified by n8n (which is why it installs on n8n Cloud), and you add it from Settings, then Community Nodes. Per n8n's own integration listing, it renders video or images from a JSON edit or from a saved template, waits for the render to finish, and returns a permanent hosted URL.
The resource list is short. Under Render you get Render Asset, which posts an edit to the render endpoint, and Render Template, which posts a template ID plus merge fields. Under Asset you get Get Asset by Render ID, which fetches the finished file.
Read that list against the file in your hands. Every operation's input is an edit: a timeline of tracks and clips, plus an output block describing the file you want built. No operation takes "this MP4" and returns the same MP4, changed.
One n8n-specific trap. The node's response comes back flat, so the render ID is {{$json.id}}, not {{$json.response.id}}, which is what you'd copy from a raw API example.
The four jobs a content-ops scenario actually has
Most scenarios that reach for a video node do one of four things to a file that already exists, and none is an assembly job.
| The job | Node operation for it | What you end up doing | What it bills |
|---|---|---|---|
| Compress an MP4 under a platform cap | None | Re-express it as a one-clip timeline, re-render at lower bitrate or resolution | A fresh rendered output |
| Trim 30 seconds by timestamp | None | Build an edit with a clip trim and length, then render | A fresh rendered output |
| Burn captions onto a finished file | Only inside a full edit | Wrap your file in a timeline so a caption asset can transcribe and burn over it | A fresh rendered output |
| Extract the audio | None | Drop to HTTP Request | Whatever the raw call costs |
The pattern underneath is the meter. A renderer charges for the output file it produces, so the unit of work is "a minute of video I built for you." Your unit of work is "a file I already own." Those units only line up when you're genuinely building something new.
This is why the compress case feels wrong. Making a 180 MB file fit under 100 MB is a bitrate decision about one existing file, and there's no compress node in n8n at all, which is the actual reason builders go looking at render nodes.
A 30-second trim, written both ways
A trim is three facts: the file, where to start, how long to run. As an edit, those facts get wrapped in a timeline, a track, a clip and an asset before the renderer will look at them.
{
"timeline": {
"tracks": [
{
"clips": [
{
"asset": {
"type": "video",
"src": "https://example.com/webinar.mp4",
"trim": 612
},
"start": 0,
"length": 30
}
]
}
]
},
"output": {
"format": "mp4",
"resolution": "hd"
}
}
Four levels of nesting to say "give me 30 seconds starting at 10:12." And trim means something non-obvious: it's an offset into the source asset, while start is the position on the output timeline. Mix those up and you get a 30-second clip of the wrong moment, which you find out after the render is billed.
The same trim sent to a media API is flat. Your n8n HTTP Request node posts to https://api.ffmpeg-micro.com/v1/transcodes with a Bearer token and a body that names the input and the output:
{
"inputs": [{ "url": "gs://your-bucket/webinar.mp4" }],
"outputFormat": "mp4",
"preset": { "quality": "medium", "resolution": "1080p" }
}
The clip window rides on the same flat object alongside the input; the field names are in the API docs. You get back a job ID and a status of pending, and the file comes from a signed download URL once the status reads completed.
That approach has its own mechanics. FFmpeg Micro has no completion webhook for callers, so your scenario polls GET /v1/transcodes/{id} until the status changes. Status checks, job listing and downloads aren't billed, so polling every five seconds costs nothing but n8n executions.
What a minute of video costs on each meter
Shotstack publishes its Starter plan at $39 a month for 200 credits, and on that tier a credit yields 1.25 rendered minutes: 250 rendered minutes, or about 15.6 cents each. Credit yield moves with the tier, so the same credit buys more minutes higher up. Prices change, so check the plan page before budgeting.
FFmpeg Micro meters the input instead. One token buys 10 seconds of input video, so a 60-second file is 6 tokens whatever you do to it. On the $19.99 Starter plan's 2,500 monthly tokens that's about 4.8 cents a minute, and on a $5 top-up pack of 500 tokens it's 6 cents. The numbers come off the pricing page as of November 21, 2026.
Three billing details matter more than the rate:
- Metering is per second with no rounding up to the minute, so a 10-second video costs 10 seconds.
- Trim 30 seconds out of a one-hour recording and you're billed for the 30 seconds, not the hour.
- Failed jobs are never billed, which matters when you're batching 200 UGC clips of unknown provenance.
An output meter multiplies when one source becomes several outputs. Cut four platform variants from a single 60-second master and a renderer sees four rendered minutes; an input meter sees four jobs of 60 seconds each. That multiplication is the real line item in any repurposing pipeline that fans one master out to TikTok, Reels, feed and YouTube.
Make and Zapier give you the same four modules
Switching automation platforms doesn't change the shape of the work. Shotstack's Make modules are Render from JSON, Render from Template, Get Render Status, and Make an API Call. The first three mirror the n8n node, and the fourth is the tell: a raw API call module exists because real scenarios need endpoints the modules don't cover.
Zapier's connector sits in the same lane. The moment your job is compress, trim or extract audio, you land in the generic webhooks or raw-call step, which is the same HTTP Request plus poll you'd write against any media API. The node has stopped saving you work there, and the only question is which meter you'd rather be on.
Where builders get this wrong when they wire video into n8n
Most of the pain here comes from four assumptions, not from the video.
The first is treating "the node waits for the render" as a feature with no cost. It holds your n8n execution open for the whole render, and on n8n Cloud an execution has a timeout. A 30-second output finishes well inside it. A ten-minute 4K assembly might not, and when the execution dies you've still paid for the render.
The second is building for a completion callback that isn't there. Plenty of media APIs, FFmpeg Micro included, make the caller poll. Design the scenario as submit, wait, check, loop back on pending or processing, branch on completed and failed. A fixed Wait node with a guessed duration is the most common reason a page-one tutorial breaks on a longer file.
The third is re-rendering a whole master to change one small thing. If a caption line is wrong at 00:42 of a ten-minute video, a render-shaped tool rebuilds all ten minutes and bills all ten minutes. Pick a tool whose unit is the input when the edit is a correction rather than a creation.
The fourth is retries you didn't plan. An n8n workflow that fires twice on the same item will happily render the same video twice and bill it twice, so de-duplicate before you scale the scenario and the invoice never teaches you this lesson.
One honest boundary, because the node isn't bad at its own job. If what you're building doesn't exist yet, say an infographic video assembled from a CSV row, AI images, a voiceover and animated text, a timeline renderer is the right shape, and an edit document is the correct amount of work. The mismatch appears when the pipeline starts with a finished file.
FAQ about using Shotstack's n8n node for existing files
Can the Shotstack n8n node compress a video I already have?
No. The Shotstack n8n node's operations are Render Asset, Render Template and Get Asset by Render ID, and all three produce a newly rendered output from an edit or a template. Compressing an existing MP4 means re-expressing it as a single-clip timeline at a lower resolution and paying for a fresh render, or sending the file to an API whose job is transforming an input.
Why can't I just run FFmpeg inside n8n instead?
n8n Cloud gives you no shell access and no custom binaries, so there's no Execute Command node and no local FFmpeg to call. Self-hosted n8n isn't a safe fallback either: version 2.0 disabled the Execute Command node by default for security, which broke workflows that had been shelling out to FFmpeg for years. Hosted media APIs called over HTTP Request are the route that survives both.
How does my scenario know the video is finished?
Your scenario polls. With the Shotstack node, the node itself waits and holds the n8n execution open until the render is done. With FFmpeg Micro you submit the job, then call the status endpoint on a loop until it returns completed or failed; status checks and downloads aren't billed, so the polling costs nothing.
Is burning captions onto an existing MP4 a full re-render?
Yes, on a timeline renderer it is. Captions get added as an asset inside an edit, which means your finished video becomes one clip in a new timeline and the whole thing is rendered again and billed as new output minutes. An input-metered API charges you for the length of the file you handed over, once.
What does it cost to test this before committing?
A new FFmpeg Micro account gets 200 tokens at sign-up with no card, which is about 33 minutes of input video, plus API access and unlimited API keys. That's enough to run all four jobs against your own footage in an n8n scenario and see which meter matches your pipeline.
Building those four jobs in n8n takes one HTTP Request node, a Wait, and a Switch that loops back to the status check. The FFmpeg in n8n Cloud walkthrough hands you that as importable workflows with the upload, metadata and wait steps wired. Sign up free starts you with 200 tokens and nothing to install: no servers to run, no FFmpeg binary to maintain, and one key that works from your own code, from n8n, Make and Zapier, or from an AI agent.
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

Your n8n Workflow Runs Twice and Renders Every Video Twice
Your n8n workflow runs twice and renders every video twice: move the trigger out of the DST repeated hour, confirm the durable scheduler, key the render.

n8n automation ideas lists skip video. Automate that step next.
Most n8n automation ideas lists are beginner text workflows. If yours already run, the next one to build is the media step n8n can orchestrate but not execute.

A Mux alternative swaps a host. The win is swapping a meter.
Mux alternatives mostly swap one video host for another. Pick a Mux alternative by the meter you're replacing: encode, storage or delivery, with arithmetic.
Ready to process videos at scale?
Start using FFmpeg Micro's simple API today. No infrastructure required.
Get Started Free