Can't I just bundle a static ffmpeg binary or a layer with my Edge Function?

No. The blocker isn't the binary size — it's the runtime. Deno has no child_process/subprocess API, so there's no way to exec an ffmpeg binary from an Edge Function even if you ship it. Fotovid runs ffmpeg off-platform and hands you the result over HTTPS.

Does ffmpeg.wasm work inside a Supabase Edge Function?

It's a dead end in practice. Even where WASM loads, the CPU and wall-clock budgets for Edge Functions are sized for lightweight logic, not sustained encoding, so real media jobs time out. Offloading the encode to an API keeps your function fast and within limits.

How do I trigger this when a user uploads a file to Supabase Storage?

Use a Storage trigger to invoke your Edge Function on upload — that part Supabase does well. Inside the function, generate a signed HTTPS URL for the new object, pass it as source_url to Fotovid, and use the returned url. The trigger starts the job; Fotovid does the heavy lifting.

What do I send and get back?

Every sync endpoint takes { "source_url": " ", "params": { ... } } with an Authorization: Bearer p6_ : header. You get back flat JSON — id, type, url (the Fotovid-hosted result), an expires_at, and duration where relevant. No SDK required; it's a plain POST.

Is the output file permanent?

Treat it as temporary. The response includes an expires_at, so if you need the file long-term, download it from the returned url and store your own copy — for example back into Supabase Storage. Fotovid is an unbundled processing API, not a media host.

Can Fotovid do more than watermarking?

Yes. The same envelope and auth work across trim, extract-audio, extract-cover, audio trim, image watermark, and probe. It's the drop-in ffmpeg microservice for serverless — cheap, developer-first, and unbundled, unlike all-in-one platforms like Cloudinary or Transloadit.

ffmpeg on Supabase Edge Functions

ffmpeg on Supabase Edge Functions, offloaded to a single HTTPS call.

Edge Functions run on Deno, so there's no child_process to spawn the ffmpeg binary. Keep your function, offload the encode to an HTTPS call, and get back a finished file URL.

Get your API key — free Read the docs →

// supabase/functions/watermark/index.ts
Deno.serve(async (req) => {
  const { videoUrl, logoUrl } = await req.json();

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

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

Why ffmpeg won't run in your Edge Function

Supabase Edge Functions execute on the Deno runtime, which has no child_process or subprocess API — so there is nothing to spawn the ffmpeg binary with, even if you bundle it. On top of that, the CPU and wall-clock limits are sized for lightweight request logic, not for the seconds-to-minutes of sustained work that media encoding needs. A Storage trigger is a perfect place to *start* a job the moment a file lands, but the actual transcode has to happen somewhere that can run a real encoder.

No child_process / subprocess on Deno — you can't exec the ffmpeg binary
CPU and wall-clock limits target quick logic, not media encoding
Storage triggers are ideal for kicking off a job, but the work must run elsewhere
Static ffmpeg builds, WASM, and layers all dead-end against the runtime, not just the size

Ways teams try to run ffmpeg on Supabase

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 Supabase function	Deno has no child_process — you can't spawn the binary
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. Fotovid runs on usage credits — $1 = 100 credits and most operations cost 1 credit — so you can wire up the flagship watermark call and test it end to end before spending anything.
2
Call the watermark endpoint from your function
From inside the same Edge Function (or the Storage trigger that fired on upload), POST to https://api.fotovid.co/v1/video/watermark with an Authorization: Bearer p6_<key_id>:<secret> header. Send the standard envelope: a source_url pointing at your video's HTTPS URL — a Supabase Storage signed URL works directly — plus a params object describing the overlay, e.g. type image, a watermark_image_url, a position like bottom-right, and an opacity or scale. Your function just makes one HTTPS request; Fotovid runs the ffmpeg work off-platform, so you never touch the Deno CPU or time limits.
3
Use the hosted result URL
The response is flat JSON: an id, a type, and a url pointing at the finished, Fotovid-hosted video. Hand that url straight back to your caller, or download it and store your own copy in Supabase Storage. Treat the hosted URL as temporary — it carries an expires_at — so persist a copy if you need it to live long-term.

Frequently asked questions

Keep exploring

Serverless ffmpeg — all guides Run ffmpeg on Cloudflare Workers Run ffmpeg on AWS Lambda Trim video API Video thumbnail 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