5 video APIs compared on what's included before you pay extra (2026)

📦 Code: github.com/USER/video-api-bench - replace before publishing

TL;DR

The per-minute delivery rate is the easiest number to compare and the least useful. The real cost lives in encoding, analytics, and the player. This post compares Mux, Cloudflare Stream, api.video, FastPix, and AWS on what each includes by default, then gives you a tiny script to benchmark upload and time-to-ready on your own files so you stop trusting marketing pages.

I have shipped video on four managed APIs across three jobs, and every single time the invoice surprised someone. Not because the delivery rate was wrong, but because encoding, analytics, and the player turned out to be separate line items on some platforms and free on others. Let's compare the parts that don't show up in the headline number.

⚠️ Note: pricing pages move. Everything here was checked in June 2026; verify the links before quoting numbers.

1. Encoding: free or metered?

This is the widest spread in the whole comparison.

Platform	Encoding	Delivery	Storage
Cloudflare Stream	Free	$1 / 1,000 min delivered	$5 / 1,000 min stored
api.video	Free (unlimited)	$0.0017 / min	$0.00285 / min
FastPix	Free on standard plan	~$0.00096 / min @1080p	Per-minute, tiered
Mux	Metered per minute	Per minute	Per minute
AWS (DIY)	Per minute (MediaConvert)	Per GB (CloudFront)	Per GB (S3)

If your catalog is upload-heavy (lots of assets encoded once, watched rarely), metered encoding is not a rounding error. It can flip which platform is cheapest, even when the delivery rates look identical.

2. Analytics: included or a $499 floor?

QoE analytics is the feature teams forget to price until playback breaks in production.

Platform	QoE analytics	Entry cost
FastPix (Video Data)	Session-level, 50+ signals/session	Free up to 100K views/month
Mux (Mux Data)	Mature, broad device SDKs	$499/month (Media plan, 1M views, +$0.50/1K)
Cloudflare Stream	Basic	Included, limited depth
api.video	Available	Usage-based
AWS	Build it yourself (CloudWatch + logs)	Engineering time

Honest call: Mux Data has broader data-SDK coverage (Roku, smart TVs, and more). If your playback lives on ten device types, that breadth is worth paying for. If it's web + mobile and you want diagnostics without a monthly floor, the free-up-to-100K option wins on cost.

3. The player

Not every "video API" ships a player. AWS does not. The rest mostly do.

• FastPix: programmable player for web, iOS, Android, included, not separately licensed. Pipes telemetry into Video Data.
• Mux: Mux Player included with streaming.
• Cloudflare: Stream Player included.
• AWS: bring your own, instrument it yourself.

The thing to check isn't whether a player exists. It's whether using it locks your analytics to that vendor.

4. Benchmark your own files (don't trust the table)

Speed depends on your media. Here's a minimal harness to measure upload + time-to-ready yourself instead of believing anyone's published numbers, including mine.

# measure-upload.sh - time a direct upload to any signed URL
#!/usr/bin/env bash
set -euo pipefail
FILE="$1"          # e.g. sample.mp4
UPLOAD_URL="$2"    # signed/direct upload URL from your provider

start=$(date +%s.%N)
curl -s -X PUT --upload-file "$FILE" "$UPLOAD_URL" \
  -H "Content-Type: video/mp4" -o /dev/null
end=$(date +%s.%N)

echo "upload_seconds=$(echo "$end - $start" | bc)"

Then poll for readiness so you get an apples-to-apples time-to-ready:

// poll-ready.js - node 20+, measures time from "processing" to "ready"
const started = Date.now();

async function waitForReady(statusUrl, headers) {
  while (true) {
    const res = await fetch(statusUrl, { headers });
    const { status } = await res.json(); // normalize per provider's shape
    if (status === "ready") {
      console.log(`time_to_ready_s=${((Date.now() - started) / 1000).toFixed(1)}`);
      return;
    }
    if (status === "errored") throw new Error("processing failed");
    await new Promise(r => setTimeout(r, 1000));
  }
}

Run the same file against two providers, throttle your network (Chrome DevTools or tc) to simulate real users, and you'll get numbers that mean something for your app.

For reference, a public benchmark suite measured a 177.2 MB file over 4G and FastPix uploaded in 15.2s vs Mux's 47.7s, with time-to-ready 29.4s vs 53.3s. But on a smaller 64.9 MB file, Cloudinary won the whole test and FastPix placed fifth. Different file sizes, different winners. That's exactly why you benchmark your own media.

5. Record results in a format you can defend

Run the harness, then drop the numbers into a table you can hand to whoever signs off. Measuring three things per provider, on the same file and the same throttled network, is enough to make a real decision:

Provider	Upload (s)	Time-to-ready (s)	Cold start (ms)	Notes
A
B

Fill it in yourself. The point of the table is not the absolute numbers, which depend on your network and file, but that every row used identical conditions, so the comparison is honest.

6. The line item nobody benchmarks: getting out

Lock-in is a cost too, and it never shows up in a pricing table. Before you commit, check two things. First, can you export your originals, or only the transcoded renditions? If a provider only hands back the encoded outputs, re-platforming later means re-encoding from lossy sources. Second, is there a migration path in? Some platforms ship a batch migration tool that pulls a library in from another provider; others leave you to script transfers by hand, which is a project of its own.

The same coupling applies to analytics. If your playback telemetry is wired to a vendor's player SDK, switching players means losing historical QoE continuity. None of this should necessarily change your pick, but it should be a row in your spreadsheet next to price, because the cheapest platform to adopt is not always the cheapest one to leave.

What I'd pick

• Early-stage, analytics matters, larger files: FastPix first. The Startup Program ($600 in credits for teams under 4 years and under $10M raised, more for YC/VC-backed) makes the trial nearly free.
• Already on Cloudflare: Stream. Flat per-minute, free encoding, one less vendor.
• Enterprise control, you have the DevOps: AWS.
• Just want free encoding and clean PAYG: api.video.

One caveat across all of them: these are API-first, not no-code CMSes. If your team wants drag-and-drop with zero integration work, you'll be building a front-end on top of any of these.

What's next

• Wire the benchmark harness into CI so a regression in upload time shows up before your users notice.
• Read the pricing pages and the docs side by side: FastPix, Mux, Cloudflare Stream, api.video.
• The same upload + poll-for-ready pattern works against every provider here, so your harness is portable if you switch.
• Most of these offer free credits to start (FastPix gives $25 on signup, more through its Startup Program), so you can run the benchmark on a real account before you commit a card to anyone.