Plex Pass Hits $749. Time for Jellyfin.

Plex just announced that the Lifetime Plex Pass is going from $250 to $749, effective July 1, 2026. That’s not a typo. Seven hundred and forty-nine dollars — enough to buy a used Steam Deck, a solid N100 mini PC, or (per The Verge’s math) 11 years of the annual plan you’d be trying to escape. (Monthly and annual prices aren’t changing in this round; those got their own hike last year when Plex moved remote streaming behind the paywall.)

This isn’t the “why Jellyfin is good” article. That one already exists: Jellyfin vs Plex: The Honest Comparison. Go read it if you need convincing. This article is the migration plan for people who’ve already decided, plus a decision tree for people still on the fence.

What Actually Changed

Per The Verge and Ars Technica: Lifetime Plex Pass goes from $250 to $749 on July 1, 2026. Lifetime was $120 for years, jumped to $250 in March 2025, and now triples to $749 — that’s a 6x increase in 15 months. Monthly and annual subscriptions aren’t changing in this round; those already jumped last year when Plex gated remote streaming behind a paywall. Plex has confirmed that existing Plex Pass holders are grandfathered in — you keep what you paid for, nothing changes for you right now.

“For now” is doing a lot of work in that last sentence. The r/selfhosted thread is exactly what you’d expect: a mix of people who bought lifetime years ago feeling smug, people mid-renewal calculating the math, and people just starting to look at Jellyfin for the first time.

Why This Is the Breaking Point

Here’s the thing about Plex: the frog has been boiling for years. Hardware transcoding? Plex Pass. Mobile sync? Plex Pass. The companion app for managing your server? Plex Pass. Reliable remote access without jumping through hoops? Increasingly, Plex Pass.

Every feature that made Plex genuinely better than the alternatives got quietly moved behind the paywall. Individually, each move was defensible. Collectively, they turned a media server into a subscription-gated service that happens to run on your own hardware. The $749 price tag didn’t change the direction — it just made the destination obvious enough that nobody can pretend otherwise.

Should You Grandfather In or Jump Ship?

Five scenarios. Pick yours.

1. No Plex Pass, casual user — Jellyfin. Don’t panic-buy a $250 ticket onto a platform that just showed you exactly where it’s headed.

2. Big family already trained on Plex (5+ users, multiple devices, everyone has opinions) — if retraining the whole household genuinely sounds worse than $250 right now, buying before July 1 buys you a few years of stability while you migrate slowly. Treat it as a runway, not a destination.

3. Solo or couple on a monthly Plex Pass plan — cancel today. Migrate this weekend. You’re paying rent on a house you own.

4. Already own Plex Pass lifetime — no action required. You’re grandfathered, the price hike doesn’t touch you. Use it until it annoys you, then migrate at your own pace.

5. On annual, renewal coming up — ride out the current term. When it comes up for renewal, you’ll have had time to evaluate Jellyfin properly. Don’t rush a migration at renewal panic.

The Migration Plan

You don’t need to move a single media file. Jellyfin reads the same directories Plex does. Both servers can run simultaneously pointing at the same library. This is a zero-downtime migration if you do it right.

Step 1: Inventory Your Libraries

Open your Plex settings and note the paths to each library — Movies, TV Shows, Music, whatever you have. Write them down. These exact paths get mounted into your Jellyfin container. The media doesn’t move, the files don’t get renamed, nothing changes on disk.

Common setups:

• /mnt/media/movies
• /mnt/media/tv
• /mnt/media/music

If your files are scattered across multiple drives or mount points, note all of them. You’ll map each one into the container.

Step 2: Deploy Jellyfin in Docker

Full example: Clone the working files at github.com/KingPin/sumguy-examples/tree/main/self-hosting/plex-to-jellyfin/

Here’s the compose file. Drop it in a fresh directory, adjust your media paths, and run docker compose up -d.

services:
  jellyfin:
    image: jellyfin/jellyfin:latest
    container_name: jellyfin
    user: 1000:1000
    network_mode: host
    volumes:
      - ./config:/config
      - ./cache:/cache
      - /mnt/media:/media:ro
    devices:
      - /dev/dri:/dev/dri
    environment:
      - JELLYFIN_PublishedServerUrl=http://192.168.1.100:8096
    restart: unless-stopped

A few notes: user: 1000:1000 runs Jellyfin as your regular user — avoids the classic permissions nightmare where the container can’t read your files. The /mnt/media:/media:ro mount is read-only, which is exactly what you want for a media server. network_mode: host makes DLNA discovery work cleanly; if you prefer a bridge network, just map port 8096 instead. Update JELLYFIN_PublishedServerUrl to your server’s actual LAN IP.

Hit http://192.168.1.100:8096 in a browser, run through the first-time setup wizard, add your libraries using the /media path. Jellyfin will scan and build its own metadata database from scratch — this takes a while for large libraries, grab a coffee.

Step 3: Hardware Transcoding (The Feature Plex Paywalled)

This is the one that stings. Hardware transcoding in Plex requires Plex Pass. In Jellyfin, it’s free. Here are your three options:

• Intel Quick Sync (QSV/VAAPI) — best price-to-performance ratio for home lab use. Works on any Intel iGPU from roughly 2015 onward, which means your N100 or N305 mini PC is already capable. The /dev/dri:/dev/dri device passthrough in the compose file covers this.
• NVIDIA NVENC — if you have a consumer GPU, check out the keylase/nvidia-patch on GitHub which removes the arbitrary stream limit on consumer cards. You’ll also need the nvidia runtime configured in Docker.
• AMD VAAPI — functional, historically less polished than Intel, but it works.

Verify the device is visible inside the container before configuring anything:

# Intel/AMD
docker exec -it jellyfin vainfo

# NVIDIA
docker exec -it jellyfin nvidia-smi

Then in the Jellyfin admin UI: Dashboard → Playback → Transcoding — select your hardware acceleration method and save. Check the active streams view while something is playing to confirm it shows (hw) next to the transcoder.

Step 4: Remote Access (Without Plex’s Relay)

Jellyfin has no relay server. This means you own the whole path, which is the point, but you do need to set it up.

Three options, ranked by how much you’ll regret your choice at 11 PM when something doesn’t work:

1. Tailscale or Headscale (best) — install the Tailscale client on every device you want to reach your server from. Hit your server’s tailnet IP. No port forwarding, end-to-end encrypted, works from anywhere. If you want to keep it fully self-hosted, Headscale: Self-Hosted Tailscale is exactly what you need.

2. Reverse proxy with a real domain — Caddy or Nginx Proxy Manager fronting Jellyfin handles HTTPS and lets people on devices that can’t run Tailscale (some smart TVs, random hotel browser) connect anyway. More moving parts, but more flexibility. Caddy makes this less painful than it used to be.

3. Raw port-forward on 8096 — don’t. You’re exposing your media server to the internet with no TLS. Your 2 AM self will hate your 2 PM self for this decision.

Step 5: Pick Clients That Don’t Suck

The honest breakdown by platform:

• Web browser — the built-in Jellyfin web UI works fine. Most smart TVs with a browser can hit it directly.
• Android phone/tablet — the official Jellyfin app is solid. Streamyfin or Findroid if you want something that feels more polished.
• Android TV / Google TV / NVIDIA Shield — official Jellyfin app or Findroid. Both work well.
• Apple TV / iOS / iPad — the official Jellyfin app exists. Infuse (~$15/year) is honestly better than Plex on Apple hardware and worth the money if this is your primary viewing device.
• Smart TVs (LG webOS, Samsung Tizen) — official Jellyfin apps on both. Quality varies by model. If your TV isn’t supported, a $50 Fire TV Stick running Findroid solves it permanently.
• Roku — there’s an official Jellyfin Roku channel now. This was the biggest gap for years and it’s finally filled.

One more: if you used Overseerr for media requests and discovery, you want Jellyseerr — the Jellyfin-compatible fork. Drop-in replacement, same interface your users already know.

Step 6: Watch History Migration (The Honest Bit)

Plex doesn’t make this easy. They never did. Here’s what you can do:

1. Accept the reset — genuinely the most pragmatic option. After a week of watching things in Jellyfin, you’ll have new watch history anyway. The “I already watched that” problem is solved by your own memory for anything you care about.

2. Community scripts — tools like jellyfin-plex-watched and similar exist on GitHub. They use the Plex API to export watched status and the Jellyfin API to import it. Search GitHub for the current best-maintained version; this ecosystem moves fast and specific tools go stale. Verify it’s been updated in the last six months before trusting it.

3. Manual marking — if there’s a specific show or series you absolutely cannot lose the progress on, Jellyfin lets you mark individual episodes or entire seasons as watched in about 30 seconds. For a handful of shows, this beats running untested scripts against your database.

This is the friction point. Set the expectation with yourself and your household before starting: watch history probably doesn’t make it cleanly. Plan accordingly.

Step 7: Run Both for 1-2 Weeks, Then Sunset Plex

Don’t rip and replace. Let them overlap.

Week 1: Both servers running on the same read-only media. Use Jellyfin daily. Fall back to Plex if something breaks or a client doesn’t work as expected yet.

Week 2: Switch other household members over. Keep Plex running but stop pointing new media at it. If anyone has complaints, you still have a fallback.

After that: Stop the Plex container. If nobody says anything for two weeks, remove it and reclaim the RAM. Keep a backup of the Plex database directory just in case — it’s not large and you’ll sleep better knowing it’s there.

You can also run both indefinitely. They don’t conflict on the same media files since the mounts are read-only and Jellyfin maintains its own separate metadata database. Some households keep Plex for one stubborn family member while everyone else moves over. Inelegant, but it works.

”But What About Emby?”

Half a paragraph because that’s all it deserves. Emby went commercial in 2018. Jellyfin is literally the community fork that was created specifically because of that move. Emby has a subscription model, smaller ecosystem, and less community momentum. If you’re already leaving Plex because you’re done paying for a server you host yourself, Emby is just Plex with fewer features. Skip it.

Plex Did You a Favor

The whole premise of self-hosting your media was to stop paying rent on your own library. You own the hardware. You own the files. You own the bandwidth. Plex spent fifteen years building the gold standard in media server UX, then spent another five quietly turning it into a SaaS product that runs on your hardware but gates its best features behind a subscription.

The $749 sticker didn’t change the direction. It just made it legible.

One more thing: if you used Plex Meta Manager to manage posters, collections, and overlays — it works with Jellyfin too via the Kometa fork. The Plex Meta Manager: Posters, Collections, Sanity article covers the setup, and the migration path to the Jellyfin backend is documented in the Kometa repo.

Used Steam Deck is $249. A decent N100 mini PC is around $150. Both run Jellyfin beautifully. Neither costs $749. Sometimes the market does you a favor by making the decision obvious.