Why I Moved From Plex to Jellyfin (and Got Free GPU Transcoding)

Why I Moved From Plex to Jellyfin

I've run Plex on my homelab for years. It worked. So why rip it out and replace it with Jellyfin?

One reason, mostly: hardware transcoding is paywalled in Plex but isn't in Jellyfin.

I'd already done the hard part — passing my Intel iGPU through to the VM that runs my media stack — specifically so the server could transcode video on the GPU instead of hammering the CPU. Then I hit the wall: Plex only enables hardware transcoding if you pay for Plex Pass. I'd built the capability, and Plex wanted a subscription to let me use it.

Jellyfin does the same job, including hardware transcoding, for free. That was enough to make the switch.

What transcoding is, and why the GPU matters

Quick primer for anyone new to this. When you stream a video, the file's format may not match what your TV or phone can play directly. The server then transcodes — re-encodes the video on the fly into something the client understands.

Done on the CPU, transcoding is brutal: a single 4K stream can peg every core and still stutter. Done on a GPU (Intel QuickSync, in my case), it's near-effortless — the dedicated video hardware handles it while the CPU sits idle.

So, GPU transcoding is the difference between "one stream and the server's on fire" and "several streams and nothing notices." For a home server, it's the feature that matters. And Plex charges for it.

The advantages I was actually after

• Free hardware transcoding. The headline. Same capability, no subscription.
• No account, no cloud dependency. Plex increasingly routes through its own accounts and online services. Jellyfin is entirely self-hosted — it talks to nothing outside my network unless I tell it to.
• Open source. I can see exactly what it does, and it isn't going to sprout ads or a new paywall next quarter.
• My arr stack didn't care. This was the pleasant surprise — see below.

I'm not going to pretend Jellyfin is strictly better than Plex at everything. Plex's apps are more polished, its remote-access setup is more turnkey, and its metadata matching is arguably slicker out of the box. If you value convenience over control, Plex Pass is a reasonable buy. For me, control (and not having to pay to use my own hardware) won.

What I actually had to change

Here's the thing: most of my setup didn't change at all.

My media pipeline is the standard "arr" stack — Radarr and Sonarr grab films and shows, hand them to a download client, and write finished files to disk. None of that knows or cares which media server reads the files afterwards. Plex and Jellyfin are just different front ends pointing to the same folders.

So the migration was far narrower than "replace everything":

Two swaps. That's it. The download engine underneath stayed exactly where it was.

The steps, roughly

I won't do a line-by-line install guide here (Jellyfin's docs cover that well), but the shape of it:

1. Stand Jellyfin up alongside Plex. I run my media stack on CasaOS, so Jellyfin went in as a container — the official linuxserver/jellyfin image. The two settings that actually matter:

• User IDs (PUID/PGID) matching the file owner. My media lives on an SMB-mounted NAS share owned by a specific user. Jellyfin has to run as that user or it can't read the files. Get this wrong and you'll stare at an empty library wondering why.
• The GPU device (/dev/dri) passed into the container. This is what lets Jellyfin reach the iGPU. No device, no hardware transcoding — you'd silently fall back to CPU.

2. Point it at the same media folders Plex used. I mapped the identical paths — the NAS library plus a couple of local folders — so Jellyfin sees exactly what Plex saw. In the setup wizard, a Jellyfin "library" can point at multiple folders, so my NAS content and local recordings merge into one clean Movies (and one Shows) library.

3. Enable hardware transcoding and verify it. In Dashboard → Playback, set hardware acceleration to Intel QuickSync and give it the render node (/dev/dri/renderD128). Then — and this is the step people skip — prove it works: play something, force the quality down so it has to transcode, and check the dashboard. If the GPU's doing the job, the transcode runs at hundreds of frames per second and your CPU barely moves. If you see the CPU spike and the framerate crawl, it fell back to software, and something's misconfigured.

For me, it landed at ~450fps on the iGPU with CPU usage in the low teens, which is exactly what all the passthrough work was for.~450fps on the iGPU with CPU usage in the low teens — which is exactly what all the passthrough work was for.

4. Swap Overseerr for Seerr. This is the one arr-adjacent change. Overseerr — the "browse, search, request, and it downloads automatically" app — authenticates against Plex. Its successor Seerr (the merged Overseerr + Jellyseerr project as of early 2026) does the same job for Jellyfin.

A note if you go looking: Jellyseerr and Overseerr both merged into Seerr in 2026. If your app store still lists "Jellyseerr," it's the legacy project — install Seerr instead. It runs as a non-root user (UID 1000) and needs an init process (init: true), which caught a few people out post-rename.

Setup is quick: point Seerr at Jellyfin for sign-in, then at your existing Radarr and Sonarr (same URLs and API keys Overseerr used). One gotcha — you have to mark a Radarr and a Sonarr server as default, or requests connect but never actually process.

Result: the exact "search for a film, click request, it downloads and shows up" workflow I had with Plex + Overseerr — now running entirely on Jellyfin.

Was it worth it?

Yes. I get the one feature I actually wanted — GPU transcoding — for free, on hardware I already own. The stack is fully self-hosted and open source. And the migration affected far less than I expected, because the underlying download automation was never Plex's job in the first place.

If you're on the fence: check whether you're paying (or about to pay) Plex Pass purely to unlock hardware transcoding you've already got the silicon for. If that's you, Jellyfin is worth an evening.

Running a similar CasaOS + arr + NAS setup? The migration is genuinely a couple of container swaps. The two things to get exactly right are the file-owner user IDs and the GPU device passthrough — nail those and everything else falls into place.