Quickstart Guide

Get a Jellyfin server up and running in minutes

Quickstart Guide

This guide will help you get Jellyfin Server running quickly for development or testing. For production deployments, see the Installation guide.

This quickstart assumes you have basic familiarity with the command line and either .NET development or Docker.

Choose Your Method

Docker (Fastest)

The quickest way to get Jellyfin running is with Docker.

1. Pull the Jellyfin image

   docker pull jellyfin/jellyfin:latest
   
2. Run the container

   docker run -d \
     --name jellyfin \
     -p 8096:8096 \
     -v /path/to/config:/config \
     -v /path/to/cache:/cache \
     -v /path/to/media:/media \
     --restart unless-stopped \
     jellyfin/jellyfin:latest
   

   Replace /path/to/config, /path/to/cache, and /path/to/media with actual paths on your system.

3. Access the web interface

   Open your browser and navigate to:

   http://localhost:8096
   

   You’ll be greeted with the Jellyfin setup wizard.

Docker Compose

For a more permanent setup, create a docker-compose.yml:

docker-compose.yml

version: '3.8'
services:
  jellyfin:
    image: jellyfin/jellyfin:latest
    container_name: jellyfin
    network_mode: host
    volumes:
      - ./config:/config
      - ./cache:/cache
      - /path/to/media:/media
    restart: unless-stopped
    environment:
      - JELLYFIN_PublishedServerUrl=http://localhost:8096

Then run:

docker-compose up -d

From Source (.NET)

Run Jellyfin Server directly from source for development.

1. Install Prerequisites

   Install the .NET 9.0 SDK:

   Linux (Ubuntu/Debian)

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

   Verify installation:

   dotnet --version
   # Should output: 9.0.x
   
2. Clone the Repository

   git clone https://github.com/jellyfin/jellyfin.git
   cd jellyfin
   
3. Install FFmpeg

   Jellyfin requires FFmpeg for media processing.

   Linux (Ubuntu/Debian)

   Add the Jellyfin repository for optimized FFmpeg:

   sudo apt install curl gnupg software-properties-common -y
   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
   

   macOS

   brew install ffmpeg
   

   Windows

   Download FFmpeg from https://www.gyan.dev/ffmpeg/builds/ and add to PATH.

4. Run the Server

   Start the server directly with dotnet run:

   cd jellyfin
   dotnet run --project Jellyfin.Server
   

   First run will download dependencies and may take a few minutes.

   You should see output like:

   Jellyfin version: 10.9.0
   Operating system: Linux
   Architecture: X64
   Now listening on: http://0.0.0.0:8096
   
5. Access the Server

   Open your browser to:

   http://localhost:8096
   

Development Tips

Running without web client: For API-only development, use:

dotnet run --project Jellyfin.Server -- --nowebclient

Building for Release:

dotnet build --configuration Release
cd Jellyfin.Server/bin/Release/net10.0
./jellyfin

Running Tests:

dotnet test

Visual Studio / VS Code

For development with an IDE.

1. Install Prerequisites

   • .NET 9.0 SDK
   • Visual Studio 2022+ or VS Code
   • FFmpeg (see installation in “From Source” tab)
2. Clone and Open Project

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

   Visual Studio: Open Jellyfin.sln

   VS Code:

   code .
   

   Install recommended extensions when prompted.

3. Run from IDE

   Visual Studio:

   • Select Jellyfin.Server as startup project
   • Press F5 to run

   VS Code:

   • Press F5 or use “Run and Debug” panel
   • Select .NET Core Launch configuration
4. Access the Server

   The server will start on http://localhost:8096

Initial Setup Wizard

When you first access Jellyfin, you’ll be guided through a setup wizard:

1. Select Language

   Choose your preferred language for the interface.

2. Create Admin Account

   Set up the administrator account:

   • Username
   • Password (optional but recommended)

   The first user created has full administrator privileges. Use a strong password for production deployments.

3. Configure Media Libraries

   Add your media folders:

   • Click “Add Media Library”
   • Select content type (Movies, TV Shows, Music, etc.)
   • Browse to your media folder
   • Click “OK”

   You can skip this step and add libraries later from the Dashboard.

4. Set Metadata Language

   Choose preferred language for metadata and artwork downloads.

5. Configure Remote Access (Optional)

   Configure if you want to access Jellyfin from outside your network.

6. Complete Setup

   Click “Finish” to complete the wizard and start using Jellyfin!

Verify Installation

Check that everything is working correctly:

Check System Info

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

Expected response:

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

Access API Documentation

Visit the interactive API docs:

http://localhost:8096/api-docs/swagger/index.html

Test API Endpoint

curl -X GET "http://localhost:8096/System/Ping"

Response:

"Jellyfin Server"

Common Issues

Port 8096 already in use

Change the port by setting an environment variable:

export JELLYFIN_PublishedServerUrl=http://localhost:8097
dotnet run --project Jellyfin.Server -- --port 8097

FFmpeg not found

Ensure FFmpeg is installed and in your PATH:

ffmpeg -version

If not found, install using the instructions in the “From Source” tab above.

.NET SDK not found

Verify .NET installation:

dotnet --version

If not found, install from https://dotnet.microsoft.com/download/dotnet/9.0

Database errors on first run

Jellyfin automatically creates its database on first run. If you see database errors:

1. Stop the server
2. Delete the config directory
3. Restart and run setup wizard again

Next Steps

Detailed Installation

Platform-specific installation guides

API Reference

Explore the REST API documentation

Configuration

Configure Jellyfin for your needs

Development

Contributing and development guides

Development Resources

Project Structure

jellyfin/
├── Jellyfin.Server/          # Main server entry point
├── Jellyfin.Api/             # REST API controllers
├── MediaBrowser.Controller/  # Core business logic
├── Emby.Server.Implementations/
├── tests/                    # Unit and integration tests
└── deployment/              # Deployment configurations

Key Files

• Jellyfin.Server/Program.cs - Application entry point
• Jellyfin.Server/Startup.cs - ASP.NET Core configuration
• Jellyfin.Server/Jellyfin.Server.csproj - Project configuration
• Jellyfin.Api/Controllers/ - API endpoint implementations

Running Tests

# Run all tests
dotnet test

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

# Run with coverage
dotnet test --collect:"XPlat Code Coverage"

For active development, consider running the server with --nowebclient and hosting the web client separately for faster iteration.