Media beginner ⏱ 30 minutes

Jellyseerr: Media Request Management for Jellyfin

Let users request movies and TV shows. Seamless integration with *Arr stack and Jellyfin.

By homelabbing.io • 2025-12-16
#jellyseerr#jellyfin#requests#media-automation#docker

Introduction: Democratizing Your Media Library

Imagine this scenario: You run a Jellyfin server for your family. Your spouse wants to watch “The Crown” but it’s not in your library. They text you. You manually search for it on Sonarr, select quality profiles, confirm the download, wait for it to complete, and notify them it’s ready. This happens three times a week.

Now imagine this: Your spouse opens a beautiful web interface, searches for “The Crown,” clicks “Request,” and receives a notification when it’s ready to watch. No texting you. No explaining Sonarr. No technical knowledge required. That’s Jellyseerr.

Jellyseerr is a fork of Overseerr (designed for Plex) that brings request management to Jellyfin and Emby. It provides a Netflix-like discovery interface where users can browse, search, and request content. Behind the scenes, it communicates with Sonarr and Radarr to automatically download approved requests, then notifies users when content becomes available.

By the end of this guide, you’ll have:

  • Jellyseerr installed via Docker with proper configuration
  • Integration with Jellyfin/Plex for authentication and library detection
  • Sonarr and Radarr connected for automatic downloads
  • User management with request quotas and permissions
  • Notification systems (Discord, email, Telegram, etc.)
  • Request approval workflows for controlled content acquisition
  • Mobile-friendly interface for requesting content anywhere

Whether you share your media server with family, roommates, or friends, Jellyseerr transforms the request process from tedious to effortless.

What is Jellyseerr?

The Request Management Problem

When you share a media server, content requests create friction:

Without Request Management:

  1. User: “Can you add The Mandalorian?”
  2. Admin: “Which season? What quality?”
  3. User: “I don’t know, just the show?”
  4. Admin: Opens Sonarr, searches, configures, monitors
  5. Admin: Two hours later “It’s ready”
  6. User: “What’s ready?”

With Jellyseerr:

  1. User: Opens Jellyseerr, searches, clicks “Request”
  2. Jellyseerr: Automatically sends to Sonarr
  3. Sonarr: Downloads via configured quality profile
  4. Jellyseerr: Detects completion, notifies user
  5. User: Watches immediately in Jellyfin

Core Features

For Users (Non-Technical):

  • Netflix-style discovery interface with posters, descriptions, trailers
  • Search across movies and TV shows
  • See what’s already available vs. what can be requested
  • Track request status (pending, approved, downloading, available)
  • Receive notifications when content is ready
  • Mobile-responsive design for requests on the go

For Administrators:

  • Approve or auto-approve requests based on user permissions
  • Set request quotas (e.g., 10 movies per week per user)
  • Integration with Sonarr (TV) and Radarr (movies)
  • Support for 4K instances (separate Radarr4K, Sonarr4K)
  • Detailed request history and analytics
  • User management with granular permissions

For Automation:

  • Automatic quality profile selection
  • Root folder assignment per user or globally
  • Release monitoring and status updates
  • Webhook notifications to Discord, Slack, Telegram
  • Email notifications for approvals and completions
  • API for custom integrations

Jellyseerr vs. Overseerr

Overseerr (original project):

  • Designed for Plex
  • Mature, stable, larger community
  • Some Plex-specific features

Jellyseerr (fork):

  • Added Jellyfin support
  • Added Emby support (limited)
  • Nearly feature-parity with Overseerr
  • Active development, responsive to Jellyfin community

If you use Jellyfin, use Jellyseerr. If you use Plex, either works (Overseerr has longer track record). If you use both Jellyfin and Plex simultaneously, Jellyseerr supports both.

Prerequisites

Required Services

Before installing Jellyseerr, you need:

1. Media Server:

  • Jellyfin (recommended) OR Plex
  • Admin access to create API keys
  • Library already configured

2. Download Management:

  • Radarr (for movies) - installed and configured
  • Sonarr (for TV shows) - installed and configured
  • At least one download client (qBittorrent, Transmission, NZBGet, etc.)

3. Infrastructure:

  • Docker and Docker Compose installed
  • Network access to all services
  • 100MB free disk space for Jellyseerr
  • Reverse proxy (optional, for HTTPS and custom domain)

Typical Stack:

Jellyfin (port 8096) ← Media playback
Radarr (port 7878) ← Movie management
Sonarr (port 8989) ← TV management
qBittorrent (port 8080) ← Download client
Jellyseerr (port 5055) ← Request interface

All running in Docker containers on the same network for easy communication.

Knowledge Assumptions

You should be comfortable with:

  • Basic Docker commands
  • Accessing web UIs
  • Finding API keys in Jellyfin/Radarr/Sonarr
  • Editing YAML files (docker-compose)

If you need to set up Radarr/Sonarr first, see our *arr Stack Guide.

Installation

We’ll use Docker Compose for easy management and updates.

Step 1: Create Directory Structure

# Create Jellyseerr directory
mkdir -p ~/jellyseerr
cd ~/jellyseerr

# Create config directory
mkdir -p config

Step 2: Create docker-compose.yml

version: '3.8'

services:
  jellyseerr:
    image: fallenbagel/jellyseerr:latest
    container_name: jellyseerr
    environment:
      - LOG_LEVEL=info
      - TZ=America/New_York  # Change to your timezone
    ports:
      - 5055:5055
    volumes:
      - ./config:/app/config
    restart: unless-stopped

Important Configuration Notes:

  • Timezone: Replace America/New_York with your timezone (TZ database)
  • Port 5055: Default Jellyseerr port, change if you have conflicts
  • LOG_LEVEL: Options are debug, info, warn, error

Step 3: Deploy Container

# Start Jellyseerr
docker compose up -d

# Verify it's running
docker compose ps

# Expected output:
# NAME          IMAGE                          STATUS
# jellyseerr    fallenbagel/jellyseerr:latest  Up 10 seconds

# Check logs for any errors
docker compose logs -f jellyseerr

Step 4: Access Web Interface

Open your browser and navigate to:

http://your-server-ip:5055

You should see the Jellyseerr welcome screen prompting you to begin setup.

Standalone Docker Deployment

If you prefer standalone Docker without Compose:

docker run -d   --name jellyseerr   -e LOG_LEVEL=info   -e TZ=America/New_York   -p 5055:5055   -v ~/jellyseerr/config:/app/config   --restart unless-stopped   fallenbagel/jellyseerr:latest

Initial Configuration

Setup Wizard

When you first access Jellyseerr, you’ll go through a guided setup wizard.

Screen 1: Welcome

Click Get Started to begin configuration.

Screen 2: Media Server Selection

Choose your media server:

  • Use Jellyfin (recommended if you use Jellyfin)
  • Use Plex
  • Use Emby

For this guide, we’ll configure Jellyfin. Plex configuration is similar.

Screen 3: Jellyfin Server Configuration

Jellyfin Server URL:

  • Internal (same Docker network): http://jellyfin:8096
  • External/Host network: http://192.168.1.100:8096 (use your Jellyfin IP)

Getting the Jellyfin API Key:

  1. Open Jellyfin
  2. Go to Dashboard → API Keys
  3. Click + (New API Key)
  4. App name: Jellyseerr
  5. Click OK
  6. Copy the API key (you can’t view it again)

Paste API key into Jellyseerr

Sign-In URL (Optional): Leave blank for default Jellyfin login, or specify custom URL if using reverse proxy.

Click Save Changes.

Screen 4: Library Sync

Jellyseerr will connect to Jellyfin and fetch your libraries.

Select which libraries to monitor:

  • Check Movies library
  • Check TV Shows library
  • Uncheck personal libraries (home videos, photos, etc.)

Click Continue.

Initial library scan begins (may take 1-5 minutes depending on library size).

Screen 5: Radarr Configuration

Now we’ll connect Radarr for movie requests.

Enable Radarr: Toggle ON

Connection Details:

  • Default Server: Checked (if this is your only Radarr instance)
  • 4K Server: Unchecked (we’ll cover 4K later)
  • Server Name: Radarr (or custom name)
  • Hostname or IP: radarr (Docker internal) or 192.168.1.100
  • Port: 7878 (Radarr default)
  • Use SSL: Usually unchecked for internal connections
  • API Key: Found in Radarr → Settings → General → Security → API Key

Test Connection: Click Test button

Should show green checkmark: “Radarr connection successful”

Radarr Configuration:

  • Quality Profile: Select default (e.g., “HD Balanced”)
  • Root Folder: /data/media/movies (or your Radarr movie path)
  • Minimum Availability: Released (download when available)

Click Add Server.

Screen 6: Sonarr Configuration

Similar to Radarr, now for TV shows.

Enable Sonarr: Toggle ON

Connection Details:

  • Default Server: Checked
  • 4K Server: Unchecked
  • Server Name: Sonarr
  • Hostname or IP: sonarr (Docker internal) or 192.168.1.100
  • Port: 8989 (Sonarr default)
  • Use SSL: Unchecked (for internal)
  • API Key: From Sonarr → Settings → General → Security → API Key

Test Connection: Click Test

Sonarr Configuration:

  • Quality Profile: Select default (e.g., “TV Fast & Upgrade”)
  • Root Folder: /data/media/tv (your Sonarr TV path)
  • Language Profile: English (or your preference)
  • Anime Quality Profile: Select if you watch anime
  • Anime Root Folder: Separate folder for anime (optional)
  • Season Folder: Checked (organize episodes by season)

Click Add Server.

Screen 7: Admin Account

Create your administrator account:

Import Jellyfin Users: Checked (recommended)

This imports existing Jellyfin users. You’ll see a list of Jellyfin accounts.

Select your admin account from the list.

Set Email (Optional): For password reset and notifications

Set Locale/Region: For content discovery (affects TMDb metadata)

Click Finish Setup.

Jellyseerr redirects you to the main interface!

User Management

Importing Jellyfin Users

Jellyseerr can automatically import users from Jellyfin, allowing them to log in with their existing Jellyfin credentials.

Step 1: Enable User Import

Settings (gear icon) → Jellyfin → Sign-In Settings

  • Enable New Jellyfin Sign-In: Checked
  • Enable Jellyfin User Import: Checked

Click Save Changes.

Step 2: Sync Users

Settings → Users

Click Import Jellyfin Users button (if not auto-synced during setup)

You’ll see all Jellyfin users listed.

User Permissions

Each user has configurable permission levels:

Permission Types:

  1. User (Default)

    • Can request content
    • See their own requests
    • Limited to request quotas

  2. Request Manager

    • All User permissions
    • Can view all requests
    • Can approve/decline requests
    • Cannot modify settings

  3. Administrator

    • Full access
    • Can modify all settings
    • User management
    • No request quotas

Setting User Permissions:

Settings → Users → Select a user

Permissions Section:

  • Admin: Full control
  • Manage Requests: Can approve requests
  • Manage Issues: Can handle reported problems
  • View Recent Requests: See all recent activity
  • Auto Approve (Movies): User’s movie requests auto-approved
  • Auto Approve (TV): User’s TV requests auto-approved
  • Request 4K (Movies/TV): Can request 4K versions

Request Limits:

  • Movie Request Limit: Number of movies per period (e.g., 10)
  • Series Request Limit: Number of series per period (e.g., 5)
  • Limit Duration: Day, Week, or Month

Example Configuration:

For a trusted family member:

  • Auto Approve Movies: Checked
  • Auto Approve TV: Checked
  • Movie Limit: 20 per month
  • Series Limit: 10 per month

For a casual friend:

  • Auto Approve: Unchecked (requires admin approval)
  • Movie Limit: 5 per month
  • Series Limit: 2 per month

Click Save after configuring.

Local User Accounts

You can also create local Jellyseerr accounts (not linked to Jellyfin):

Settings → Users → Create Local User

  • Email: User’s email address
  • Username: Login username
  • Password: Set initial password
  • Permissions: Configure as above

Click Create.

User receives email invitation (if email configured).

Request Workflows

User Request Process

From User Perspective:

  1. User logs in to Jellyseerr with Jellyfin credentials

  2. Browse or search for content

    • Popular movies/TV shows displayed on home page
    • Search bar for specific content
    • Filter by genre, year, etc.

  3. Click on desired content

    • View details: description, cast, trailer, ratings
    • See if already available in Jellyfin (green “Available” badge)
    • See if already requested (yellow “Pending” badge)

  4. Click “Request” button

  5. Request Modal appears:

    • For Movies:

      • Select quality profile (if allowed)
      • Select 4K option (if permitted)
      • Add note to admin (optional)

    • For TV Shows:

      • Select all seasons or specific seasons
      • Select quality profile
      • Add note

  6. Submit request

  7. Confirmation:

    • “Request submitted successfully”
    • Can view status in Requests page

  8. Notifications:

    • When admin approves (if manual approval required)
    • When download starts
    • When content becomes available

Admin Approval Process

For Auto-Approved Requests:

No action needed. Jellyseerr immediately sends to Radarr/Sonarr.

For Manual Approval Requests:

  1. Admin receives notification (email, Discord, etc.)

  2. Navigate to Requests page

  3. View pending requests:

    • See requester name
    • Content details
    • Notes from requester

  4. Review request:

    • Click on request for full details
    • Check if content meets quality standards
    • Verify storage space available

  5. Approve or Decline:

    • Approve: Jellyseerr sends to Radarr/Sonarr automatically
    • Decline: Select reason (optional), user receives notification

Bulk Actions:

Select multiple requests → Approve Selected or Decline Selected

Request Status Tracking

Status Indicators:

  • Pending: Awaiting admin approval
  • Approved: Sent to Radarr/Sonarr, waiting for download
  • Partially Available: Some episodes/seasons available
  • Available: Fully downloaded and in Jellyfin library
  • Declined: Admin rejected request
  • Failed: Technical error (check logs)

Viewing Request Status:

Users can check Requests page to see:

  • All their pending/approved requests
  • Estimated completion time (based on download speed)
  • Why a request was declined (if admin provided reason)

Notifications Configuration

Jellyseerr supports extensive notification options to keep users informed.

Email Notifications

Step 1: Configure Email Settings

Settings → Notifications → Email

Enable Agent: Toggle ON

SMTP Configuration:

Using Gmail:

SMTP Host: smtp.gmail.com
SMTP Port: 587
Encryption Method: STARTTLS
Username: [email protected]
Password: App password (not regular password)
From Email: [email protected]
From Name: Jellyseerr

Getting Gmail App Password:

  1. Google Account → Security
  2. 2-Step Verification (must be enabled)
  3. App passwords → Generate
  4. Use generated password in Jellyseerr

Using Custom SMTP (e.g., Mailgun, SendGrid):

SMTP Host: smtp.mailgun.org
SMTP Port: 587
Encryption Method: STARTTLS
Username: your-mailgun-user
Password: your-mailgun-password

Test Configuration: Click Test button

Should send test email to admin address.

Click Save Changes.

Step 2: Enable Email Notification Types

For each notification type, toggle which events trigger emails:

Media Requested:

  • Admin Email: Checked (notify admins of new requests)
  • User Email: Unchecked (user knows they requested)

Media Approved:

  • User Email: Checked (notify requester)

Media Available:

  • User Email: Checked (notify when ready to watch)

Media Failed:

  • Admin Email: Checked (notify admins of failures)

Discord Notifications

Step 1: Create Discord Webhook

  1. Open Discord server
  2. Server Settings → Integrations → Webhooks
  3. Click New Webhook
  4. Name: Jellyseerr
  5. Channel: Select notification channel (e.g., #media-requests)
  6. Copy Webhook URL

Step 2: Configure in Jellyseerr

Settings → Notifications → Discord

Enable Agent: Toggle ON

Webhook URL: Paste Discord webhook URL

Username: Jellyseerr (appears as bot name in Discord)

Avatar URL: (Optional) Custom bot avatar

Notification Types:

Toggle which events post to Discord:

  • Media Requested: Checked
  • Media Approved: Checked
  • Media Available: Checked
  • Media Declined: Checked
  • Media Failed: Checked

Test: Click Send Test Notification

Check Discord channel for test message.

Click Save Changes.

Telegram Notifications

Step 1: Create Telegram Bot

  1. Open Telegram, search for @BotFather
  2. Send /newbot
  3. Follow prompts to name your bot
  4. Copy bot token (looks like 123456789:ABCdefGHIjklMNOpqrsTUVwxyz)

Step 2: Get Chat ID

  1. Start conversation with your new bot (send any message)
  2. Visit: https://api.telegram.org/bot<YOUR_BOT_TOKEN>/getUpdates
  3. Find "chat":{"id":123456789} in response
  4. Copy chat ID

Step 3: Configure in Jellyseerr

Settings → Notifications → Telegram

Enable Agent: Toggle ON

Bot API Token: Paste bot token from BotFather

Chat ID: Paste chat ID from getUpdates

Send Silently: Checked (no sound notification)

Notification Types: Toggle as desired

Test: Click Send Test Notification

Check Telegram for test message.

Webhook Notifications (Advanced)

For custom integrations, use webhooks.

Settings → Notifications → Webhook

Webhook URL: https://your-automation-server.com/jellyseerr-webhook

Authorization Header: (Optional) Bearer your-secret-token

JSON Payload: Automatically sent with event details

Example Payload (Media Requested):

{
  "notification_type": "MEDIA_REQUESTED",
  "event": "media.requested",
  "subject": "New Request: The Matrix",
  "message": "User requested The Matrix (1999)",
  "media": {
    "media_type": "movie",
    "tmdbId": 603,
    "tvdbId": null,
    "status": "pending"
  },
  "request": {
    "request_id": 42,
    "requestedBy_username": "alice"
  }
}

Use this for custom automation, logging, or integration with home automation systems.

Advanced Configuration

4K Request Management

Many users maintain separate 4K libraries with higher quality requirements. Jellyseerr supports dual Radarr/Sonarr instances.

Step 1: Deploy 4K Radarr Instance

Create separate Radarr container for 4K:

radarr-4k:
  image: linuxserver/radarr:latest
  container_name: radarr-4k
  environment:
    - PUID=1000
    - PGID=1000
    - TZ=America/New_York
  ports:
    - "7879:7878"  # Different port
  volumes:
    - ./radarr-4k/config:/config
    - /data:/data
  restart: unless-stopped

Configure with:

  • Root folder: /data/media/movies-4k
  • Quality profile: 4K/2160p settings
  • Custom format scores favoring Remux/high-quality releases

Step 2: Add 4K Server to Jellyseerr

Settings → Radarr

Click Add Radarr Server

  • Default Server: Unchecked
  • 4K Server: Checked
  • Server Name: Radarr 4K
  • Hostname: radarr-4k (or IP)
  • Port: 7879
  • API Key: From Radarr 4K instance
  • Quality Profile: 4K quality profile
  • Root Folder: /data/media/movies-4k

Test and Save.

Repeat for Sonarr 4K if desired.

Step 3: Enable 4K Requests for Users

Settings → Users → Select user

Permissions:

  • Request 4K Movies: Checked
  • Request 4K Series: Checked

Now when users request content, they see checkbox:

  • Request in 4K

Checking this routes to 4K Radarr/Sonarr instance instead of regular.

Quality Profile Override

Allow users to select quality profiles on request (advanced feature).

Settings → Radarr (or Sonarr)

Server Settings:

  • Enable Quality Profile Selection: Checked

Now users see dropdown during request:

  • Quality: [HD Balanced | 4K UHD | SD Only]

Useful for giving power users more control.

External Access with Reverse Proxy

For accessing Jellyseerr from outside your network with HTTPS.

Using Traefik:

Add to docker-compose.yml:

jellyseerr:
  image: fallenbagel/jellyseerr:latest
  container_name: jellyseerr
  environment:
    - LOG_LEVEL=info
    - TZ=America/New_York
  volumes:
    - ./config:/app/config
  networks:
    - web
  labels:
    - "traefik.enable=true"
    - "traefik.http.routers.jellyseerr.rule=Host(`jellyseerr.yourdomain.com`)"
    - "traefik.http.routers.jellyseerr.entrypoints=websecure"
    - "traefik.http.routers.jellyseerr.tls.certresolver=letsencrypt"
    - "traefik.http.services.jellyseerr.loadbalancer.server.port=5055"
  restart: unless-stopped

Access via: https://jellyseerr.yourdomain.com

Using Nginx:

server {
    listen 443 ssl http2;
    server_name jellyseerr.yourdomain.com;

    ssl_certificate /etc/letsencrypt/live/jellyseerr.yourdomain.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/jellyseerr.yourdomain.com/privkey.pem;

    location / {
        proxy_pass http://localhost:5055;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

Update Jellyseerr Base URL:

Settings → General → Application URL

Set to: https://jellyseerr.yourdomain.com

Save and restart Jellyseerr.

Issue Reporting

Users can report problems with media:

Enable Issue Reporting:

Settings → General → Enable Issue Reporting: Checked

Users can now report:

  • Video playback issues
  • Audio sync problems
  • Subtitle errors
  • Wrong media (incorrect match)

Admins view issues:

Issues page → See all reported problems with details

Useful for quality control and user feedback.

Troubleshooting

Jellyseerr Can’t Connect to Jellyfin

Symptoms:

  • “Failed to connect to Jellyfin server”
  • Timeout errors during setup

Solutions:

1. Verify Jellyfin URL:

# From Jellyseerr container
docker exec jellyseerr curl http://jellyfin:8096/health

# Should return 200 OK

2. Check API Key:

  • Regenerate in Jellyfin: Dashboard → API Keys → Delete old → Create new
  • Verify no extra spaces when pasting

3. Network connectivity:

# Ensure same Docker network
docker network inspect <network-name>

# Both Jellyfin and Jellyseerr should be listed

4. Firewall:

  • Ensure port 8096 not blocked
  • Check Docker firewall rules

Requests Not Appearing in Radarr/Sonarr

Symptoms:

  • User requests content
  • Nothing happens in Radarr/Sonarr
  • Request stuck in “Pending” or “Approved”

Diagnostics:

Check Jellyseerr Logs:

docker logs jellyseerr --tail 50

# Look for errors like:
# "Failed to add movie to Radarr"
# "Radarr API returned error"

Verify Radarr/Sonarr Connection:

Settings → Radarr → Click Test

Should show green checkmark.

Common Issues:

Wrong API Key:

  • Regenerate in Radarr: Settings → General → Security → Regenerate API Key
  • Update in Jellyseerr

Wrong Root Folder:

  • Radarr Settings → Media Management → Root Folders
  • Ensure path in Jellyseerr matches exactly
  • Case-sensitive on Linux

Quality Profile Doesn’t Exist:

  • Radarr Settings → Profiles
  • Ensure quality profile selected in Jellyseerr exists in Radarr
  • Re-select profile in Jellyseerr settings

Network Issues:

# Test from Jellyseerr container
docker exec jellyseerr curl http://radarr:7878/api/v3/system/status?apiKey=YOUR_API_KEY

# Should return JSON with Radarr version info

Users Can’t Login

Symptoms:

  • “Invalid credentials” error
  • Login page loops

Solutions:

Jellyfin User Import Not Enabled:

Settings → Jellyfin → Enable New Jellyfin Sign-In: Checked

User Not Imported:

Settings → Users → Import Jellyfin Users button

Case-Sensitive Usernames:

  • Jellyfin usernames are case-sensitive
  • Ensure exact match (e.g., “Alice” ≠ “alice”)

Jellyfin Password Changed:

  • User must use current Jellyfin password
  • If changed in Jellyfin, use new password in Jellyseerr

Local Account vs. Jellyfin Account:

  • Verify user is logging in with correct account type
  • Jellyfin users: use Jellyfin credentials
  • Local users: use Jellyseerr-created credentials

Notifications Not Sending

Email Not Working:

Test SMTP:

# From Jellyseerr logs
docker logs jellyseerr | grep -i smtp

# Look for connection errors

Common Fixes:

  • Gmail: Use App Password, not regular password
  • Enable “Less secure app access” (if using old Gmail)
  • Verify SMTP port (587 for STARTTLS, 465 for SSL)
  • Check firewall blocking port 587/465

Discord Webhook Not Working:

  • Verify webhook URL is correct (should contain /api/webhooks/)
  • Ensure Discord channel still exists
  • Regenerate webhook in Discord if suspicious

Test Individual Notifications:

Settings → Notifications → Discord → Send Test Notification

Check Discord for message.

Best Practices

User Onboarding

For Family/Friends:

  1. Create dedicated “How to Request” guide:

    • Screenshot walkthrough
    • Share via Google Docs or Notion
    • Include Jellyseerr URL

  2. Set reasonable quotas:

    • Start conservative (5-10 movies/month)
    • Increase based on behavior
    • Prevents abuse/storage issues

  3. Enable auto-approval for trusted users:

    • Saves admin time
    • Builds trust
    • Monitor initially

  4. Configure notifications:

    • Users love knowing when content is ready
    • Email + Discord/Telegram recommended
    • Set expectations (downloads may take 1-6 hours)

Admin Workflows

Daily Tasks:

  • Check pending requests (if not auto-approved)
  • Review any failed downloads
  • Monitor storage space

Weekly Tasks:

  • Review request history/analytics
  • Adjust quotas based on usage
  • Check for Jellyseerr updates

Monthly Tasks:

  • Audit user permissions
  • Review quality profiles
  • Clean up declined/old requests

Security

Restrict External Access:

  • Don’t expose Jellyseerr to internet without authentication
  • Use reverse proxy with SSL
  • Consider VPN-only access (Tailscale)

Rate Limiting: Settings → General → Enable Rate Limiting: Checked

Prevents brute-force login attempts.

Regular Backups:

# Backup Jellyseerr config
docker exec jellyseerr tar czf /app/config/backup.tar.gz /app/config/db
docker cp jellyseerr:/app/config/backup.tar.gz ~/jellyseerr-backup-$(date +%F).tar.gz

Update Regularly:

# Pull latest image
docker compose pull jellyseerr

# Restart with new image
docker compose up -d jellyseerr

Integration with Other Tools

Tautulli Integration

Tautulli tracks Jellyfin/Plex watch history. Combine with Jellyseerr for powerful analytics.

Use Case: Identify requested content that’s never watched.

Setup:

  1. Install Tautulli (monitors Jellyfin)
  2. Compare Tautulli watch data with Jellyseerr request data
  3. Identify unused content for cleanup

Homepage/Dashy Integration

Add Jellyseerr to your homelab dashboard.

Homepage.dev Widget:

- Media Requests:
    icon: jellyseerr.png
    href: https://jellyseerr.yourdomain.com
    description: Request Movies & TV

Dashy:

- title: Jellyseerr
  icon: fas fa-film
  url: http://192.168.1.100:5055

Automation Scripts

Auto-Delete Old Requests:

Jellyseerr doesn’t auto-purge old requests. Create cleanup script:

#!/bin/bash
# Jellyseerr API cleanup

JELLYSEERR_URL="http://localhost:5055"
API_KEY="your-jellyseerr-api-key"

# Delete requests older than 90 days and available
curl -X DELETE "$JELLYSEERR_URL/api/v1/request/cleanup?days=90"   -H "X-Api-Key: $API_KEY"

Run monthly via cron.

Conclusion

Jellyseerr transforms shared media servers from an administrative burden into a delightful, user-friendly service. Your users get a Netflix-quality browsing experience, while you maintain full control over what gets added to your library.

What You’ve Built:

  • Self-service request system eliminating manual work
  • Integration with Sonarr/Radarr for automatic downloads
  • Notification system keeping everyone informed
  • Granular permission system with quotas and approvals
  • Production-ready deployment with monitoring and backups

Key Takeaways:

  1. Auto-approve trusted users to minimize admin overhead
  2. Set quotas to prevent storage exhaustion
  3. Configure notifications for better user experience
  4. Use reverse proxy for secure remote access
  5. Regular updates ensure security and new features

Next Steps:

  • Fine-tune quality profiles based on actual requests
  • Implement 4K instances if you have storage
  • Set up analytics to understand request patterns
  • Create user documentation for your specific setup
  • Explore Jellyseerr API for custom integrations

For families, roommates, or any shared media environment, Jellyseerr is the missing piece that makes self-hosted streaming competitive with commercial services. Your users get the convenience of Netflix requests, while you maintain the privacy and control of self-hosting.

Additional Resources

Official Documentation

Community Resources

Document Version: 1.0 Last Updated: December 16, 2025 Word Count: ~5,400 words