How to Install Jellyfin Media Server on Ubuntu

Jellyfin is a free media server for movies, TV, music, and photos. You install it on Ubuntu, point it at folders on disk, then play your library from browsers, phones, and TVs on your network.

On Ubuntu 26.04 and 24.04 LTS, Jellyfin publishes native APT packages for resolute and noble—the same workflow also works on 22.04 (jammy). After install you open http://SERVER-IP:8096, finish the setup wizard, and add libraries under paths Jellyfin can read (not necessarily own). Current stable releases use the 12.x version series; Jellyfin changed numbering in 2026 so the line after 10.11 became 12.x instead of 10.12.

Quick answer

Official Jellyfin APT install on supported Ubuntu LTS:

Download and verify Jellyfin’s installer script:

curl -fsSL https://repo.jellyfin.org/install-debuntu.sh -o install-debuntu.sh
curl -fsSL https://repo.jellyfin.org/install-debuntu.sh.sha256sum -o install-debuntu.sh.sha256sum
sha256sum -c install-debuntu.sh.sha256sum

Run the installer (it adds the signed APT repo and installs jellyfin):

sudo bash install-debuntu.sh

Confirm the service is running:

systemctl is-active jellyfin

active

From another machine on your LAN, open the setup wizard:

http://SERVER-IP:8096

Replace SERVER-IP with the server’s address (hostname -I | awk '{print $1}' on the host). Confirm the installed build with apt-cache policy jellyfin or dpkg-query -W jellyfin—do not hardcode a version number in your own notes; Jellyfin ships frequent updates.

Jellyfin support on Ubuntu 26.04, 24.04, and 22.04

Jellyfin’s install script recognizes these Ubuntu codenames today: focal, jammy, noble, and resolute (plus amd64, arm64, and armhf). For a normal home or small-office server on current LTS, use native APT—not Docker—as the default path.

Current Jellyfin version and the move from 10.11 to 12.x

Jellyfin 12.x is the current stable line (for example 12.2 on the lab host). The project skipped 10.12 and moved to 12.x in 2026 when it changed version numbering—so guides that still show 10.11.x repository examples are outdated, not “one major behind.”

Record what your host actually installed:

apt-cache policy jellyfin

jellyfin:
  Installed: 12.2+ubu2604
  Candidate: 12.2+ubu2604
  Version table:
 *** 12.2+ubu2604 500
        500 https://repo.jellyfin.org/ubuntu resolute/main amd64 Packages

List installed package versions:

dpkg-query -W jellyfin jellyfin-server

jellyfin	12.2+ubu2604
jellyfin-server	12.2+ubu2604

Your +ubu2404 or +ubu2604 suffix matches the Ubuntu suite Jellyfin built against.

Prerequisites

Before you install:

• A user with sudo for packages, systemctl, and optional UFW rules.
• Disk space for Jellyfin’s database and cache under /var/lib/jellyfin (a few gigabytes; libraries are separate).
• A stable path for media (see below)—not a desktop automount that disappears after logout.
• curl and gnupg for the official script or manual repo setup.

        Ubuntu server
              |
              v
   Official Jellyfin APT repo
              |
              v
      jellyfin.service
              |
              v
     http://SERVER-IP:8096
              |
              v
      First-run wizard
              |
              v
   Media folder permissions
              |
              v
   Movie / TV / Music library
              |
              v
      Clients on your LAN

Choose a stable media mount path

Prefer fixed server paths such as /srv/media or /mnt/media with an /etc/fstab entry for USB disks or NAS mounts. Avoid tying your library to /media/username/... on a desktop session—automounts can vanish after reboot or logout, and Jellyfin then sees an empty library.

Jellyfin’s application data (/var/lib/jellyfin, config under /etc/jellyfin) should stay on suitable local storage—the installer warns about NFS/Ceph for that directory and about COW filesystem quirks. Your movie and music files can live on a NAS mount as long as the mount is stable and the jellyfin user can traverse every parent directory and read the files.

Install Jellyfin on Ubuntu

Download and verify the official installer

Fetch the script and checksum file separately so you can verify before bash runs as root:

curl -fsSL https://repo.jellyfin.org/install-debuntu.sh -o install-debuntu.sh
curl -fsSL https://repo.jellyfin.org/install-debuntu.sh.sha256sum -o install-debuntu.sh.sha256sum
sha256sum -c install-debuntu.sh.sha256sum

A successful check prints install-debuntu.sh: OK. Avoid piping curl straight into sudo bash when you can verify the file first.

Run the Jellyfin installer

Run the verified script as root:

sudo bash install-debuntu.sh

The script detects your codename (resolute on 26.04, noble on 24.04), installs /etc/apt/keyrings/jellyfin.gpg, writes /etc/apt/sources.list.d/jellyfin.sources, and runs apt install jellyfin. On the lab host it pulled jellyfin-server, jellyfin-web, and jellyfin-ffmpeg8 as dependencies.

Verify the Jellyfin service

Enable and check the unit with systemctl:

sudo systemctl enable --now jellyfin
sudo systemctl status jellyfin --no-pager

Look for Active: active (running). A quick check:

systemctl is-active jellyfin

active

Optional: Add the Jellyfin APT repository manually

Use this when you want the same result as the script without running it—for example automation that already manages APT sources.

Set your release codename:

CODENAME="$(. /etc/os-release && echo "$VERSION_CODENAME")"
ARCH="$(dpkg --print-architecture)"

Install tooling for HTTPS repos (no apt-transport-https on current Ubuntu):

sudo apt update
sudo apt install curl gnupg ca-certificates

Import the signing key Jellyfin publishes today:

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
sudo chmod 644 /etc/apt/keyrings/jellyfin.gpg

Write the Deb822 source (architecture follows your CPU—amd64, arm64, or armhf):

sudo tee /etc/apt/sources.list.d/jellyfin.sources <<EOF
Types: deb
URIs: https://repo.jellyfin.org/ubuntu
Suites: ${CODENAME}
Components: main
Architectures: ${ARCH}
Signed-By: /etc/apt/keyrings/jellyfin.gpg
EOF

Remove a legacy one-line list file if an old guide left one behind:

sudo rm -f /etc/apt/sources.list.d/jellyfin.list

Refresh indexes and confirm a candidate before you install:

sudo apt update
apt-cache policy jellyfin

Install when the candidate comes from repo.jellyfin.org:

sudo apt install jellyfin

Package installs use the apt command with Jellyfin’s signed repository.

Access the Jellyfin web interface

On the server or another machine on the same LAN, open:

http://SERVER-IP:8096

Jellyfin listens on TCP 8096 by default. Optional 8920/tcp is for HTTPS when you configure it in the dashboard; most home LAN setups start with plain HTTP on the private network.

Complete the Jellyfin setup wizard

On first load, Jellyfin 12.x may show a brief loading screen (the Jellyfin logo on a dark background), then the server picker or Welcome to Jellyfin—choose your local server (or Add Server with http://SERVER-IP:8096) before the language and admin steps.

The wizard then walks through:

1. Preferred language.
2. Administrator username and password.
3. Media libraries—add at least one folder (for example /srv/media/movies with content type Movies).
4. Metadata language and remote-access preference (leave remote access off until you understand exposure).
5. Finish—land on the dashboard.

You can add libraries later under Administration → Dashboard → Libraries → Add Media Library. Match the content type (Movies, Shows, Music) to what is on disk; TV episodes expect season folders for best metadata matching.

Create the administrator account

Pick a strong password—this account controls libraries, users, and playback settings. You sign in with it after the wizard completes.

Add a media library

Choose Movies, Shows, or Music, then set the folder path Jellyfin should scan. The path must exist and be readable by the jellyfin service account before the scan finds files.

Give Jellyfin access to your media

Jellyfin needs traverse permission on every parent directory and read permission on media files. It does not need to own your entire library.

Grant read access without changing media ownership

Example library tree:

sudo mkdir -p /srv/media/{movies,tv,music}

Install ACL tools if setfacl is missing:

sudo apt install acl

Grant the jellyfin user read and directory traverse on the tree:

sudo setfacl -R -m u:jellyfin:rX /srv/media

Optional default ACL so new files under /srv/media stay readable (useful when another app writes into the tree):

sudo setfacl -R -d -m u:jellyfin:rX /srv/media

Do not run chmod -R 777 on a library. Do not chown -R jellyfin:… on large personal archives unless you have a deliberate ownership model—ACLs or a shared group are usually safer.

Verify access as the jellyfin user

Confirm the service account can list the library:

sudo -u jellyfin ls /srv/media/movies

If that fails, check every parent—Jellyfin cannot read /srv/media/movies/film.mkv when /srv or /srv/media blocks traverse:

namei -l /srv/media/movies

Fix permissions or ACLs on the first directory in the chain that denies jellyfin execute (x) for directories.

Access Jellyfin from other devices

Install clients from jellyfin.org/downloads or use a browser. Point phones and TVs at:

http://SERVER-IP:8096

Jellyfin documents 8096/tcp as the default HTTP port. Exposing that port directly to the public Internet is not recommended—use a VPN or reverse proxy with TLS when you need access outside the LAN. This guide stops at a working LAN server; it does not walk through Nginx or Let’s Encrypt.

Allow Jellyfin through UFW on your LAN

If UFW is active, allow the web UI from your home subnet—not the whole world:

sudo ufw allow from 192.168.1.0/24 to any port 8096 proto tcp

Replace 192.168.1.0/24 with your LAN CIDR. Confirm SSH stays allowed before you enable UFW (sudo ufw allow OpenSSH).

sudo ufw status

Optional client discovery

Some clients discover servers with UDP 7359 on the LAN. You do not need it to browse to http://SERVER-IP:8096. If you want auto-discovery on the private network only:

sudo ufw allow from 192.168.1.0/24 to any port 7359 proto udp

Do not forward 7359 or 8096 to the Internet without understanding the risk.

Optional: Configure hardware transcoding

Verify direct play works first. When the server must transcode, enable the acceleration path that matches your GPU (Intel QSV, VA-API, NVIDIA NVENC, and others) in Dashboard → Playback → Transcoding. The official Debian/Ubuntu package ships Jellyfin’s recommended FFmpeg build—follow Jellyfin’s hardware acceleration documentation for your hardware instead of pasting one-size-fits-all driver commands here.

Optional: Run Jellyfin with Docker

Use Docker when you already run containers or want app isolation. On 26.04 and 24.04, native APT is simpler—systemd and apt upgrade stay integrated.

docker run -d \
  --name jellyfin \
  --restart unless-stopped \
  --publish 8096:8096 \
  --volume /path/to/config:/config \
  --volume /path/to/cache:/cache \
  --volume /path/to/media:/media:ro \
  jellyfin/jellyfin:latest

Map /path/to/media to the same stable library you would use for an APT install. Hardware transcoding needs extra device flags—see Jellyfin’s container documentation.

Update Jellyfin

Update Jellyfin 12.x (minor releases)

Within the 12.x line, refresh indexes and upgrade like any APT package:

sudo apt update
sudo apt install --only-upgrade jellyfin

Restart if the packaging postinst did not already:

sudo systemctl restart jellyfin

Back up before a major Jellyfin upgrade

Moving from 10.11.x (or 10.10.7) to 12.x runs database migrations on first start. Jellyfin documents that rollback after migration requires restoring a backup—do not treat apt upgrade as reversible once migrations run.

Before a major jump:

sudo systemctl stop jellyfin
sudo cp -a /var/lib/jellyfin /path/to/backup/jellyfin-data
sudo cp -a /etc/jellyfin /path/to/backup/jellyfin-etc

Run sudo apt update and upgrade jellyfin, then start the service:

sudo systemctl start jellyfin

The first 12.x start can take several minutes while migrations run—watch journalctl -u jellyfin -f instead of assuming the service hung.

Uninstall Jellyfin

Remove the server packages

Stop the service, then purge the metapackage explicitly—no wildcard:

sudo systemctl stop jellyfin
sudo apt purge jellyfin

Preview orphaned dependencies before you autoremove:

sudo apt-get -s autoremove

Remove only packages you recognize as Jellyfin-related leftovers. Remove the repo if you will not reinstall:

sudo rm -f /etc/apt/sources.list.d/jellyfin.sources /etc/apt/keyrings/jellyfin.gpg
sudo apt update

Broader cleanup habits: how to remove software on Ubuntu.

Keep or remove Jellyfin server data

Purging packages does not delete:

• /var/lib/jellyfin — database, metadata, transcode cache
• /etc/jellyfin — configuration

Delete those directories only when you intend to wipe users, watch history, and libraries from this server. Your media files under /srv/media remain unless you remove them separately.

Docker: docker stop jellyfin && docker rm jellyfin, then delete mounted config/cache volumes when you no longer need them.

Troubleshooting

Summary

Install Jellyfin on Ubuntu 26.04 or 24.04 with Jellyfin’s official APT repository—the install script on repo.jellyfin.org is the fastest supported path. Verify with systemctl is-active jellyfin, open http://SERVER-IP:8096, and finish the wizard with real library paths.

Grant access with ACLs or group read permission instead of chown -R jellyfin on your media. Keep libraries on stable mount paths, open 8096/tcp to your LAN in UFW when needed, and back up /var/lib/jellyfin before jumping from 10.11.x to 12.x. Docker remains optional; native packages are the default on current LTS.

References

• Jellyfin — Linux installation
• Jellyfin — Networking
• Jellyfin — Hardware acceleration
• Jellyfin server downloads
• Jellyfin install script (debuntu)