Why does my ffmpeg code work locally but fail on Vercel?

Locally you have the ffmpeg binary on your machine and no bundle or timeout limits. On Vercel, Node serverless functions cap the unzipped bundle at 250MB (ffmpeg plus codecs don't fit) and long encodes hit the function timeout. Nothing is wrong with your code; the runtime just can't host ffmpeg. Fotovid runs the encode off-platform and returns a URL.

Can I run ffmpeg on Vercel's Edge runtime instead?

No. The Edge runtime has no Node APIs and no child_process, so you can't spawn an ffmpeg binary at all. It avoids the 250MB size problem only by removing the ability to run native binaries. Calling the Fotovid HTTP API works fine from Edge functions since it's just a fetch.

Will a long video encode blow past my Vercel function timeout?

If you run ffmpeg inside the function, yes. Hobby caps execution at 10s and Pro is configurable but still bounded, and real encodes take longer. With Fotovid your function only makes an HTTP request and returns; the encoding happens on Fotovid's side, so your function finishes fast.

What does a Fotovid request and response look like?

Every sync endpoint takes the same envelope: { source_url, params }. The watermark call adds params like type, watermark_image_url or text, position, opacity, and scale. The response is flat JSON with id, type, a fotovid-hosted url, and expires_at. You store your own copy of the result file.

Why not just use Cloudinary or Transloadit?

Those are full media platforms — asset managers, dashboards, a pipeline you adopt. Fotovid is just the one ffmpeg call your Vercel function couldn't make on its own: a single endpoint, priced by usage, with no platform to migrate onto and no SDK to learn.

Usage credits: $1 buys 100 credits and most operations cost 1 credit each. You start with a free key, so you can wire up your Vercel function and confirm it works before spending anything.

ffmpeg on Vercel

ffmpeg on Vercel breaks at deploy — call an API that doesn't.

It worked on localhost, then broke the moment you deployed. That's not your code, it's the runtime. Point your Vercel function at Fotovid: it sends a source URL, Fotovid returns the rendered media.

Get your API key — free Read the docs →

// app/api/watermark/route.ts
import { NextResponse } from "next/server";

export async function POST(req: Request) {
  const { videoUrl, logoUrl } = await req.json();

  const res = await fetch("https://api.fotovid.co/v1/video/watermark", {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.FOTOVID_API_KEY!}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      source_url: videoUrl,
      params: { type: "image", watermark_image_url: logoUrl, position: "bottom-right" },
    }),
  });

  const { url } = await res.json();
  return NextResponse.json({ url });
}

Why ffmpeg breaks on Vercel

Vercel is a great place to run your app and a hostile one to run ffmpeg. Node serverless functions cap the unzipped bundle at 250MB, and ffmpeg plus its codecs blow past that before your own code is counted. Switch to the Edge runtime to dodge the size limit and you lose child_process entirely, so there is no way to spawn a binary. Even when a build sneaks through, the function timeout (10s on Hobby, bounded on Pro) kills any real encode partway. ffmpeg-static and fluent-ffmpeg pass locally and fail on deploy for exactly these reasons.

250MB unzipped function cap: ffmpeg plus codecs don't fit in a Node serverless bundle
Edge runtime has no Node APIs and no child_process, so you can't spawn a binary
Function timeouts (10s Hobby, bounded on Pro) cut off long encodes mid-run
ffmpeg-static and fluent-ffmpeg work on localhost and break the moment you deploy

Ways teams try to run ffmpeg on Vercel

Before Fotovid these were the options — each one is work you'd rather not own.

Option	What it costs you	Verdict
Bundle ffmpeg into your Vercel function	Blows past the 250MB function limit; Edge has no child_process
Self-host a container or VM	Always-on cost plus patching, scaling, and monitoring
Run a job queue + worker	New infra: a queue, workers, retries, dead-letter handling
Transcode in the browser (WASM)	Slow, memory-hungry, and crashes on mobile
Call the Fotovid API	One HTTPS request; nothing to run, package, or scale

How it works

Your first call in three steps

1
Grab a free API key
Sign up and create a key, no card required. You get a token in the form p6_<key_id>:<secret> that you pass as a Bearer authorization header. Drop it into your Vercel project's environment variables so your function can read it at runtime.
2
POST your video to the watermark endpoint
From your Vercel function, call POST /v1/video/watermark on https://api.fotovid.co with the standard envelope: a source_url pointing at your input video, plus a params object describing the overlay (an image or text watermark, its position, opacity, and scale). No binary, no bundle, no encode running inside your function. Fotovid does the ffmpeg work on its own infrastructure, so your timeout never enters the picture.
3
Use the returned hosted URL
The response comes back as flat JSON with an id, type, a fotovid-hosted url for the finished video, and an expires_at. Store your own copy of that file, or hand the URL straight to your frontend. Same envelope works for the rest of the API: trim, extract-audio, extract-cover, probe, and more.

Frequently asked questions

Keep exploring

Serverless ffmpeg — all guides Run ffmpeg on Netlify Run ffmpeg on Supabase Add watermark API Trim video API Pricing

Ship it with one API call

Grab a free key and make your first call in under five minutes.

Get your API key — free