Send a video URL and -vn -c:a libmp3lame -q:a 2 to ReelSDK's POST /v1/ffmpeg and get an MP3 link back. At $0.02 per compute minute, a 30-second clip costs under a tenth of a cent, so $1 covers over 1,000 of them.

Video to MP3 API

Yes: -vn drops the picture and -q:a 2 encodes the sound as variable-bitrate MP3 at about 184 kb/s, and ReelSDK returns a 30-second clip in a few seconds.

Use casesUpdated

launch.mp3: 30 s at about 184 kb/s and 691 KB, from the NASA launch clip.Input: launch.mp4

The request

POST /v1/ffmpeg

Pull the audio track out of any video as an MP3 with one ffmpeg call, under a tenth of a cent for a 30 s clip.

terminalTry it
curl "https://api.reelsdk.com/v1/ffmpeg?wait=60" \
  -H "Authorization: Bearer $REELSDK_KEY" \
  --json '{
    "inputs": {
      "launch.mp4": "https://api.reelsdk.com/f/lib/in/use-cases/launch.mp4"
    },
    "args": [
      "-i", "launch.mp4", "-vn", "-c:a", "libmp3lame", "-q:a", "2",
      "launch.mp3"
    ],
    "outputs": ["launch.mp3"]
  }'
request.mjsTry it
const res = await fetch("https://api.reelsdk.com/v1/ffmpeg?wait=60", {
  method: "POST",
  headers: { Authorization: `Bearer ${process.env.REELSDK_KEY}`, "Content-Type": "application/json" },
  body: JSON.stringify({
    "inputs": {
      "launch.mp4": "https://api.reelsdk.com/f/lib/in/use-cases/launch.mp4"
    },
    "args": [
      "-i", "launch.mp4", "-vn", "-c:a", "libmp3lame", "-q:a", "2",
      "launch.mp3"
    ],
    "outputs": ["launch.mp3"]
  }),
});
const { job } = await res.json();
response.json
{
  "job": {
    "id": "job_aj1whjhuk437dd9r0l14",
    "op": "ffmpeg",
    "status": "succeeded",
    "stage": null,
    "created_at": "2026-11-07T01:20:08.770Z",
    "finished_at": "2026-11-07T01:20:12.606Z",
    "outputs": {
      "launch.mp3": "https://api.reelsdk.com/f/out/job_aj1whjhuk437dd9r0l14/launch.mp3?s=..."
    },
    "result": null,
    "duration_s": 30.016,
    "error": null,
    "usage": {
      "output_seconds": 30.016,
      "audio_seconds": 0,
      "tts_characters": 0,
      "images": 0
    },
    "poll_url": "https://api.reelsdk.com/v1/jobs/job_aj1whjhuk437dd9r0l14"
  }
}

How the ffmpeg arguments work

When you pass -i, launch.mp4, -vn, -c:a, libmp3lame, -q:a, 2, and launch.mp3 in args, ReelSDK hands that array straight to ffmpeg without a shell. The -vn flag drops the H.264 video stream from the 18.6 MB launch.mp4 source. Then -c:a libmp3lame with -q:a 2 encodes the AAC track into a variable-bitrate MP3. For this 30-second clip, that averages about 184 kb/s and makes a 691 KB launch.mp3.

The output file name in outputs and at the end of args tells ffmpeg which container format to write. If you want another audio format instead of mp3, change the extension on launch.mp3 (see the ffmpeg docs for full details).

  • mp3
  • m4a and aac
  • wav and flac
  • ogg and opus

At a glance

Ways to turn a video into an MP3

Ways to turn a video into an MP3
OptionPriceLimitsWhat you run
ffmpeg on your own machineFree; LGPL 2.1 or later, or GPL 2 or later with GPL libraries such as libx264Your CPU, disk and bandwidthffmpeg builds, a job queue, storage
AWS Lambda with an ffmpeg layer$0.0000166667 per GB-second plus $0.20 per 1M requests (x86, US East)900 s per run, 10,240 MB memory and /tmp, 250 MB of code and layers, 6 MB sync payloadThe layer, S3 in and out, retries
FFmpeg Micro1 token per 10 s of input, 500 tokens for $5; this 30 s clip: 3 tokens, $0.03100 MB input on the free plan, 1,024 MB on Starter and ProAPI calls
ReelSDK$0.02 per compute minute; under a tenth of a cent for this 30 s clip500 MB per file, 1 GB per job, 10 minutes of run timeOne HTTP call

Sources: FFmpeg license and legal, AWS Lambda quotas, AWS Lambda pricing, FFmpeg Micro pricing, checked November 2026.

Running this on ReelSDK vs your own servers

Running ffmpeg on AWS Lambda means packaging the binary as a layer inside the 250 MB unzipped deployment package limit. Because Lambda caps synchronous request and response payloads at 6 MB, you can't pass an 18.6 MB video directly; you have to move files through S3, work within 512 MB to 10,240 MB of /tmp storage, and finish before the 900 seconds (15 minutes) invocation timeout. If you put ffmpeg on your own server instead, you have to run a job queue and storage yourself.

With POST /v1/ffmpeg, you map a file name to a URL under inputs and each job runs on its own fresh machine. ReelSDK fetches inputs up to 500 MB each (up to 1 GB and 50 inputs per job) and stores up to 20 outputs per job. If you have a local file instead of a URL, one upload takes up to 100 MiB and is kept 7 days, and files over 100 MiB go up as a multipart upload.

Timing, webhooks, and billing

Fetching launch.mp4, running ffmpeg and storing launch.mp3 billed about 1.5 seconds of compute, and machine start-up isn't billed. At $0.02 per compute minute, billed per second with a 1 s minimum (see pricing), that came to under a tenth of a cent. Failed jobs cost $0, and you get $0.50 of free credit at sign-up.

A request to POST /v1/ffmpeg waits 60 s by default (and up to 300 s) for the result, while a longer job keeps running in the background so you can poll it or get a webhook, and output files are kept 7 days.

What it costs

What this job cost

Compute: fetching the input, running ffmpeg and storing the MP3
1.5 s
Rate
$0.02 per compute minute
Charged
$0.0005

Billed per second with a 1 s minimum. Machine start-up is not billed, and failed jobs cost $0.

Limits

What one request takes

Input files
500 MB each, 1 GB per job
Job run time
Up to 10 minutes
Audio formats out
mp3, m4a, aac, wav, flac, ogg, opus
Waiting for a result
60 s by default, up to 300 s
Output retention
7 days

How it works

From request to file

  1. Host the input

    Any public http or https URL on the default port works, as long as it has no username or password in it; ReelSDK downloads it before ffmpeg starts. A local file goes up with POST /v1/uploads?filename=clip.mp4 first: up to 100 MiB per upload, kept 7 days, and larger files go up as a multipart upload.

  2. Send the arguments

    Map the URL to a file name under inputs, then pass the arguments you would type after ffmpeg: -vn drops the picture and -c:a libmp3lame -q:a 2 writes variable-bitrate MP3. List launch.mp3 under outputs so ReelSDK keeps it.

  3. Download the result

    Every file is listed under job.outputs, and the links work for 7 days, so copy what you keep. For long jobs, send ?wait=0 with a webhook_url and fetch GET /v1/jobs/{id} when the webhook arrives.

FAQ

Questions, answered

How do I output a different audio format like WAV or M4A?

Change the output file extension in both args and outputs from launch.mp3 to the format you want, such as m4a, aac, wav, flac, ogg, or opus. You'll also need to drop or replace -c:a libmp3lame and -q:a 2 in args since those flags are for the MP3 encoder. Everything goes into the args JSON array and runs on ffmpeg without a shell.

What does -q:a 2 do to the audio?

Passing -q:a 2 to libmp3lame sets variable-bitrate encoding, which averaged about 184 kb/s on this track. The 30-second launch.mp4 became a 48 kHz launch.mp3 of 691 KB.

How does the cost compare to FFmpeg Micro and AWS Lambda?

ReelSDK bills $0.02 per compute minute per second with a 1 s minimum, so about 1.5 seconds of compute for this 30 s video cost under a tenth of a cent. On FFmpeg Micro, billing is 1 token per 10 seconds of input (metered per second), so a 30 s input takes 3 tokens, or $0.03 at the top-up rate of 500 tokens for $5. AWS Lambda charges $0.0000166667 per GB-second (x86, US East) and $0.20 per 1M requests.

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