Jellyfin vs Plex — measured on the same box

Disclosure: this article contains affiliate links. If you buy through them, Rack at Home may earn a commission at no extra cost to you. We test everything we recommend.

Tested on 2026-10-28, end-to-end, on our own hardware.

"Jellyfin or Plex?" is the most argued question in home media, and almost every answer on the internet is a feature list copied from a wiki. We did the boring instead: installed both official servers as containers on the same Linux box, gave them the same resources, and wrote down the numbers. Then we tried to set each one up the way an automation-minded person would — no browser, just API calls — and hit a wall that almost nobody mentions. This is what we measured, including the parts we could not measure honestly.

How we tested

The bench was a small Ubuntu KVM VM from our home lab — the kind of modest box plenty of readers already have running. Both servers went in as their official containers: jellyfin/jellyfin:latest and the linuxserver/plex image, each in an identical 2 vCPU / 4 GB-class container on the same host, sharing one tiny sample media file. Every number below comes from that single machine, so the comparison is apples to apples. Where we could not measure something, we say so rather than guess.

Install and pull: 36 seconds of difference, 2 GB of it in an image

Both images pulled cleanly over a home connection. The interesting part isn't the time — 14 seconds for Jellyfin versus 13 for Plex, a rounding error on fibre — it's what those seconds moved: 2.49 GB for the Jellyfin image against 631 MB for Plex. On a metered connection, or when you pull updates onto a NAS that isn't on fibre, a four-times-larger image is a real cost. It also tells you something about philosophy: the Jellyfin image bundles a lot of dependencies to stay self-contained and distro-friendly; Plex ships lean and expects the host to carry the rest.

One number here matters more than any benchmark: that 2.49 GB recurs every time you refresh the image, not just once. Jellyfin ships releases often, and each update re-pulls gigabytes onto whatever disk hosts your media box; Plex's lean image keeps updates cheap and low-friction. Neither publishes a rollback path, so snapshot the last working tag before touching either — a five-second habit that's the difference between a ten-minute fix and a bad evening.

Idle footprint: both are sippers

This is the answer people usually want, and it deflates the whole debate: neither server is the reason your box feels slow. After about 75 seconds of warmup with an empty-ish library, docker stats read 161.8 MiB of RAM and effectively 0% CPU for Jellyfin, versus 240.7 MiB and 0.56% CPU for Plex. Over the next minutes both settled lower and steadier — Jellyfin around 173 MiB, Plex back down near 175 MiB with CPU hovering around half a percent. Call it a wash for idle RAM at steady state, with Jellyfin lighter in the first minute and Plex doing a little background work it considers housekeeping.

If your media server is the heaviest thing on your machine, your machine is fine. The fights start when transcoding enters the picture, and that's exactly where we have to be honest (below).

Cold start: which is "up" first? Both lie

We killed both containers and timed a fresh start with a brand-new configuration directory. The trap here catches monitoring scripts: within about two seconds, both servers answer HTTP on their ports — with 503. A healthcheck that treats "anything answering" as ready will declare victory far too early.

Timed properly, against endpoints that mean the application itself is listening — Jellyfin's system-info API and Plex's identity endpoint — Plex was functionally up in about 4 seconds and Jellyfin in about 6. Four versus six seconds: both are instant for human purposes. If you're scripting around either server, poll the real endpoint, not the port.

The wall: neither one finishes setup headlessly

Here's the finding that didn't make it into the feature lists. We tried to complete initial setup without opening a browser — the dream of a fully scripted, rebuildable media stack. On Jellyfin 12.4, every route to create the first administrator over the API returns 401. We tried both documented user-creation endpoints, from the host network and from inside the container's own network namespace, and both refused: there is no unauthenticated path to the first user. First boot is a browser wizard, full stop.

Plex fails the same experiment differently. An unclaimed Plex server — one not yet tied to an account — never returns a successful page for its own web interface. Our first automation script sat waiting for an HTTP 200 that this state never produces, and burned seven minutes before we noticed the bug was our assumption, not the server's. Getting Plex to a usable state means claiming it through a Plex account, in a browser or an app.

The honest line, tested on 2026 builds of both: both servers demand interactive browser setup — Jellyfin's first-admin wizard, Plex's account claim — and neither offers a supported headless path. If your plan was "rebuild my whole media stack from a script," factor in the human step, and keep the config directory backed up so you never have to redo it.

What we deliberately did not measure

Two headline numbers — full library scan time and hardware-transcode behaviour — are missing from this article on purpose. Our bench had no GPU pass-through wired up and a one-file sample library, and both servers were stuck at the setup wall above. Scan times on a real 5,000-item library and transcode quality on real footage are the numbers that actually differ, and publishing fake ones for them would be worse than publishing none. If you're choosing between these two on transcoding alone, that's the variable to test on your own hardware — it's the one thing in this comparison our bench couldn't fairly answer.

"Is Plex free?" — the real answer as of today

We pulled Plex's own plans page live on 2026-10-28. The gating, straight from it:

Read that table carefully, because it's the whole argument in one place: Plex's free tier is genuinely fine for a single-user, in-home server. The paid tier is what you reach the moment a household, a phone on mobile data, or a modest GPU enters the picture. Jellyfin needs no table — it's free software with no tier at all, every feature included. What you pay there is in setup friction and in a thinner first-party app ecosystem.

So which one, then?

• One person, home Wi-Fi, wants it to just work: Plex free. It's up in seconds, sips under 200 MiB idle, and the free tier covers your actual use case. Don't let anyone sell you a Pass for a server you never leave the house with.
• A household with more than one viewer, or you want remote access and hardware transcoding: put real numbers on the table — Plex's paid tier against Jellyfin's $0 with a bit of your Saturday. On a home server, your time is the cost column that matters.
• You script everything and rebuild from config: Jellyfin's lighter image and fully local operation fit better — but budget the interactive first-run, because as measured above, no API shortcut exists in 12.4.

Every number in this article came off one machine in one afternoon, and we've told you exactly which parts we couldn't test. If you think we got the call wrong — or your idle numbers look nothing like ours — that's the point of publishing the measurements. Come defend your stack; the bench is documented.