Installation Guide

This guide provides comprehensive installation instructions for Jellyfin Server across different platforms and deployment scenarios.

For a quick start, see the Quickstart Guide. This guide covers production-ready installations.

Prerequisites

Before installing Jellyfin Server, ensure you have:

.NET 9.0 SDK - Required for building from source
FFmpeg - Required for media transcoding and processing
Minimum 2GB RAM - Recommended 4GB+ for larger libraries
Sufficient storage - For media, metadata, and transcoding cache

Installation Methods

Docker
Linux
Windows
macOS
From Source (Advanced)

Docker is the recommended method for most deployments.

Basic Docker Installation

Install Docker

curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh
sudo usermod -aG docker $USER

Pull Jellyfin Image

docker pull jellyfin/jellyfin:latest

For a specific version:

docker pull jellyfin/jellyfin:10.9.0

Create Directories

mkdir -p /opt/jellyfin/config
mkdir -p /opt/jellyfin/cache

Run Container

docker run -d \
  --name jellyfin \
  --user 1000:1000 \
  --net=host \
  --volume /opt/jellyfin/config:/config \
  --volume /opt/jellyfin/cache:/cache \
  --mount type=bind,source=/path/to/media,target=/media \
  --restart=unless-stopped \
  jellyfin/jellyfin:latest

Replace /path/to/media with your actual media directory path.

Docker Compose (Recommended)

Create a docker-compose.yml file:

docker-compose.yml

version: '3.8'

services:
  jellyfin:
    image: jellyfin/jellyfin:latest
    container_name: jellyfin
    user: 1000:1000
    network_mode: host
    volumes:
      - ./config:/config
      - ./cache:/cache
      - /path/to/media:/media
      - /path/to/media2:/media2:ro  # Optional, read-only
    restart: unless-stopped
    environment:
      - JELLYFIN_PublishedServerUrl=http://example.com
    # Optional: Hardware acceleration
    devices:
      - /dev/dri:/dev/dri  # For Intel QuickSync
      # - /dev/nvidia0:/dev/nvidia0  # For NVIDIA

Start the services:

docker-compose up -d

View logs:

docker-compose logs -f jellyfin

Hardware Acceleration with Docker

Intel QuickSync
NVIDIA GPU
AMD GPU

services:
  jellyfin:
    devices:
      - /dev/dri:/dev/dri
    group_add:
      - "109"  # render group ID

Install NVIDIA Container Toolkit first:

distribution=$(. /etc/os-release;echo $ID$VERSION_ID)
curl -s -L https://nvidia.github.io/nvidia-docker/gpgkey | sudo apt-key add -
curl -s -L https://nvidia.github.io/nvidia-docker/$distribution/nvidia-docker.list | \
  sudo tee /etc/apt/sources.list.d/nvidia-docker.list
sudo apt-get update && sudo apt-get install -y nvidia-container-toolkit
sudo systemctl restart docker

Then add to docker-compose.yml:

services:
  jellyfin:
    runtime: nvidia
    environment:
      - NVIDIA_VISIBLE_DEVICES=all

services:
  jellyfin:
    devices:
      - /dev/dri:/dev/dri
    group_add:
      - "109"  # render group ID

Installation instructions for various Linux distributions.

Ubuntu/Debian

Install Dependencies

sudo apt update
sudo apt install -y curl gnupg software-properties-common

Install .NET 9.0 SDK

wget https://dot.net/v1/dotnet-install.sh
chmod +x dotnet-install.sh
sudo ./dotnet-install.sh --channel 9.0 --install-dir /usr/share/dotnet

# Add to PATH
echo 'export PATH=$PATH:/usr/share/dotnet' >> ~/.bashrc
source ~/.bashrc

# Verify
dotnet --version

Install Jellyfin FFmpeg

Add Jellyfin repository for optimized FFmpeg:

sudo add-apt-repository universe -y
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

export VERSION_OS="$(awk -F'=' '/^ID=/{ print $NF }' /etc/os-release)"
export VERSION_CODENAME="$(awk -F'=' '/^VERSION_CODENAME=/{ print $NF }' /etc/os-release)"
export DPKG_ARCHITECTURE="$(dpkg --print-architecture)"

cat <<EOF | sudo tee /etc/apt/sources.list.d/jellyfin.sources
Types: deb
URIs: https://repo.jellyfin.org/${VERSION_OS}
Suites: ${VERSION_CODENAME}
Components: main
Architectures: ${DPKG_ARCHITECTURE}
Signed-By: /etc/apt/keyrings/jellyfin.gpg
EOF

sudo apt update
sudo apt install jellyfin-ffmpeg7 -y

Clone and Build Jellyfin

git clone https://github.com/jellyfin/jellyfin.git
cd jellyfin

# Build release version
dotnet build --configuration Release

# Create installation directory
sudo mkdir -p /opt/jellyfin
sudo cp -r Jellyfin.Server/bin/Release/net10.0/* /opt/jellyfin/

Create Systemd Service

Create /etc/systemd/system/jellyfin.service:

/etc/systemd/system/jellyfin.service

[Unit]
Description=Jellyfin Media Server
After=network.target

[Service]
Type=simple
User=jellyfin
Group=jellyfin
WorkingDirectory=/opt/jellyfin
ExecStart=/usr/share/dotnet/dotnet /opt/jellyfin/jellyfin.dll --datadir=/var/lib/jellyfin
Restart=on-failure
TimeoutSec=15

[Install]
WantedBy=multi-user.target

Create user and directories:

sudo useradd -r -s /bin/false jellyfin
sudo mkdir -p /var/lib/jellyfin
sudo chown -R jellyfin:jellyfin /var/lib/jellyfin
sudo chown -R jellyfin:jellyfin /opt/jellyfin

Enable and start:

sudo systemctl daemon-reload
sudo systemctl enable jellyfin
sudo systemctl start jellyfin

Fedora/CentOS/RHEL

# Install .NET
sudo dnf install dotnet-sdk-9.0

# Install FFmpeg from RPM Fusion
sudo dnf install https://download1.rpmfusion.org/free/fedora/rpmfusion-free-release-$(rpm -E %fedora).noarch.rpm
sudo dnf install ffmpeg

# Clone and build (same as Ubuntu steps above)
git clone https://github.com/jellyfin/jellyfin.git
cd jellyfin
dotnet build --configuration Release

Arch Linux

# Install dependencies
sudo pacman -S dotnet-sdk ffmpeg

# Or install from AUR
yay -S jellyfin-server-git

Installation on Windows systems.

Install .NET 9.0 SDK

Download and install from Microsoft:

# Using winget
winget install Microsoft.DotNet.SDK.9

# Or download installer from:
# https://dotnet.microsoft.com/download/dotnet/9.0

Verify installation:

dotnet --version

Install FFmpeg

Using Package Manager
Manual Installation

# Using Chocolatey
choco install ffmpeg

# Using Scoop
scoop install ffmpeg

Download FFmpeg from https://www.gyan.dev/ffmpeg/builds/
Extract to C:\ffmpeg
Add C:\ffmpeg\bin to System PATH
Verify:

ffmpeg -version

Clone Repository

git clone https://github.com/jellyfin/jellyfin.git
cd jellyfin

Build Jellyfin

# Build release version
dotnet build --configuration Release

# Navigate to build output
cd Jellyfin.Server\bin\Release\net10.0

Run Server

.\jellyfin.exe

Or install as Windows Service using NSSM:

# Download NSSM from https://nssm.cc/download
nssm install Jellyfin "C:\Path\To\jellyfin.exe"
nssm start Jellyfin

Running as Windows Service

Using NSSM (Non-Sucking Service Manager):

# Install NSSM
choco install nssm

# Install Jellyfin service
nssm install Jellyfin "C:\Program Files\Jellyfin\Server\jellyfin.exe"
nssm set Jellyfin AppDirectory "C:\Program Files\Jellyfin\Server"
nssm set Jellyfin AppParameters "--datadir C:\ProgramData\Jellyfin\Server"

# Start service
nssm start Jellyfin

Installation on macOS systems.

Install Homebrew

If not already installed:

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

Install Dependencies

# Install .NET SDK
brew install dotnet@9

# Install FFmpeg
brew install ffmpeg

# Verify installations
dotnet --version
ffmpeg -version

Clone and Build

git clone https://github.com/jellyfin/jellyfin.git
cd jellyfin

# Build
dotnet build --configuration Release

Run Server

cd Jellyfin.Server/bin/Release/net10.0
./jellyfin

Create Launch Daemon (Optional)

Create ~/Library/LaunchAgents/jellyfin.plist:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>Label</key>
    <string>jellyfin</string>
    <key>ProgramArguments</key>
    <array>
        <string>/usr/local/share/dotnet/dotnet</string>
        <string>/path/to/jellyfin/Jellyfin.Server/bin/Release/net10.0/jellyfin.dll</string>
    </array>
    <key>RunAtLoad</key>
    <true/>
    <key>KeepAlive</key>
    <true/>
</dict>
</plist>

Load the service:

launchctl load ~/Library/LaunchAgents/jellyfin.plist

Building from source for development or custom deployments.

Prerequisites

.NET 9.0 SDK
Git
FFmpeg
Node.js (optional, for web client)

Build Steps

Clone Repository

git clone https://github.com/jellyfin/jellyfin.git
cd jellyfin

Restore Dependencies

dotnet restore

Build Project

# Debug build
dotnet build

# Release build
dotnet build --configuration Release

Run from Build Output

cd Jellyfin.Server/bin/Release/net10.0
./jellyfin

Or run directly:

dotnet run --project Jellyfin.Server --configuration Release

Build with Web Client

Clone Web Client

git clone https://github.com/jellyfin/jellyfin-web.git
cd jellyfin-web

Build Web Client

npm ci
npm run build:production

Link to Server

# Copy web client dist to server wwwroot
cp -r dist ../jellyfin/Jellyfin.Server/bin/Release/net10.0/jellyfin-web

Or run server with web directory:

dotnet run --project Jellyfin.Server -- --webdir /path/to/jellyfin-web/dist

Development Build

For active development:

# Run with hot reload
dotnet watch --project Jellyfin.Server

# Run without web client (faster startup)
dotnet run --project Jellyfin.Server -- --nowebclient

# Run tests
dotnet test

# Run specific test project
dotnet test tests/Jellyfin.Api.Tests

Post-Installation Configuration

Directory Structure

Jellyfin creates the following directories:

Jellyfin Data Directory/
├── config/           # Configuration files
├── cache/            # Temporary cache files
├── data/             # Database and metadata
├── log/              # Log files
└── transcodes/       # Transcoding temporary files

Default Ports

Port	Protocol	Purpose
8096	HTTP	Web interface and API
8920	HTTPS	Secure web interface (if configured)
1900	UDP	Service discovery (DLNA)
7359	UDP	Client discovery

Firewall Configuration

Linux (ufw)
Linux (firewalld)
Windows

sudo ufw allow 8096/tcp
sudo ufw allow 8920/tcp
sudo ufw allow 1900/udp
sudo ufw allow 7359/udp

sudo firewall-cmd --permanent --add-port=8096/tcp
sudo firewall-cmd --permanent --add-port=8920/tcp
sudo firewall-cmd --permanent --add-port=1900/udp
sudo firewall-cmd --permanent --add-port=7359/udp
sudo firewall-cmd --reload

# Allow inbound on port 8096
New-NetFirewallRule -DisplayName "Jellyfin HTTP" -Direction Inbound -Protocol TCP -LocalPort 8096 -Action Allow
New-NetFirewallRule -DisplayName "Jellyfin HTTPS" -Direction Inbound -Protocol TCP -LocalPort 8920 -Action Allow

Verification

Verify your installation:

Check Service Status

sudo systemctl status jellyfin

Test API

curl http://localhost:8096/System/Info/Public

Expected response:

{
  "LocalAddress": "http://localhost:8096",
  "ServerName": "Jellyfin Server",
  "Version": "10.9.0",
  "ProductName": "Jellyfin Server",
  "OperatingSystem": "Linux",
  "StartupWizardCompleted": false
}

Access Web Interface

Open your browser:

http://localhost:8096

You should see the Jellyfin setup wizard.

Troubleshooting

Server won't start

Check logs:

# Linux
sudo journalctl -u jellyfin -n 100

# Docker
docker logs jellyfin

# Manual installation
cat /var/lib/jellyfin/log/log_*.txt

Permission errors

Ensure the Jellyfin user has access to media directories:

sudo usermod -aG your-media-group jellyfin
sudo chmod -R 755 /path/to/media

FFmpeg not found

Verify FFmpeg installation:

ffmpeg -version
which ffmpeg

If not found, install using platform-specific instructions above.

Port already in use

Change the listening port:

# Command line
./jellyfin --port 8097

# Environment variable
export JELLYFIN_PublishedServerUrl=http://localhost:8097

Database connection errors

Check database file permissions:

ls -la /var/lib/jellyfin/data/jellyfin.db
sudo chown jellyfin:jellyfin /var/lib/jellyfin/data/jellyfin.db

Upgrading

Docker

# Pull latest image
docker pull jellyfin/jellyfin:latest

# Stop and remove old container
docker stop jellyfin
docker rm jellyfin

# Start new container with same volumes
docker run -d \
  --name jellyfin \
  --volume /opt/jellyfin/config:/config \
  --volume /opt/jellyfin/cache:/cache \
  --mount type=bind,source=/path/to/media,target=/media \
  --restart=unless-stopped \
  jellyfin/jellyfin:latest

# Or with docker-compose
docker-compose pull
docker-compose up -d

From Source

cd jellyfin
git pull
dotnet build --configuration Release
sudo systemctl restart jellyfin

Always backup your configuration and database before upgrading!

Next Steps

Initial Setup

Complete the setup wizard

API Reference

Explore the REST API

Configuration

Configure Jellyfin settings

Plugins

Extend functionality with plugins

Getting Started

Core Concepts

Server Setup

Development

Installation Guide

Installation Guide

Prerequisites

Installation Methods

Basic Docker Installation

Docker Compose (Recommended)

Hardware Acceleration with Docker

Ubuntu/Debian

Fedora/CentOS/RHEL

Arch Linux

Running as Windows Service

Prerequisites

Build Steps

Build with Web Client

Development Build

Post-Installation Configuration

Directory Structure

Default Ports

Firewall Configuration

Verification

Check Service Status

Test API

Access Web Interface

Troubleshooting

Upgrading

Docker

From Source

Next Steps

Initial Setup

API Reference

Configuration

Plugins

Build docs developers (and LLMs) love

Getting Started

Core Concepts

Server Setup

Development

​Installation Guide

​Prerequisites

​Installation Methods

​Basic Docker Installation

​Docker Compose (Recommended)

​Hardware Acceleration with Docker

​Ubuntu/Debian

​Fedora/CentOS/RHEL

​Arch Linux

​Running as Windows Service

​Prerequisites

​Build Steps

​Build with Web Client

​Development Build

​Post-Installation Configuration

​Directory Structure

​Default Ports

​Firewall Configuration

​Verification

​Check Service Status

​Test API

​Access Web Interface

​Troubleshooting

​Upgrading

​Docker

​From Source

​Next Steps

Initial Setup

API Reference

Configuration

Plugins

Build docs developers (and LLMs) love

Installation Guide

Prerequisites

Installation Methods

Basic Docker Installation

Docker Compose (Recommended)

Hardware Acceleration with Docker

Ubuntu/Debian

Fedora/CentOS/RHEL

Arch Linux

Running as Windows Service

Prerequisites

Build Steps

Build with Web Client

Development Build

Post-Installation Configuration

Directory Structure

Default Ports

Firewall Configuration

Verification

Check Service Status

Test API

Access Web Interface

Troubleshooting

Upgrading

Docker

From Source

Next Steps