This is the whole integration. One HTTP request offloads the command and returns right away, so your Edge Function stays inside the Deno sandbox limits.
// supabase/functions/transcode/index.tsimport { createClient } from "npm:@rendobar/sdk";
Deno.serve(async (req) => { const { videoUrl } = await req.json(); const rb = createClient({ apiKey: Deno.env.get("RENDOBAR_API_KEY")! });
// Offload the command, return right away. const job = await rb.jobs.create({ type: "raw.ffmpeg", params: { command: `ffmpeg -i ${videoUrl} -vn -c:a libmp3lame audio.mp3` }, });
return Response.json({ jobId: job.id });});You can't spawn FFmpeg inside a Supabase Edge Function. They run on the Supabase Edge Runtime, a Deno-compatible V8 isolate with no shell. Deno.Command is blocked on the hosted runtime, and there's no native ffmpeg binary to call.
ffmpeg.wasm doesn't rescue it either. The core is tens of megabytes of WebAssembly, and a real transcode runs past the function's 256 MB memory ceiling and its CPU limit. The offload version is the snippet at the top of this page.
// supabase/functions/transcode/index.tsDeno.serve(async (req) => { const { videoUrl } = await req.json();
// Deno can spawn subprocesses locally, but the hosted Supabase // Edge Runtime blocks Deno.Command and ships no ffmpeg binary. // In production this throws before a frame is decoded. const cmd = new Deno.Command("ffmpeg", { args: ["-i", videoUrl, "-vn", "-c:a", "libmp3lame", "out.mp3"], }); await cmd.output(); // never runs on the edge
return new Response("never gets here");});Your Edge Function calls rb.jobs.create with type "raw.ffmpeg" and your command string. It's one HTTPS request, so the function returns before the video is processed and stays inside the wall-clock and CPU limits.
Rendobar runs the exact FFmpeg command in an isolated container built for media work. Full codecs, no 256 MB memory ceiling, none of the Edge Runtime limits.
When the command finishes, the output is stored and the job result carries its URL. Read it from the webhook, then drop it into Supabase Storage or stream it to your user.
Rendobar POSTs the finished job to the endpoint you registered. Your function never had to wait, so it stays well under the execution limit.
You don't have to call it from a function at all. A Postgres trigger can submit the job the moment a file lands in Storage, using pg_net. The result URL comes back on your webhook, ready to write into the row.
-- Fire the Edge Function the moment a file lands in Storagecreate function notify_transcode() returns triggerlanguage plpgsql as $$begin perform net.http_post( url := 'https://<project>.supabase.co/functions/v1/transcode', body := json_build_object('videoUrl', new.name)::text, headers := '{"Authorization": "Bearer <anon-key>"}'::jsonb ); return new;end;$$;
create trigger on_storage_upload after insert on storage.objects for each row execute function notify_transcode();| Approach | Works on the edge? | Why |
|---|---|---|
| Deno.Command to spawn ffmpeg | No | Subprocess is blocked on the hosted runtime |
| ffmpeg.wasm in the function | No | Tens of MB, CPU and memory limited |
| Install a native binary | No | No shell or package install on the edge |
| Rendobar API (offload) | Yes | One fetch, fits the sandbox |
Edge Functions run on the Supabase Edge Runtime, a Deno-compatible V8 isolate. There's no shell, Deno.Command is blocked on the hosted runtime, and there's no native ffmpeg binary to call. Offloading the command keeps the function inside those limits.
Rendobar skips it for you. The ffmpeg.wasm core is tens of megabytes, and a real transcode blows past the Edge Function's 256 MB memory ceiling and its CPU limit before it finishes.
Yes. Any path that makes an HTTPS request can submit a job. A database webhook or a Postgres trigger using pg_net can fire your Edge Function on a row change, and hooking it to inserts on storage.objects starts a job the moment a file uploads.
Register a webhook endpoint once (rb.webhooks.create) and Rendobar POSTs each finished job to it. You can also poll GET /jobs/{id}, subscribe with the realtime SDK, or drop the result into Supabase Storage.
Jobs are billed by compute time. Every account begins with $5 in free credits and no credit card, so you can run a real transcode before paying anything.
The call is a plain HTTPS request, so the same offload runs from every serverless host. Pick your runtime and follow the guide.
$5 free on signup. No credit card. No subprocess needed.