Jellyfin vs Plex vs Emby: The Self-Hosted Media Server Showdown

At some point every homelab operator accumulates a media library — ripped Blu-rays, downloaded films, a decade of TV shows — and needs a way to actually watch it. Three projects dominate self-hosted media serving: Plex, the polished incumbent with a freemium model; Jellyfin, the fully open-source fork that costs nothing; and Emby, the middle ground that went commercial and split the community.

The right choice depends on your priorities. This guide covers each platform honestly: architecture, hardware transcoding setup (where most people get stuck), client support, metadata management, and the real cost of each option — so you can pick once and not regret it.

The Short Version

The Platforms

Jellyfin

Jellyfin is a community fork of Emby, created in 2018 when Emby moved to a proprietary license. It is genuinely open-source (GPL-2.0), has no telemetry, no account requirement, no cloud dependency, and no paid tier. Every feature works locally without any external service.

What it costs: Nothing. Ever.

What you give up: The client polish is behind Plex. Some edge cases (specific subtitle formats, unusual codecs) are handled better by Plex. The iOS app has historically lagged.

Plex

Plex is the most widely known media server. It runs a freemium model: the server is free, but many features — hardware transcoding, offline sync, live TV DVR, Plex Home for managed users, mobile sync, and some client features — require Plex Pass ($7/month, $40/year, or $120 lifetime).

What it costs: Free for basic use; Plex Pass for the full feature set.

What you get: The most polished UI across all clients, the most reliable remote access (through Plex’s relay servers), the best native app on most platforms, and a large install base meaning community answers to every problem.

Emby

Emby is where Jellyfin came from. It went proprietary in 2018 — the server core is still open but some features require Emby Premiere ($5/month or $80 lifetime). Hardware transcoding, parental controls, mobile sync, and server backup require Premiere.

What it costs: Free tier exists; Premiere for meaningful features.

What you get: A middle ground. More polished than Jellyfin in some areas, less expensive than Plex, but a smaller community and ecosystem than either.

Docker Compose Setup

Jellyfin

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

services:
  jellyfin:
    image: jellyfin/jellyfin:latest
    restart: unless-stopped
    user: "1000:1000"
    environment:
      - JELLYFIN_PublishedServerUrl=https://media.yourdomain.com
    volumes:
      - ./jellyfin/config:/config
      - ./jellyfin/cache:/cache
      - /mnt/nas/movies:/media/movies:ro
      - /mnt/nas/tv:/media/tv:ro
      - /mnt/nas/music:/media/music:ro
    ports:
      - "8096:8096"
    # For Intel Quick Sync hardware transcoding:
    devices:
      - /dev/dri:/dev/dri
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.jellyfin.rule=Host(`media.yourdomain.com`)"
      - "traefik.http.routers.jellyfin.entrypoints=websecure"
      - "traefik.http.routers.jellyfin.tls.certresolver=letsencrypt"

Plex

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

services:
  plex:
    image: lscr.io/linuxserver/plex:latest
    restart: unless-stopped
    network_mode: host   # Required for GDM discovery on local network
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=America/New_York
      - VERSION=docker
      - PLEX_CLAIM=${PLEX_CLAIM_TOKEN}   # From plex.tv/claim, expires in 4 minutes
    volumes:
      - ./plex/config:/config
      - /mnt/nas/movies:/movies:ro
      - /mnt/nas/tv:/tv:ro
      - /mnt/nas/music:/music:ro
      # Transcode directory on fast storage (SSD/tmpfs)
      - /tmp/plex-transcode:/transcode
    # For Intel Quick Sync:
    devices:
      - /dev/dri:/dev/dri

Emby

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

services:
  emby:
    image: emby/embyserver:latest
    restart: unless-stopped
    environment:
      - UID=1000
      - GID=1000
    volumes:
      - ./emby/config:/config
      - /mnt/nas/movies:/mnt/movies:ro
      - /mnt/nas/tv:/mnt/tv:ro
    ports:
      - "8096:8096"
      - "8920:8920"   # HTTPS
    devices:
      - /dev/dri:/dev/dri

Hardware Transcoding: The Critical Setup

Transcoding is the most common performance issue with media servers. When a client requests a format the server or client can’t play natively (wrong codec, wrong resolution, wrong bitrate), the server must convert the stream in real time. Software transcoding (CPU) can transcode one or two 1080p streams simultaneously on a decent CPU. Hardware transcoding uses the GPU’s dedicated video encode/decode blocks and can handle 10-20+ simultaneous streams on the same hardware.

Intel Quick Sync (Most Common for Homelab)

Intel Quick Sync is available on nearly every Intel CPU with integrated graphics from Sandy Bridge (2011) onward, and on Intel Arc discrete GPUs. It’s the most cost-effective hardware transcoding option.

Host Setup:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

# Install Intel media driver
apt install intel-media-va-driver-non-free vainfo

# Verify the GPU is accessible
vainfo
# Should list VAEntrypoint* for H.264, HEVC, AV1 (depending on generation)

# Check device permissions
ls -la /dev/dri/
# renderD128 must be readable by the media server user
# Add your user to the 'render' group:
usermod -aG render,video $USER

Generation capability reference:

Jellyfin config (Dashboard → Playback → Transcoding):

• Hardware acceleration: Intel QuickSync (QSV)
• Enable: H.264, HEVC, VP8, VP9, AV1 (check what your CPU supports)
• Enable Low-Power Encoder: Yes (uses less power, slightly lower quality)

Plex config (Settings → Transcoder):

• Requires Plex Pass
• Hardware-Accelerated Streaming: On
• Use hardware-accelerated video encoding: On

NVIDIA GPUs

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

# Install NVIDIA Container Toolkit
curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | gpg --dearmor \
  -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg
curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list \
  | sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' \
  > /etc/apt/sources.list.d/nvidia-container-toolkit.list

apt update && apt install nvidia-container-toolkit
nvidia-ctk runtime configure --runtime=docker
systemctl restart docker

1
2
3
4
5
6
7
8

# docker-compose.yml — Jellyfin with NVIDIA
services:
  jellyfin:
    image: jellyfin/jellyfin:latest
    runtime: nvidia
    environment:
      - NVIDIA_VISIBLE_DEVICES=all
      - NVIDIA_DRIVER_CAPABILITIES=all

NVENC session limits: Consumer NVIDIA GPUs (GeForce) have a firmware limit of 3-5 concurrent encode sessions. This limit does not exist on Quadro/RTX professional cards or when using the NVENC unlock patch. Plan accordingly — if you need more than 3-5 simultaneous transcodes, use Intel Quick Sync instead.

Jellyfin config: Hardware acceleration → NVENC. Enable HEVC encoding only if your card supports it (GTX 900+ series).

AMD GPUs

1
2
3
4

# Install AMDGPU driver and ROCm for media capabilities
apt install amdgpu-dkms
# Add user to video and render groups
usermod -aG video,render $USER

1
2
3
4
5
6
7
8

services:
  jellyfin:
    devices:
      - /dev/dri:/dev/dri
      - /dev/kfd:/dev/kfd   # For compute capabilities
    group_add:
      - "video"
      - "render"

AMD VAAPI support in Jellyfin: Dashboard → Playback → Transcoding → VAAPI. AMD hardware transcoding quality and compatibility is generally good on RDNA2+ cards but has historically been less consistent than Intel or NVIDIA.

Verifying Hardware Transcoding Is Working

Start a stream that requires transcoding (play a HEVC file on a client that only supports H.264, or force transcoding in the server settings). Then:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

# Jellyfin — check active sessions with hardware decode/encode
# Dashboard → Activity shows "Direct Play", "Direct Stream", or "Transcode (hw)"

# Check GPU usage during transcode
# Intel:
intel_gpu_top
# NVIDIA:
nvidia-smi dmon -s u
# AMD:
radeontop

If the GPU usage spikes during playback, hardware transcoding is working. If the CPU spikes and the GPU is idle, fall back to the transcoding settings and verify device permissions.

Direct Play vs Direct Stream vs Transcoding

Understanding these three modes prevents a lot of confusion:

Direct Play: The client plays the file exactly as stored. Zero server CPU/GPU usage. Requires the client to support the container format, video codec, audio codec, and subtitle format — all simultaneously.

Direct Stream: The server remuxes the video into a different container without re-encoding (e.g., MKV → MP4). Very low CPU usage. Used when the video codec is compatible but the container isn’t.

Transcoding: The server re-encodes the video (and/or audio) in real time. High CPU/GPU usage. Required when the codec itself isn’t supported by the client.

Goal: maximize direct play by choosing media in widely-compatible formats. H.264 video in an MKV or MP4 container with AAC audio directly plays on virtually every client and device.

The biggest transcoding trigger is HEVC (H.265) — it’s common in 4K content but not supported by older clients (Roku, Apple TV pre-2017, older smart TVs). If you rip your own media, encoding to H.264 at reasonable quality settings means more direct play at the cost of larger files.

Client Ecosystem Comparison

Jellyfin Clients

Jellyfin’s weakest client area is historically iOS/Apple TV, though Swiftfin has improved significantly. Game consoles have no native support.

Plex Clients

Plex has the broadest native client coverage of any media server. If you need to support a diverse range of devices — smart TVs, game consoles, Rokus — Plex wins by a meaningful margin.

Emby Clients

Coverage is roughly between Jellyfin and Plex. Official clients for Android, iOS, Android TV, Apple TV, Kodi, and Emby Theater for desktop. No PS4/PS5/Xbox native apps. Smart TV support is limited.

Metadata and Library Management

How Metadata Fetching Works

All three servers fetch metadata (posters, descriptions, ratings, cast, trailers) from external sources — primarily TheMovieDB (TMDb) for movies and TheTVDB/TheMovieDB for TV shows.

The fetch happens when you add media to your library. The server matches filenames against the metadata database, downloads artwork and info, and stores it alongside your files (or in an internal database).

File naming is critical. The servers use filename pattern matching:

# Movies — include the year
Movies/
  The Shawshank Redemption (1994)/
    The Shawshank Redemption (1994).mkv

# TV Shows — SxxExx format
TV/
  Breaking Bad/
    Season 01/
      Breaking Bad - S01E01 - Pilot.mkv
      Breaking Bad - S01E02 - Cat's in the Bag.mkv

A misnamed file (breaking.bad.s01e01.mkv in a flat folder) will confuse all three servers equally.

Metadata Agents

All three support plugins/agents that change where metadata is fetched from:

• TMDb: Best for movies. International title coverage, high-quality artwork.
• TheTVDB: Traditional TV show source. Long history, comprehensive.
• TMDb for TV: Growing in quality, better for newer shows and streaming originals.
• MusicBrainz: For music libraries — all three support it.
• Custom agents: For anime, Jellyfin has an AniDB/AniList agent; Plex has the HAMA agent for anime metadata.

Artwork Management

All three servers store downloaded artwork. Jellyfin and Emby also support local artwork — placing image files next to your media:

Movies/
  Inception (2010)/
    Inception (2010).mkv
    poster.jpg        ← Used as movie poster
    fanart.jpg        ← Used as background
    backdrop.jpg      ← Alternative background
    logo.png          ← Clear logo overlay
    theme.mp3         ← Background music (Emby/Jellyfin)

Local artwork is read at scan time and takes priority over fetched artwork. This is useful when the metadata agent fetches the wrong poster or you want custom artwork.

Library Organization Options

Separate libraries (recommended):

• Movies library → /mnt/nas/movies
• TV Shows library → /mnt/nas/tv
• Home Videos library → /mnt/nas/home
• Music library → /mnt/nas/music

Collections: Group related movies (all MCU films, all Alien films) regardless of directory structure. All three servers support collections, though the UX varies.

Playlists: User-created ordered lists of content. All three support these well.

Features Comparison

Core Features (All Free)

Premium Features

Hardware transcoding being free in Jellyfin is significant — for Plex, hardware transcoding is the primary reason to buy Plex Pass.

Remote Access

Plex: The most reliable remote access. Plex routes traffic through its own relay servers when direct connection fails (you’re behind CGNAT, port forwarding isn’t set up). This “just works” for most users but means your media traffic flows through Plex’s infrastructure.

Jellyfin: No built-in relay. Remote access requires either port forwarding (80/443 → server), a VPN (Tailscale, WireGuard), or a Cloudflare Tunnel. More setup but zero third-party involvement.

Emby: Similar to Jellyfin — direct connection required, no relay service.

Live TV and DVR

All three support HDHomeRun tuners and similar OTA TV tuners, plus IPTV via M3U playlists. Plex’s Live TV/DVR is the most polished. Jellyfin’s is functional but less refined. Both are free in Jellyfin, paywalled in Plex/Emby.

Music Libraries

Jellyfin for Music

Jellyfin has a reasonably good music library with MusicBrainz metadata, but the music playback UX in the web UI lags behind dedicated music players. The Finamp iOS/Android app is a dedicated Jellyfin music client that handles offline sync and background playback well.

Plex for Music

Plex’s music library uses Gracenote (Sonic) metadata — high quality for mainstream music but weaker for classical, jazz, and world music. Plex Amp (mobile app) is a well-designed music player. PlexAmp for Sonos integrates nicely for whole-home audio.

Subsonic API Compatibility

Jellyfin and Emby both implement the Subsonic API, which means any app designed for Subsonic/Airsonic/Navidrome (DSub, Ultrasonic, Symfonium, Plexamp alternatives) also works with Jellyfin and Emby. This dramatically expands the music client ecosystem.

Performance and Scalability

Server Hardware Requirements

For 4K HDR content with tone mapping (converting HDR to SDR for clients that don’t support HDR), the demands are higher. Intel 11th Gen+ and NVIDIA Turing+ (GTX 1650+) handle this well. A Raspberry Pi 4 will not.

Transcode Directory

Place the transcode directory on the fastest storage available:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

# Use RAM disk for transcoding (transcodes are ephemeral)
volumes:
  - type: tmpfs
    target: /transcode
    tmpfs:
      size: 4294967296  # 4GB limit

# Or use SSD (more stable for high-bitrate 4K):
volumes:
  - /tmp/jellyfin-transcode:/transcode

Avoid putting the transcode directory on a spinning HDD or network storage (NFS/SMB) — it will bottleneck performance significantly.

The Privacy Question

This is where Jellyfin wins unconditionally.

Plex requires a plex.tv account to operate the server. All authentication goes through Plex’s servers even for local playback (the server must phone home to verify your account). Plex collects usage data — what you watch, when, from where. You can minimize this but not eliminate it.

Emby similarly requires an account, though it’s optional to a greater degree. Telemetry exists but is configurable.

Jellyfin has zero telemetry by default, requires no account, and can operate fully air-gapped with no internet access. All authentication is local. Metadata can be fetched from external sources (TMDb) but this is optional — you can pre-populate metadata locally and disable all external lookups.

For a homelab where privacy matters, Jellyfin is the clear choice.

Recommendations

Choose Jellyfin if:

• You want zero ongoing cost and full control
• Privacy is important (no cloud accounts, no telemetry)
• You’re willing to configure remote access yourself (Tailscale, Cloudflare Tunnel)
• Your clients are mainstream (browser, Android, Apple TV via Swiftfin, Kodi)
• You run an air-gapped or strictly controlled network

Choose Plex Pass if:

• You’re sharing with non-technical family who need reliable “just works” remote access
• You have a diverse device ecosystem including game consoles and smart TVs
• The $40/year is acceptable for the polish and reliability it provides
• You want the best DVR/Live TV experience

Choose Emby Premiere if:

• You like a middle-ground UI
• You want something between Plex’s cost and Jellyfin’s DIY requirements
• Lifetime Premiere at $80 appeals vs Plex’s ongoing subscription

The pragmatic homelab answer: Start with Jellyfin. It’s free, capable, and improving rapidly. If you hit a specific limitation — a device with no Jellyfin client, remote access too complex for your use case, a feature you genuinely need that’s paywalled — then evaluate Plex Pass for that specific gap. Many people who started with Plex years ago have migrated to Jellyfin and never looked back.