React Native + ReelSDK $0.02 per compute minute, first $0.50 free

FFmpeg in React Native and Expo after ffmpeg-kit

ffmpeg-kit is retired and its binaries are gone. ReelSDK runs ffmpeg from your backend for $0.02 per compute minute: a 5.5 MB phone clip becomes a 1.1 MB 720p mp4 in about 6 seconds, and the app ships no native code and no API key.

  • Same ffmpeg arguments, run on a server
  • Works in Expo Go
  • API key stays on your backend
Installing ffmpeg-kit-react-native 6.0.2, then resolving the Android library it depends on with Gradle

npm warn deprecated ffmpeg-kit-react-native@6.0.2: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.

> Could not find com.arthenica:ffmpeg-kit-https:6.0-2.

Searched in the following locations:

- https://repo.maven.apache.org/maven2/com/arthenica/ffmpeg-kit-https/6.0-2/ffmpeg-kit-https-6.0-2.pom

BUILD FAILED in 6s

Sources: Saying goodbye to FFmpegKit, ffmpeg-kit-react-native on npm

The same job as one call to ReelSDK

curl "https://api.reelsdk.com/v1/ffmpeg?wait=60" \
  -H "Authorization: Bearer $REELSDK_KEY" \
  --json '{
    "inputs": {
      "in.mp4": "https://api.reelsdk.com/f/lib/demo/clip.mp4"
    },
    "args": [
      "-i", "in.mp4", "-vf", "scale=720:-2", "-c:v", "libx264", "-preset",
      "veryfast", "-crf", "28", "-c:a", "aac", "-b:a", "96k", "-movflags",
      "+faststart", "out.mp4"
    ],
    "outputs": ["out.mp4"]
  }'
200 in about 6 seconds: an 11-second phone clip re-encoded to 720x1280, 5.5 MB down to 1.1 MBTry it

Why ffmpeg breaks here

The binaries are gone, so ffmpeg moves to your server

ffmpeg-kit was retired on January 6, 2025, and its prebuilt binaries were removed from Maven Central and the GitHub releases: versions before 6.0 on February 1, 2025, and 6.0 on April 1, 2025. The npm package is deprecated and the repository is archived, so a clean Android build fails on the missing ffmpeg-kit-https library. Community forks on npm rebuild the binaries, but then you own a native ffmpeg build: a full GPL Android build of ffmpeg-kit carries 44.1 MB of arm64 native libraries, Google Play has required 16 KB page support for apps targeting Android 15 and higher since November 1, 2025, and Expo Go can't load custom native code at all. Every other way off ffmpeg-kit is in ReelSDK vs FFmpegKit.

The other way is to keep ffmpeg off the phone. The app sends the picked video to your own backend, which checks the user's session, uploads the bytes to POST /v1/uploads and runs the same arguments through POST /v1/ffmpeg. On a 200 the job carries the mp4's link. Without a session the route below answers 401; with one it answers 200 in about 6 seconds. The key stays on the server, the app is plain fetch, and it works the same in Expo Go and in a store build.

Raw ffmpeg costs $0.02 per compute minute, billed by the second, and failed jobs are free. Output links last 7 days, so copy the file to your own storage if you keep it. Pricing has the other job types, and a re-encoded clip shows the output.

ffmpeg-kit on the phone next to ReelSDK

ffmpeg-kit on the phone next to ReelSDK
Topicffmpeg-kit in the appReelSDK from your backend
PackageDeprecated, binaries removedPOST /v1/ffmpeg with the same arguments
ExpoNeeds a development build, not Expo GoPlain fetch, works in Expo Go
App size44.1 MB of arm64 libraries in a full GPL buildNothing added to the app
Android 16 KB pagesYour native build has to support themNothing to rebuild
Big filesLimited by the phone100 MiB per upload, up to 5 GB multipart

React Native limits from Saying goodbye to FFmpegKit, checked November 2026.

Set it up

One route on your backend, one call in the app

Any backend works. This one is Node with Hono, and verifySession stands for whatever auth your app already has. Remove ffmpeg-kit-react-native and its config plugin from the app before you rebuild.

  1. Keep the key on the server

    Set REELSDK_KEY in the backend's environment. Never in an EXPO_PUBLIC_ variable or app.json: Expo inlines those into the bundle, where anyone can read them.

    Backend environment
    REELSDK_KEY
    rsdk_live_...
  2. Add the route

    It takes the raw video up to 100 MiB, sends it to ReelSDK's upload storage and runs the ffmpeg job, waiting up to 60 s. A longer job answers 202 with its id; poll GET /v1/jobs/{id} from the server until it is done.

    server.tsTry it
    import { serve } from "@hono/node-server";
    import { Hono } from "hono";
    import { bodyLimit } from "hono/body-limit";
    import { verifySession } from "./auth";
    
    const API = "https://api.reelsdk.com/v1";
    const app = new Hono();
    
    app.post("/clips", bodyLimit({ maxSize: 100 * 1024 * 1024 }), async (c) => {
      const user = await verifySession(c.req.header("Authorization"));
      if (!user) return c.json({ error: "sign in first" }, 401);
    
      const clip = await c.req.arrayBuffer();
      if (clip.byteLength === 0) return c.json({ error: "empty body" }, 400);
    
      // The clip goes to ReelSDK's upload storage, then the ffmpeg job reads it from there
      const upload = await reelsdk("/uploads?filename=clip.mp4", clip, "video/mp4");
      const { job } = await reelsdk(
        "/ffmpeg?wait=60",
        JSON.stringify({
          inputs: { "in.mp4": upload.url },
          args: [
            "-i", "in.mp4", "-vf", "scale=720:-2", "-c:v", "libx264", "-preset", "veryfast",
            "-crf", "28", "-c:a", "aac", "-b:a", "96k", "-movflags", "+faststart", "out.mp4",
          ],
          outputs: ["out.mp4"],
        }),
        "application/json",
      );
    
      const video = job.outputs?.["out.mp4"] ?? null;
      return c.json({ id: job.id, status: job.status, video });
    });
    
    async function reelsdk(path: string, body: BodyInit, type: string) {
      const res = await fetch(API + path, {
        method: "POST",
        headers: { Authorization: `Bearer ${process.env.REELSDK_KEY}`, "Content-Type": type },
        body,
      });
    
      const data = await res.json();
      if (!res.ok) throw new Error(`reelsdk ${res.status}: ${data.error?.message}`);
      return data;
    }
    
    serve({ fetch: app.fetch, port: Number(process.env.PORT ?? 3000) });
    
  3. Call it from the app

    The app only knows your backend's URL and the user's session token.

    lib/edit-clip.ts
    import * as ImagePicker from "expo-image-picker";
    
    const API_URL = process.env.EXPO_PUBLIC_API_URL;
    
    // The app only talks to our own backend, the ReelSDK key never ships in the bundle
    export async function editClip(sessionToken: string) {
      const picked = await ImagePicker.launchImageLibraryAsync({ mediaTypes: ["videos"] });
      if (picked.canceled) return null;
    
      const clip = await (await fetch(picked.assets[0].uri)).blob();
      const res = await fetch(`${API_URL}/clips`, {
        method: "POST",
        headers: { Authorization: `Bearer ${sessionToken}`, "Content-Type": "video/mp4" },
        body: clip,
      });
    
      if (!res.ok) throw new Error(`clip upload failed: ${res.status}`);
      return (await res.json()) as { id: string; status: string; video: string | null };
    }
    

FAQ

Video on React Native, answered

Is ffmpeg-kit-react-native still maintained?

No. ffmpeg-kit was retired on January 6, 2025, its binaries were removed by April 1, 2025, the npm package is deprecated and the repository is archived. Community forks exist, but you then build and update the native ffmpeg binaries yourself.

Can I use ffmpeg in Expo Go?

Not on the device: Expo Go only loads native libraries that ship with the Expo SDK. Sending the video to your backend over HTTPS works in Expo Go, in development builds and in store builds alike.

Why not call ReelSDK straight from the app?

Anything in the app bundle can be read by whoever installs it, including an API key. The app calls your backend with the user's session, and only the backend holds the ReelSDK key.

How big can the video be?

POST /v1/uploads takes up to 100 MiB in one request and multipart uploads go up to 5 GB. A job reads inputs of up to 500 MB each and up to 15 minutes of media.

What does it cost?

Raw ffmpeg is $0.02 per compute minute, billed by the second. Failed jobs are free and the first $0.50 is free.

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