How to Install Jellyfin Media Server on Ubuntu 24.04

Jellyfin turns any Ubuntu 24.04 VPS into a personal Netflix — movies, TV shows, music, audiobooks, and photos — streamed to every device in the house with zero monthly subscription and zero data leaving your server. It's the only major media server that is fully free, fully open source (GPLv2), and has no paywalled features. This guide walks you through a production-grade install: official apt repository, library setup, TMDB and TVDB metadata, VA-API hardware transcoding with jellyfin-ffmpeg, a properly tuned Nginx reverse proxy, TLS with Let's Encrypt, and mobile apps.

Want to skip the manual steps? Our one-click templates for popular stacks are available on the CloudCore VPS store. Jellyfin itself installs cleanly in under 25 minutes by following this guide.

Table of Contents

What is Jellyfin?

Jellyfin is a free, self-hosted media server that organizes and streams your personal library to any device. It's the GPL fork of Emby that was started in 2018 when Emby's core went closed-source, and it has since become the reference implementation for open-source media serving.

Jellyfin handles the full pipeline: it scans your video, music, audiobook, and photo directories; fetches rich metadata and artwork from public databases; exposes a web UI that looks and feels like a modern streaming service; transcodes on the fly when a client can't play a file natively; syncs watch progress across every device; and exposes clients for iOS, Android, Android TV, Apple TV, Roku, Fire TV, Samsung and LG smart TVs, Kodi, and any web browser.

Typical use cases include ripping your Blu-ray and DVD collection to a NAS or VPS and streaming it anywhere; running a household media hub so everyone has their own profile and watch state; replacing a cancelled Netflix or Disney+ subscription with a curated library; serving music as a private Spotify alternative with Finamp; sharing your library with family members over the internet; and running an archive of YouTube channels, lectures, or podcasts through the integrated DVR and tooling like yt-dlp.

The big technical wins are hardware transcoding — Jellyfin bundles its own jellyfin-ffmpeg build with full Intel Quick Sync, NVIDIA NVENC/NVDEC, AMD AMF, and VA-API support; Live TV and DVR through any compatible tuner (HDHomeRun, IPTV m3u); and a plugin system for adding features like TMDB box sets, sonarr/radarr integration, SSO, and intro skipping.

Why Self-Host Your Media Instead of Using Netflix or Plex?

Streaming subscriptions looked like a great deal in 2012. In 2026, between Netflix, Disney+, Prime Video, Max, Apple TV+, Paramount+, and the rest, a typical household pays EUR 80-120 per month for content that rotates in and out as licensing deals shift. The movie you want to re-watch tonight might be on a service you don't subscribe to, or might have left the platform entirely last month. Plex, historically the open answer, has spent the last few years pushing a paid Plex Pass, removing features from the free tier, forcing accounts through their cloud, and running ad-supported content you didn't ask for.

Jellyfin on your own VPS fixes all of that:

• You own the catalog. Files on disk don't get removed when a licensing deal expires. Your library doesn't shrink.
• No subscription, forever. Jellyfin is GPL-licensed with no paid tier. Hardware transcoding, remote access, sync, DVR, and all client apps are free.
• No third-party account. Jellyfin has no mandatory cloud login. User accounts live in your database on your server.
• No telemetry, no ads, no content injection. The server sends zero data home. You won't get interrupted by trailers for the company's original content.
• Predictable cost. A CloudCore Professional VPS is EUR 19.99/month flat — cheaper than a single streaming subscription and it runs every service you want on top.
• Quality, uncompressed. You control the encode. Keep the full 4K HDR remux if you want to; no adaptive bitrate is going to silently drop you to 720p during peak hours.
• Share with family. Create accounts for parents, partners, kids with proper parental controls, and they each get watch history, resume points, and device sync.
• One server, many services. The same VPS can run Sonarr, Radarr, and Nextcloud alongside Jellyfin — one bill, one backup target.

Recommended Plan: CloudCore Professional

Video transcoding is the single most CPU-hungry thing a home server does. A 4K HEVC file being converted to 1080p H.264 on software alone can eat six cores at 100%. The CloudCore Professional plan is sized for exactly this workload:

• 6 vCPU cores (enough for 2-3 simultaneous software transcodes, or 6+ hardware-accelerated)
• 12 GB RAM (plenty of headroom for metadata cache and parallel scans)
• 100 GB NVMe SSD (system + metadata + a starter library)
• Unmetered bandwidth (4K streams are ~25 Mbps each)
• EUR 19.99/month

Prerequisites

• A VPS running Ubuntu 24.04 LTS (codename noble) with root or sudo access
• At least 2 GB RAM, 4 GB recommended for transcoding headroom
• 20 GB free disk minimum (plus whatever your library needs)
• A domain name pointed at your server (required for proper TLS and mobile clients)
• An SSH client

ssh root@your-server-ip

Step 1: Update the System

Start clean with the latest packages:

sudo apt update && sudo apt upgrade -y

If the kernel was upgraded, reboot before continuing:

sudo reboot

Install the utilities needed for adding a third-party repo:

sudo apt install -y curl gnupg ca-certificates apt-transport-https lsb-release

Step 2: Add the Official Jellyfin APT Repository

Jellyfin publishes signed packages at repo.jellyfin.org. Do not install from apt directly — Ubuntu's own repository version lags significantly behind and is missing current transcoding fixes.

Create the keyrings directory and import the signing key:

sudo mkdir -p /etc/apt/keyrings
curl -fsSL https://repo.jellyfin.org/jellyfin_team.gpg.key \
  | sudo gpg --dearmor -o /etc/apt/keyrings/jellyfin.gpg

Add the repository for Ubuntu 24.04 (noble):

cat <<EOF | sudo tee /etc/apt/sources.list.d/jellyfin.sources
Types: deb
URIs: https://repo.jellyfin.org/ubuntu
Suites: noble
Components: main
Architectures: amd64
Signed-By: /etc/apt/keyrings/jellyfin.gpg
EOF

Refresh the package index:

sudo apt update

You should see Jellyfin's repo listed in the output with no GPG warnings.

Step 3: Install the Jellyfin Package

Install the server, web UI, and the bundled ffmpeg build in one go:

sudo apt install -y jellyfin

This pulls three packages:

• jellyfin-server — the actual media server daemon
• jellyfin-web — the browser UI bundle
• jellyfin-ffmpeg7 — a Jellyfin-patched ffmpeg build with the right codec and hardware acceleration support

sudo systemctl status jellyfin

Expected output:

● jellyfin.service - Jellyfin Media Server
     Loaded: loaded (/lib/systemd/system/jellyfin.service; enabled; preset: enabled)
     Active: active (running) since Thu 2026-04-16 10:00:00 UTC; 20s ago
   Main PID: 4321 (jellyfin)

Open firewall port 8096 temporarily so you can reach the setup wizard (we'll close it once Nginx is in place):

sudo ufw allow 8096/tcp

Step 4: Prepare the Media Directories

Jellyfin runs as the jellyfin system user. Create the library tree and hand ownership over:

sudo mkdir -p /media/movies /media/tv /media/music
sudo chown -R jellyfin:jellyfin /media
sudo chmod -R 755 /media

Transfer your first few files over SFTP, rsync, or rclone to test the scanner. Use Jellyfin's expected naming so metadata matches on the first try:

/media/movies/
  Interstellar (2014)/
    Interstellar (2014).mkv
  Dune Part Two (2024)/
    Dune Part Two (2024).mkv
/media/tv/
  Severance/
    Season 01/
      Severance - S01E01 - Good News About Hell.mkv
      Severance - S01E02 - Half Loop.mkv

Step 5: Run the First-Time Setup Wizard

Open http://your-server-ip:8096 in a browser. Jellyfin shows a multi-step wizard the first time it runs.

Page 1 — Language. Pick your UI language.

Page 2 — Admin user. Set a strong admin username and password. This is the only account that can reach the dashboard, so do not use admin / admin. Use a password manager.

Page 3 — Media libraries. Click Add Media Library.

For movies:

• Content type: Movies
• Display name: Movies
• Folder: /media/movies
• Metadata downloaders: TheMovieDb (TMDB)
• Image fetchers: TheMovieDb (TMDB)
• Preferred metadata language: your language
• Country: your country

• Content type: Shows
• Display name: TV
• Folder: /media/tv
• Metadata downloaders: TheTVDB, TheMovieDb
• Image fetchers: TheTVDB, TheMovieDb

Page 4 — Metadata language. Pick your display language and country.

Page 5 — Remote access. Leave Allow remote connections on (we'll front with Nginx and TLS) but uncheck Enable automatic port mapping (UPnP) — we're behind a reverse proxy.

Page 6 — Finish. Log in with the admin account.

Step 6: Configure Metadata Providers (TMDB and TVDB)

Go to Dashboard → Libraries → Movies → Manage library. Confirm TheMovieDb is checked for both Metadata downloaders and Image fetchers, and drag it to the top of the priority list.

Repeat for TV in the TV library, with TheTVDB first and TheMovieDb second. TVDB has more accurate episode splits for older shows; TMDB has better artwork for recent ones.

Back on the library page, click Scan Library. Watch the progress bar — a few hundred files typically take 2-5 minutes. If a movie didn't match, click its card, choose Identify, and pick the right entry.

Schedule nightly scans in Dashboard → Scheduled Tasks — the default "Scan all libraries" task at 2 AM works fine.

Step 7: Enable Hardware Transcoding (VA-API)

Software transcoding a 4K HEVC HDR file to 1080p H.264 SDR takes roughly 6 CPU cores at 100%. Hardware transcoding — offloading to the iGPU via VA-API — does the same job at about 5% CPU and with lower latency.

Most KVM-based VPS hosts, including CloudCore nodes on Intel Xeon processors, pass through a render node at /dev/dri/renderD128. Check:

ls -l /dev/dri

Expected output:

crw-rw---- 1 root render 226,   0 Apr 16 09:00 card0
crw-rw---- 1 root render 226, 128 Apr 16 09:00 renderD128

If you see renderD128, you have hardware acceleration available.

Give the jellyfin user access to the render group:

sudo usermod -aG render jellyfin
sudo usermod -aG video jellyfin

Install the VA-API runtime and drivers:

sudo apt install -y vainfo intel-media-va-driver-non-free i965-va-driver

Verify:

vainfo

You should see a list of supported profiles (H.264, HEVC Main/Main10, VP9, AV1 on 11th gen+ CPUs).

Restart Jellyfin so it picks up the new group membership:

sudo systemctl restart jellyfin

In the Jellyfin dashboard, go to Playback → Transcoding:

• Hardware acceleration: VA-API
• VA-API Device: /dev/dri/renderD128
• Enable the codecs your CPU supports: H.264, HEVC, VP9, AV1 (only if your CPU has the decoder)
• Enable hardware decoding for: check H.264, HEVC, VP9
• Enable hardware encoding: on
• Enable VPP Tone mapping: on (for HDR -> SDR mobile playback)

If ffmpeg path is wrong, point it explicitly at /usr/lib/jellyfin-ffmpeg/ffmpeg in Playback → FFmpeg path.

Step 8: Install Nginx as a Reverse Proxy

Direct exposure on port 8096 works but has no TLS, no HTTP/2, and uses Jellyfin's built-in Kestrel server which is not tuned for hostile internet traffic. Put it behind Nginx.

sudo apt install -y nginx

Create the site configuration (replace jellyfin.example.com with your domain):

sudo tee /etc/nginx/sites-available/jellyfin > /dev/null <<'EOF'
server {
    listen 80;
    listen [::]:80;
    server_name jellyfin.example.com;
    return 301 https://$host$request_uri;
}
server {
    listen 443 ssl http2;
    listen [::]:443 ssl http2;
    server_name jellyfin.example.com;
    # SSL certs filled in by certbot in the next step
    # ssl_certificate     /etc/letsencrypt/live/jellyfin.example.com/fullchain.pem;
    # ssl_certificate_key /etc/letsencrypt/live/jellyfin.example.com/privkey.pem;
    # Modern TLS
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers HIGH:!aNULL:!MD5;
    ssl_prefer_server_ciphers on;
    # Security headers
    add_header X-Content-Type-Options "nosniff" always;
    add_header X-Frame-Options "SAMEORIGIN" always;
    add_header Referrer-Policy "strict-origin-when-cross-origin" always;
    add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;
    # Large files — 4K remuxes can be tens of GB, and Jellyfin streams
    # uploads/metadata in chunks. 20 GB is a safe ceiling.
    client_max_body_size 20G;
    # --- Streaming buffer settings ---
    # Disable proxy buffering so Nginx streams video straight through
    # without trying to cache 50 GB files in /var/cache/nginx.
    proxy_buffering off;
    proxy_request_buffering off;
    # Long timeouts — sessions can sit idle during pause, direct-play
    # over cell networks, or slow seek operations on HEVC.
    proxy_read_timeout 86400s;
    proxy_send_timeout 86400s;
    send_timeout 86400s;
    # Allow large initial manifest responses
    proxy_buffer_size 8k;
    proxy_busy_buffers_size 16k;
    # WebSocket support (Jellyfin uses WS for sync, now-playing, chapters)
    location /socket {
        proxy_pass http://127.0.0.1:8096;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
    location / {
        proxy_pass http://127.0.0.1:8096;
        proxy_http_version 1.1;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_set_header X-Forwarded-Protocol $scheme;
        proxy_set_header X-Forwarded-Host $http_host;
        # Upgrade for Jellyfin's SSE streams too
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection $http_connection;
    }
}
EOF

Enable the site:

sudo ln -s /etc/nginx/sites-available/jellyfin /etc/nginx/sites-enabled/
sudo rm -f /etc/nginx/sites-enabled/default

Do not reload yet — certbot will fill in the cert paths for us.

Step 9: Obtain a TLS Certificate with Certbot

Make sure your DNS A/AAAA record for jellyfin.example.com already points at the server. Then:

sudo apt install -y certbot python3-certbot-nginx
sudo certbot --nginx -d jellyfin.example.com \
  --non-interactive --agree-tos --redirect \
  -m [email protected]

Certbot edits the Nginx block to uncomment the cert lines, reloads Nginx, and installs a systemd timer for auto-renewal. Verify renewal works:

sudo certbot renew --dry-run

Test the final URL:

curl -I https://jellyfin.example.com

You should see HTTP/2 200 and strict-transport-security in the headers.

Now that Nginx is proxying on 443, close the direct 8096 port:

sudo ufw delete allow 8096/tcp
sudo ufw allow 'Nginx Full'
sudo ufw --force enable

And bind Jellyfin itself to localhost only. Edit /etc/jellyfin/network.xml:

<LocalNetworkAddresses>
  <string>127.0.0.1</string>
</LocalNetworkAddresses>

Restart:

sudo systemctl restart jellyfin

Jellyfin is now reachable only through Nginx over TLS.

Step 10: Connect Mobile and TV Clients

Install the official Jellyfin client for each platform you use. All of them accept a custom server URL — this is why we went to the trouble of setting up a real domain with a valid cert.

iOS / iPadOS — App Store: Jellyfin Mobile. Some users prefer Swiftfin, a third-party native client with better 4K HDR handling.

Android / Android TV — Play Store: Jellyfin. On Android TV, install Jellyfin for Android TV specifically — it has a 10-foot UI and remote-friendly navigation.

Apple TV / tvOS — Swiftfin from the tvOS App Store is the production-grade option.

Samsung / LG smart TV — Jellyfin publishes a Tizen (Samsung) and webOS (LG) app directly from the TV's app store.

Roku / Fire TV — Install Jellyfin from the Roku Channel Store / Amazon Appstore.

Kodi — Install the Jellyfin for Kodi add-on; it syncs the library into Kodi's native UI.

Desktop — Any modern browser at https://jellyfin.example.com, or Jellyfin Media Player for proper MPV-based direct play of high-bitrate files.

Music — Finamp for iOS and Android is a polished Spotify-style music-only client that streams from Jellyfin.

In every app the connection flow is the same: enter https://jellyfin.example.com, sign in with the admin account or a user you created in Dashboard → Users, and you're streaming.

Next Steps: Automate Your Library

A media server is only as good as the content on disk. Pair Jellyfin with the *arr stack for hands-off library management:

• Sonarr — monitors your TV shows, grabs new episodes from your indexers as they air, renames them to the Jellyfin layout, and drops them in /media/tv. Jellyfin's auto-scanner picks them up within minutes.
• Radarr — the movie equivalent. Build a watchlist and it handles the rest.
• Prowlarr — a single indexer manager that feeds both Sonarr and Radarr so you don't configure indexers twice.
• Bazarr — automatic subtitles for everything in your library.
• Jellyseerr — a request UI for your users: they pick titles, Sonarr/Radarr handle the rest, and it notifies them when the content lands.

• Nextcloud — run a private cloud for file sync and calendar on the same VPS.
• Emby — the historical fork Jellyfin came from, if you want a paid-tier alternative with similar features.
• Jellyfin official docs: — the canonical reference for every setting, plugin, and advanced networking scenario.

FAQ

Is Jellyfin really 100% free?

Yes. Jellyfin is GPLv2 licensed, has no paid tier, no Jellyfin Pass, no locked features, and no telemetry. Hardware transcoding, remote access, DVR, sync, user accounts, parental controls, and every client app are free forever. The project is community-funded via OpenCollective and has no plans to change that model.

What VPS size do I actually need?

For one or two simultaneous direct-play streams of already-compatible files, a 2 vCPU / 4 GB VPS is enough. For hardware-transcoded 4K HDR to 1080p SDR for three to five users, you want the CloudCore Professional plan (6 vCPU / 12 GB RAM, EUR 19.99/month) because transcoding is the single most CPU-heavy task on a home server. If every client is on the same LAN and playing native files, you can get away with smaller; if you stream to cellphones over LTE, you'll transcode a lot and need the headroom.

Can Jellyfin actually do hardware transcoding on a VPS?

Yes, as long as the host exposes /dev/dri/renderD128 to the guest. Most KVM-based VPS providers including CloudCore do this automatically on Intel Xeon nodes, letting Jellyfin use VA-API (Quick Sync) for 4K H.264, HEVC, and AV1 decode and encode at a fraction of CPU cost. Check with ls -l /dev/dri — if the render node is there, you're set. On nodes without it, you fall back to software transcoding, which works but uses far more CPU.

Why does my stream buffer constantly through Nginx?

The default Nginx proxy settings are wrong for video. You must set proxy_buffering off and proxy_request_buffering off, raise client_max_body_size to something like 20G, and push proxy_read_timeout and proxy_send_timeout to 24 hours. The configuration in Step 8 of this guide has the full tuned block — copy it verbatim and buffering problems disappear.

How do I add movies and TV shows to the library?

Upload files to /media/movies and /media/tv via SFTP, rsync, or by mounting cloud storage with rclone. Use the recommended directory layout: /media/movies/Movie Name (Year)/Movie Name (Year).mkv and /media/tv/Show Name/Season 01/Show Name - S01E01.mkv. Jellyfin scans on a schedule and pulls metadata from TMDB and TVDB automatically. For fully hands-off automation, use Sonarr and Radarr.

Do I really need a domain name?

Not strictly — you can access the server at http://your-ip:8096 on your local network. But for remote playback on mobile data, for any iOS or tvOS client (which refuse self-signed certs), and for proper Let's Encrypt TLS, you need a real domain. A free subdomain from a dynamic DNS provider plus a Let's Encrypt cert takes ten minutes and removes every remote-access headache.

Should I use Jellyfin, Plex, or Emby?

Jellyfin if you want fully open-source, no subscription, no third-party account, and full control of your data. Plex if you're willing to pay the $120 lifetime Plex Pass for hardware transcoding, accept that Plex requires a cloud account, and want the more polished discovery UI. Emby is the historical fork Jellyfin came from — its core went closed-source in 2018 and it has a Premiere subscription for advanced features. For self-hosters who care about ownership and longevity, Jellyfin wins on principle, price, and momentum.

Ready to run your own media server? The CloudCore Professional VPS gives you 6 vCPU, 12 GB RAM, and 100 GB NVMe for EUR 19.99/month — enough for a busy household Jellyfin instance with hardware transcoding, Sonarr, Radarr, and plenty of room left over. Deploy in under a minute and follow this guide end-to-end.