Webflow + ReelSDK $0.03 per output minute, first $0.50 free

Video in Webflow sites

ReelSDK turns a CMS item into a narrated video for $0.03 per output minute plus $0.05 per 1,000 voiceover characters, about 1.2 cents for 5 photos and a short script. Webflow Cloud runs code on Cloudflare Workers with a 20 s request timeout and 30 s of CPU, and it can't spawn ffmpeg.

  • CMS item in, video link out
  • Both webhooks signature-checked
  • The mp4 is copied to your bucket before the 7-day link expires
Spawning ffmpeg in the Workers runtime that Webflow Cloud apps run on, locally with wrangler

Error: The child_process.spawn method is not implemented

at spawn (node:child_process:81:11)

Sources: Webflow Cloud: Node.js compatibility, Webflow Cloud: edge environment

The same job as one call to ReelSDK

curl "https://api.reelsdk.com/v1/slideshow?wait=60" \
  -H "Authorization: Bearer $REELSDK_KEY" \
  --json '{
    "images": [
      "https://api.reelsdk.com/f/lib/demo/seville/river.jpg",
      "https://api.reelsdk.com/f/lib/demo/seville/plaza.jpg",
      "https://api.reelsdk.com/f/lib/demo/seville/oranges.jpg",
      "https://api.reelsdk.com/f/lib/demo/seville/flamenco.jpg",
      "https://api.reelsdk.com/f/lib/demo/seville/tapas.jpg"
    ],
    "size": "16:9",
    "voiceover": {
      "text": "Three days in Seville. Plaza de España at noon, orange trees under the Giralda, flamenco after dark, and tapas until midnight.",
      "voice": "luna"
    },
    "music": {
      "url": "https://api.reelsdk.com/f/lib/music/chill/calm-currents.mp3",
      "volume": 0.15
    },
    "captions": "minimal"
  }'
200 in about 23 seconds: a 12-second 1920x1080 video with voiceover, music and minimal captionsTry it

Why ffmpeg breaks here

Workers can't run ffmpeg, and Logic is gone

Webflow Cloud deploys framework apps to Cloudflare Workers, where child_process exists only as a stub that throws, there is no file system, and each request gets 20 s and 30 s of CPU. The video on this page took about 23 seconds, so even a fast render outlives the request. Webflow Logic, the old no-code way to call an API, was shut down on June 27, 2025.

So a small Webflow Cloud app does it in two webhooks. When an item is published, Webflow calls the first route; it checks Webflow's signature, sends the item's photos and summary to ReelSDK with ?wait=0, and answers in about a second. When the video is done, ReelSDK calls the second route, which checks ReelSDK's signature, stores the mp4 in the app's bucket and writes its link into the item through the CMS API. Output links expire after 7 days, which is why the app keeps a copy.

This one cost about 1.2 cents: $0.03 per output minute for 12 s of video plus $0.05 per 1,000 characters of voiceover. Music and captions are free, failed jobs are free, and pricing has the rest. Watch a video made this way.

Webflow Cloud next to ReelSDK

Webflow Cloud next to ReelSDK
TopicWebflow CloudReelSDK
Running ffmpegchild_process throws, no file systemSlideshows, captions and raw ffmpeg over HTTPS
Time per request20 s, 30 s of CPU?wait=0 answers at once with a job id
Memory128 MB per workerInputs up to 500 MB each
Storing the videoBucket binding, no public bucketsOutput links for 7 days
Webhooksx-webflow-signature, 5 minute windowReelsdk-Signature, up to 6 attempts

Webflow limits from Webflow Cloud limits, checked November 2026.

Set it up

A Webflow Cloud app with three routes

This uses an Astro app on Webflow Cloud. Give the collection a Multi-image field photos, a Plain text field summary and a Link field video-link, then add a bucket binding VIDEOS in wrangler.json and a site webhook for collection_item_published that points at the first route.

  1. Add the secrets to the environment

    In the Webflow Cloud environment settings, add these as secrets. They stay on the server: never put the ReelSDK key in a page embed or custom code, where every visitor can read it. The Webflow token needs CMS:write.

    Webflow Cloud environment
    REELSDK_KEY
    rsdk_live_...
    REELSDK_WEBHOOK_SECRET
    whsec_...
    WEBFLOW_WEBHOOK_SECRET
    the site webhook's secret
    WEBFLOW_TOKEN
    site token with CMS:write
    APP_URL
    https://<your site>/<mount path>
  2. Start a render when an item is published

    Webflow signs the timestamp and the raw body, so the route verifies them before parsing anything and skips items that already have a video.

    src/pages/api/webflow.tsTry it
    import type { APIRoute } from "astro";
    
    export const prerender = false;
    
    // Webflow calls this on collection_item_published
    export const POST: APIRoute = async ({ request, locals }) => {
      const env = locals.runtime.env;
      const body = await request.text();
      const signed = await verifyWebflow(request.headers, body, env.WEBFLOW_WEBHOOK_SECRET);
      if (!signed) return new Response("invalid signature", { status: 401 });
    
      const item = JSON.parse(body).payload;
      const photos = (item.fieldData.photos ?? []).map((photo) => photo.url);
      const summary = item.fieldData.summary ?? "";
      if (item.fieldData["video-link"] || photos.length === 0 || !summary) {
        return new Response("skipped");
      }
    
      const callback = `${env.APP_URL}/api/reelsdk?collection=${item.collectionId}&item=${item.id}`;
      const res = await fetch("https://api.reelsdk.com/v1/slideshow?wait=0", {
        method: "POST",
        headers: {
          Authorization: `Bearer ${env.REELSDK_KEY}`,
          "Content-Type": "application/json",
          "Idempotency-Key": `webflow-${item.id}`,
        },
        body: JSON.stringify({
          images: photos.slice(0, 10),
          size: "16:9",
          voiceover: { text: summary, voice: "luna" },
          music: {
            url: "https://api.reelsdk.com/f/lib/music/chill/calm-currents.mp3",
            volume: 0.15,
          },
          captions: "minimal",
          webhook_url: callback,
        }),
      });
    
      if (!res.ok) return new Response(`reelsdk ${res.status}`, { status: 502 });
      return new Response("rendering");
    };
    
    async function verifyWebflow(headers: Headers, body: string, secret: string) {
      const timestamp = headers.get("x-webflow-timestamp") ?? "";
      const signature = headers.get("x-webflow-signature") ?? "";
      const fresh = Date.now() - Number(timestamp) <= 300_000;
      if (!/^[0-9a-f]{64}$/i.test(signature) || !fresh) return false;
    
      const encoder = new TextEncoder();
      const key = await crypto.subtle.importKey(
        "raw", encoder.encode(secret), { name: "HMAC", hash: "SHA-256" }, false, ["verify"],
      );
      const bytes = Uint8Array.from(signature.match(/../g)!, (pair) => parseInt(pair, 16));
      return crypto.subtle.verify("HMAC", key, bytes, encoder.encode(`${timestamp}:${body}`));
    }
    
  3. Store the video and update the item

    The second route only trusts a body that carries a valid ReelSDK signature, then copies the mp4 into the bucket and patches the live item.

    src/pages/api/reelsdk.ts
    import type { APIRoute } from "astro";
    
    export const prerender = false;
    
    // ReelSDK calls this when the video is done
    export const POST: APIRoute = async ({ request, locals, url }) => {
      const env = locals.runtime.env;
      const body = await request.text();
      const header = request.headers.get("reelsdk-signature");
      const signed = await verifyReelsdkSignature(header, body, env.REELSDK_WEBHOOK_SECRET);
      if (!signed) return new Response("invalid signature", { status: 401 });
    
      const job = JSON.parse(body);
      const collection = url.searchParams.get("collection") ?? "";
      const item = url.searchParams.get("item") ?? "";
      const ids = /^[0-9a-f]{24}$/;
      if (job.status !== "succeeded" || !ids.test(collection) || !ids.test(item)) {
        return new Response("ok");
      }
    
      // Output links expire after 7 days, so we keep our own copy in the bucket
      const video = await fetch(job.outputs.video);
      if (!video.ok) return new Response("download failed", { status: 502 });
      await env.VIDEOS.put(`${job.id}.mp4`, await video.arrayBuffer(), {
        httpMetadata: { contentType: "video/mp4" },
      });
    
      const live = `https://api.webflow.com/v2/collections/${collection}/items/${item}/live`;
      const res = await fetch(live, {
        method: "PATCH",
        headers: {
          Authorization: `Bearer ${env.WEBFLOW_TOKEN}`,
          "Content-Type": "application/json",
        },
        body: JSON.stringify({
          fieldData: { "video-link": `${env.APP_URL}/api/videos/${job.id}.mp4` },
        }),
      });
    
      if (!res.ok) return new Response(`webflow ${res.status}`, { status: 502 });
      return new Response("ok");
    };
    
    async function verifyReelsdkSignature(header: string | null, body: string, secret: string) {
      const parts = Object.fromEntries((header ?? "").split(",").map((part) => part.split("=")));
      const age = Math.abs(Date.now() / 1000 - Number(parts.t));
      if (!/^[0-9a-f]{64}$/i.test(parts.v1 ?? "") || !(age <= 300)) return false;
    
      const encoder = new TextEncoder();
      const key = await crypto.subtle.importKey(
        "raw", encoder.encode(secret), { name: "HMAC", hash: "SHA-256" }, false, ["verify"],
      );
      const pairs = parts.v1.match(/../g) ?? [];
      const signature = Uint8Array.from(pairs, (pair) => parseInt(pair, 16));
      return crypto.subtle.verify("HMAC", key, signature, encoder.encode(`${parts.t}.${body}`));
    }
    
  4. Serve the videos

    Point a Video or Embed element, or your own player, at the video-link field.

    src/pages/api/videos/[file].ts
    import type { APIRoute } from "astro";
    
    export const prerender = false;
    
    // Webflow Cloud has no public buckets, so this route streams the stored videos
    export const GET: APIRoute = async ({ params, request, locals }) => {
      const bucket = locals.runtime.env.VIDEOS;
      const file = params.file ?? "";
      const stored = /^job_[a-z0-9]+\.mp4$/.test(file) ? await bucket.head(file) : null;
      if (!stored) return new Response("not found", { status: 404 });
    
      const headers = new Headers({
        "Content-Type": "video/mp4",
        "Accept-Ranges": "bytes",
        "Cache-Control": "public, max-age=31536000, immutable",
        ETag: stored.httpEtag,
      });
    
      // Safari asks for byte ranges before it plays a video
      const range = /^bytes=(\d+)-(\d*)$/.exec(request.headers.get("range") ?? "");
      if (!range) return new Response((await bucket.get(file))?.body, { headers });
    
      const start = Number(range[1]);
      const end = Math.min(range[2] ? Number(range[2]) : stored.size - 1, stored.size - 1);
      if (start > end) {
        headers.set("Content-Range", `bytes */${stored.size}`);
        return new Response(null, { status: 416, headers });
      }
    
      const length = end - start + 1;
      const part = await bucket.get(file, { range: { offset: start, length } });
      headers.set("Content-Range", `bytes ${start}-${end}/${stored.size}`);
      return new Response(part?.body, { status: 206, headers });
    };
    

FAQ

Video on Webflow, answered

Can Webflow run ffmpeg?

No. Webflow sites are hosted pages, and Webflow Cloud runs app code on Cloudflare Workers, where child_process can't spawn anything and there is no file system. Send the render to ReelSDK and store the finished mp4.

Why not render inside one Webflow Cloud request?

A request may run for 20 seconds, and even a 12-second video takes about 23 seconds to render. Start the job with ?wait=0, answer Webflow at once, and let the ReelSDK webhook bring the result back.

Can I call ReelSDK from a Webflow embed or custom code?

Not with your API key: anything in an embed runs in the visitor's browser, where the key can be copied. Keep the key in the Webflow Cloud environment and call ReelSDK from a route.

Where does the video live?

ReelSDK's output links expire after 7 days, so the app copies the mp4 into its bucket. Webflow Cloud doesn't serve buckets publicly, so a small route streams the file, and its URL goes into a Link field on the item.

What does it cost?

$0.03 per output minute plus $0.05 per 1,000 voiceover characters, so a 12-second video with a short voiceover costs about 1.2 cents. Music and captions are free, the first $0.50 is free and failed jobs cost nothing.

All integrations

Ready to build?

Ship video from your app today

Your first $0.50 is free, and one key covers every endpoint.

Moonlit lake with a lit cabin under the mountains