> ## Documentation Index
> Fetch the complete documentation index at: https://mintlify.com/jellyfin/jellyfin/llms.txt
> Use this file to discover all available pages before exploring further.

# 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](/installation) guide.

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

## Choose Your Method

<Tabs>
  <Tab title="Docker (Fastest)">
    The quickest way to get Jellyfin running is with Docker.

    <Steps>
      <Step title="Pull the Jellyfin image">
        ```bash theme={null}
        docker pull jellyfin/jellyfin:latest
        ```
      </Step>

      <Step title="Run the container">
        ```bash theme={null}
        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
        ```

        <Note>
          Replace `/path/to/config`, `/path/to/cache`, and `/path/to/media` with actual paths on your system.
        </Note>
      </Step>

      <Step title="Access the web interface">
        Open your browser and navigate to:

        ```
        http://localhost:8096
        ```

        You'll be greeted with the Jellyfin setup wizard.
      </Step>
    </Steps>

    ### Docker Compose

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

    ```yaml docker-compose.yml theme={null}
    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:

    ```bash theme={null}
    docker-compose up -d
    ```
  </Tab>

  <Tab title="From Source (.NET)">
    Run Jellyfin Server directly from source for development.

    <Steps>
      <Step title="Install Prerequisites">
        Install the .NET 9.0 SDK:

        <CodeGroup>
          ```bash Linux (Ubuntu/Debian) theme={null}
          wget https://dot.net/v1/dotnet-install.sh
          chmod +x dotnet-install.sh
          ./dotnet-install.sh --channel 9.0
          ```

          ```bash macOS theme={null}
          brew install dotnet@9
          ```

          ```powershell Windows theme={null}
          # Download and install from:
          # https://dotnet.microsoft.com/download/dotnet/9.0
          winget install Microsoft.DotNet.SDK.9
          ```
        </CodeGroup>

        Verify installation:

        ```bash theme={null}
        dotnet --version
        # Should output: 9.0.x
        ```
      </Step>

      <Step title="Clone the Repository">
        ```bash theme={null}
        git clone https://github.com/jellyfin/jellyfin.git
        cd jellyfin
        ```
      </Step>

      <Step title="Install FFmpeg">
        Jellyfin requires FFmpeg for media processing.

        <Tabs>
          <Tab title="Linux (Ubuntu/Debian)">
            Add the Jellyfin repository for optimized FFmpeg:

            ```bash theme={null}
            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
            ```
          </Tab>

          <Tab title="macOS">
            ```bash theme={null}
            brew install ffmpeg
            ```
          </Tab>

          <Tab title="Windows">
            Download FFmpeg from [https://www.gyan.dev/ffmpeg/builds/](https://www.gyan.dev/ffmpeg/builds/) and add to PATH.
          </Tab>
        </Tabs>
      </Step>

      <Step title="Run the Server">
        Start the server directly with `dotnet run`:

        ```bash theme={null}
        cd jellyfin
        dotnet run --project Jellyfin.Server
        ```

        <Warning>
          First run will download dependencies and may take a few minutes.
        </Warning>

        You should see output like:

        ```
        Jellyfin version: 10.9.0
        Operating system: Linux
        Architecture: X64
        Now listening on: http://0.0.0.0:8096
        ```
      </Step>

      <Step title="Access the Server">
        Open your browser to:

        ```
        http://localhost:8096
        ```
      </Step>
    </Steps>

    ### Development Tips

    <Tip>
      **Running without web client**: For API-only development, use:

      ```bash theme={null}
      dotnet run --project Jellyfin.Server -- --nowebclient
      ```
    </Tip>

    **Building for Release**:

    ```bash theme={null}
    dotnet build --configuration Release
    cd Jellyfin.Server/bin/Release/net10.0
    ./jellyfin
    ```

    **Running Tests**:

    ```bash theme={null}
    dotnet test
    ```
  </Tab>

  <Tab title="Visual Studio / VS Code">
    For development with an IDE.

    <Steps>
      <Step title="Install Prerequisites">
        * [.NET 9.0 SDK](https://dotnet.microsoft.com/download/dotnet/9.0)
        * [Visual Studio 2022+](https://visualstudio.microsoft.com/) or [VS Code](https://code.visualstudio.com/)
        * FFmpeg (see installation in "From Source" tab)
      </Step>

      <Step title="Clone and Open Project">
        ```bash theme={null}
        git clone https://github.com/jellyfin/jellyfin.git
        cd jellyfin
        ```

        **Visual Studio**: Open `Jellyfin.sln`

        **VS Code**:

        ```bash theme={null}
        code .
        ```

        Install recommended extensions when prompted.
      </Step>

      <Step title="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
      </Step>

      <Step title="Access the Server">
        The server will start on `http://localhost:8096`
      </Step>
    </Steps>
  </Tab>
</Tabs>

## Initial Setup Wizard

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

<Steps>
  <Step title="Select Language">
    Choose your preferred language for the interface.
  </Step>

  <Step title="Create Admin Account">
    Set up the administrator account:

    * Username
    * Password (optional but recommended)

    <Warning>
      The first user created has full administrator privileges. Use a strong password for production deployments.
    </Warning>
  </Step>

  <Step title="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"

    <Info>
      You can skip this step and add libraries later from the Dashboard.
    </Info>
  </Step>

  <Step title="Set Metadata Language">
    Choose preferred language for metadata and artwork downloads.
  </Step>

  <Step title="Configure Remote Access (Optional)">
    Configure if you want to access Jellyfin from outside your network.
  </Step>

  <Step title="Complete Setup">
    Click "Finish" to complete the wizard and start using Jellyfin!
  </Step>
</Steps>

## Verify Installation

Check that everything is working correctly:

### Check System Info

```bash theme={null}
curl http://localhost:8096/System/Info/Public
```

Expected response:

```json theme={null}
{
  "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

```bash theme={null}
curl -X GET "http://localhost:8096/System/Ping"
```

Response:

```json theme={null}
"Jellyfin Server"
```

## Common Issues

<AccordionGroup>
  <Accordion title="Port 8096 already in use">
    Change the port by setting an environment variable:

    ```bash theme={null}
    export JELLYFIN_PublishedServerUrl=http://localhost:8097
    dotnet run --project Jellyfin.Server -- --port 8097
    ```
  </Accordion>

  <Accordion title="FFmpeg not found">
    Ensure FFmpeg is installed and in your PATH:

    ```bash theme={null}
    ffmpeg -version
    ```

    If not found, install using the instructions in the "From Source" tab above.
  </Accordion>

  <Accordion title=".NET SDK not found">
    Verify .NET installation:

    ```bash theme={null}
    dotnet --version
    ```

    If not found, install from [https://dotnet.microsoft.com/download/dotnet/9.0](https://dotnet.microsoft.com/download/dotnet/9.0)
  </Accordion>

  <Accordion title="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
  </Accordion>
</AccordionGroup>

## Next Steps

<CardGroup cols={2}>
  <Card title="Detailed Installation" icon="download" href="/installation">
    Platform-specific installation guides
  </Card>

  <Card title="API Reference" icon="code" href="/api/authentication/overview">
    Explore the REST API documentation
  </Card>

  <Card title="Configuration" icon="gear" href="/setup/configuration">
    Configure Jellyfin for your needs
  </Card>

  <Card title="Development" icon="laptop-code" href="/development/building-from-source">
    Contributing and development guides
  </Card>
</CardGroup>

## 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

```bash theme={null}
# Run all tests
dotnet test

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

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

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