Overseerr & Jellyseerr

The request system. A beautiful way for anyone to ask for content.

What are they?

Overseerr (for Plex) and Jellyseerr (for Jellyfin) are web applications that give your media server a beautiful, user-friendly request system. Think of them as the front desk of your streaming service.

Instead of giving everyone access to Sonarr and Radarr (which are powerful but complicated), you point people to Overseerr. They see a polished interface where they can:

Browse trending, popular, and upcoming movies and TV shows
Search for specific content
See what's already in your library
Request movies or TV shows with one click
Track the status of their requests

Behind the scenes, when someone makes a request, Overseerr tells Sonarr or Radarr, which kicks off the whole automation chain you've already set up.

Overseerr vs Jellyseerr

Simple rule:

Using Plex? Use Overseerr
Using Jellyfin? Use Jellyseerr

Jellyseerr is a fork of Overseerr that adds Jellyfin support. It also supports Plex, so if you want the flexibility of supporting both, Jellyseerr is the way to go. The interfaces are nearly identical.

Docker setup

Overseerr (for Plex)

services:
  overseerr:
    image: lscr.io/linuxserver/overseerr:latest
    container_name: overseerr
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=America/New_York
    volumes:
      - ./overseerr/config:/config
    ports:
      - "5055:5055"
    restart: unless-stopped

Jellyseerr (for Jellyfin)

services:
  jellyseerr:
    image: fallenbagel/jellyseerr:latest
    container_name: jellyseerr
    environment:
      - TZ=America/New_York
    volumes:
      - ./jellyseerr/config:/app/config
    ports:
      - "5055:5055"
    restart: unless-stopped

Start with docker compose up -d, then open http://your-server:5055.

Initial configuration

The setup wizard walks you through everything. Here's what to expect:

Step 1: Sign in

Overseerr: Sign in with your Plex account. This links your Plex server and creates your admin account.
Jellyseerr: Choose Jellyfin, enter your Jellyfin server URL, and sign in with your Jellyfin admin credentials.

Step 2: Sync libraries

The wizard will scan your media server and identify your libraries (Movies, TV Shows, etc.). Select which libraries to sync. This lets Overseerr know what you already have, so it won't show those items as "available to request."

Step 3: Connect Sonarr and Radarr

This is where the automation connects:

Adding Radarr:

Click "Add Radarr Server"
Check "Default Server" (use this server for all movie requests)
Server Name: whatever you want (e.g., "Radarr")
Hostname: radarr (Docker service name) or your server IP
Port: 7878
API Key: from Radarr's Settings > General
Click "Test" -- it should connect and load your quality profiles
Select your default quality profile and root folder
Save

Adding Sonarr:

Click "Add Sonarr Server"
Same process: hostname (sonarr), port (8989), API key
Select quality profile, root folder, and language profile
Save

The complete flow

Here's what happens end-to-end when someone requests a movie:

User opens Overseerr, searches for "Oppenheimer", clicks "Request"
Overseerr receives the request. If auto-approve is on, it immediately sends it to Radarr. Otherwise, it waits for admin approval.
Radarr receives the movie, searches all indexers via Prowlarr
Prowlarr queries your Usenet indexers and torrent trackers, returns results
Radarr picks the best match based on your quality profile and sends it to SABnzbd (or qBittorrent)
SABnzbd downloads the file, verifies, and extracts it
Radarr detects the completed download, renames it, moves it to /data/media/movies/Oppenheimer (2023)/
Plex/Jellyfin detects the new file and adds it to the library
Overseerr updates the request status to "Available"
The user gets a notification (if configured) that their movie is ready to watch

All of this happens automatically. The user clicks one button and gets a notification when it's ready. That's the magic of this stack.

User management

One of Overseerr's best features is user management. You can give friends and family their own accounts without exposing any of the backend.

Importing users

Plex/Overseerr: Go to Settings > Users and import your Plex friends. Anyone you've shared your Plex server with can be imported.
Jellyfin/Jellyseerr: Import users from your Jellyfin server, or let people create local accounts.

Permissions

You can control what each user can do:

Request -- can they make requests?
Auto-approve -- are their requests automatically approved, or do they need admin approval?
Request limits -- limit how many movies/shows a user can request per week
View requests -- can they see other users' requests?
4K requests -- if you have a separate 4K quality profile, you can restrict who can request in 4K

Recommended setup for friends/family: Enable requests, set auto-approve for trusted users, and set request limits (maybe 5 movies and 3 TV shows per week) for everyone else. This prevents anyone from going on a request binge that overwhelms your storage.

Notifications

Overseerr/Jellyseerr can send notifications when requests are made, approved, or available. You can set these up under Settings > Notifications:

Discord -- create a webhook in your Discord server, paste the URL. Great for a shared server with friends.
Telegram -- set up a bot via BotFather, add the token and chat ID
Email -- configure SMTP settings. Users get notified at their email address.
Slack -- webhook integration
Pushover -- push notifications to your phone
Webhook -- generic webhook for custom integrations

You can configure notifications separately for different events (new request, approved, available, failed) and for admin vs. regular users.

Tautulli: monitoring your server

While not part of the request flow, Tautulli is worth mentioning. It's a monitoring tool for Plex that tracks:

Who's watching what and when
Playback quality and transcoding stats
Most watched content, most active users
History and statistics
Notifications for playback events

services:
  tautulli:
    image: lscr.io/linuxserver/tautulli:latest
    container_name: tautulli
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=America/New_York
    volumes:
      - ./tautulli/config:/config
    ports:
      - "8181:8181"
    restart: unless-stopped

Access it at http://your-server:8181. Connect it to your Plex server and it'll start collecting data immediately. It's especially useful for seeing if users are transcoding (which taxes your server) when they could be direct playing.

Jellyfin alternative: Jellyfin has built-in playback tracking and user activity monitoring. It's not as detailed as Tautulli, but it covers the basics without needing an extra app.

The complete stack

Congratulations -- if you've followed this entire guide series, you now have a fully automated media server. Here's everything running together:

┌─────────────────────────────────────────────────────┐
│                Your complete stack                   │
├─────────────────────────────────────────────────────┤
│                                                     │
│  Overseerr/Jellyseerr ─── request management        │
│         │                                           │
│         ▼                                           │
│  Sonarr ──────────────── TV show automation         │
│  Radarr ──────────────── movie automation           │
│  Lidarr ──────────────── music automation           │
│  Readarr ─────────────── book automation            │
│         │           │                               │
│         ▼           ▼                               │
│  Prowlarr ───── SABnzbd ──── Usenet downloads       │
│  (indexers)     qBittorrent ─ torrent downloads     │
│                 (via Gluetun VPN)                    │
│                      │                              │
│                      ▼                              │
│  Plex/Jellyfin ──── media server & streaming        │
│  Bazarr ─────────── subtitle downloads              │
│  Tautulli ───────── monitoring (Plex only)          │
│                                                     │
└─────────────────────────────────────────────────────┘

Docker Compose: the full stack

Here's a reference docker-compose.yml with every service. Customize the paths, timezone, and credentials for your setup:

services:
  # --- Media Server ---
  jellyfin:
    image: jellyfin/jellyfin:latest
    container_name: jellyfin
    ports:
      - "8096:8096"
    volumes:
      - ./jellyfin/config:/config
      - ./jellyfin/cache:/cache
      - /data/media:/media
    devices:
      - /dev/dri:/dev/dri  # Intel hardware transcoding
    restart: unless-stopped

  # --- Media Management ---
  sonarr:
    image: lscr.io/linuxserver/sonarr:latest
    container_name: sonarr
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=America/New_York
    volumes:
      - ./sonarr/config:/config
      - /data:/data
    ports:
      - "8989:8989"
    restart: unless-stopped

  radarr:
    image: lscr.io/linuxserver/radarr:latest
    container_name: radarr
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=America/New_York
    volumes:
      - ./radarr/config:/config
      - /data:/data
    ports:
      - "7878:7878"
    restart: unless-stopped

  lidarr:
    image: lscr.io/linuxserver/lidarr:latest
    container_name: lidarr
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=America/New_York
    volumes:
      - ./lidarr/config:/config
      - /data:/data
    ports:
      - "8686:8686"
    restart: unless-stopped

  prowlarr:
    image: lscr.io/linuxserver/prowlarr:latest
    container_name: prowlarr
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=America/New_York
    volumes:
      - ./prowlarr/config:/config
    ports:
      - "9696:9696"
    restart: unless-stopped

  bazarr:
    image: lscr.io/linuxserver/bazarr:latest
    container_name: bazarr
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=America/New_York
    volumes:
      - ./bazarr/config:/config
      - /data/media:/data/media
    ports:
      - "6767:6767"
    restart: unless-stopped

  # --- Download Clients ---
  sabnzbd:
    image: lscr.io/linuxserver/sabnzbd:latest
    container_name: sabnzbd
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=America/New_York
    volumes:
      - ./sabnzbd/config:/config
      - /data/downloads:/data/downloads
    ports:
      - "8080:8080"
    restart: unless-stopped

  gluetun:
    image: qmcgaw/gluetun:latest
    container_name: gluetun
    cap_add:
      - NET_ADMIN
    environment:
      - VPN_SERVICE_PROVIDER=your_provider
      - VPN_TYPE=wireguard
      - WIREGUARD_PRIVATE_KEY=your_key
      - WIREGUARD_ADDRESSES=10.x.x.x/32
    ports:
      - "8081:8081"
    restart: unless-stopped

  qbittorrent:
    image: lscr.io/linuxserver/qbittorrent:latest
    container_name: qbittorrent
    network_mode: "service:gluetun"
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=America/New_York
      - WEBUI_PORT=8081
    volumes:
      - ./qbittorrent/config:/config
      - /data/downloads:/data/downloads
    depends_on:
      gluetun:
        condition: service_healthy
    restart: unless-stopped

  # --- Request Management ---
  jellyseerr:
    image: fallenbagel/jellyseerr:latest
    container_name: jellyseerr
    environment:
      - TZ=America/New_York
    volumes:
      - ./jellyseerr/config:/app/config
    ports:
      - "5055:5055"
    restart: unless-stopped

You made it! This is the complete, fully automated media server stack. From here, it mostly runs itself. Check in occasionally to approve requests, update containers (docker compose pull && docker compose up -d), and enjoy your library.

The full guide series

Home Media Server -- The big picture, Plex/Jellyfin, Docker basics
The *Arr Stack -- Sonarr, Radarr, Lidarr, Prowlarr, Bazarr
Download Clients -- Usenet and torrent clients
Indexers -- Where content is found
Overseerr & Jellyseerr -- You are here. Request management and the full stack.