Deploying Jellyseerr

Introduction

Jellyseerr is a free and open-source media request management application for your Jellyfin media server. As a fork of Overseerr designed specifically for Jellyfin integration, Jellyseerr allows users to browse media, request movies and TV shows, and have those requests automatically fulfilled through integration with Sonarr and Radarr.

Built with Next.js and TypeScript, Jellyseerr provides a beautiful, responsive interface for discovering and requesting media content. The application handles request workflows, approval processes, and communicates with download managers to automatically add approved content to your media library.

Key highlights of Jellyseerr:

Media Discovery: Browse trending, popular, and upcoming movies and TV shows
Request System: Users can request content with an intuitive interface
Jellyfin Integration: Native support for Jellyfin media server
Sonarr/Radarr Integration: Automatic request fulfillment
User Management: Multiple users with different permission levels
Request Approval: Optional approval workflow for requests
Notifications: Discord, Slack, email, and other notification options
Issue Reporting: Users can report problems with media
Availability Checking: Shows what’s already in your library
Mobile Friendly: Responsive design for all devices
Open Source: Actively maintained community project

This guide walks through deploying Jellyseerr on Klutch.sh using Docker, configuring media server integration, and setting up request workflows.

Why Deploy Jellyseerr on Klutch.sh

Deploying Jellyseerr on Klutch.sh provides several advantages for media request management:

Simplified Deployment: Klutch.sh automatically builds and deploys your Jellyseerr container without complex configuration.

Persistent Storage: Attach persistent volumes for configuration and database. Your settings survive restarts.

HTTPS by Default: Klutch.sh provides automatic SSL certificates for secure access.

GitHub Integration: Connect your configuration repository for automated deployments.

Scalable Resources: Allocate CPU and memory based on user count and traffic.

Environment Variable Management: Securely store API keys and configuration.

Custom Domains: Assign a custom domain for your request portal.

Always-On Availability: Your request system remains accessible 24/7.

Prerequisites

Before deploying Jellyseerr on Klutch.sh, ensure you have:

A Klutch.sh account
A GitHub account with a repository for your Jellyseerr configuration
An existing Jellyfin media server
(Optional) Sonarr and/or Radarr for automated downloads
Basic familiarity with Docker and containerization concepts
(Optional) A custom domain for your Jellyseerr instance

Understanding Jellyseerr Architecture

Jellyseerr connects multiple services:

Next.js Application: The core web application handling UI and business logic.

SQLite Database: Stores users, requests, settings, and media metadata.

Jellyfin API: Communicates with your media server for library data and authentication.

Sonarr/Radarr API: Sends approved requests for automatic download.

TMDb API: Fetches media metadata, posters, and information.

Preparing Your Repository

Repository Structure

jellyseerr-deploy/
├── Dockerfile
├── README.md
└── .dockerignore

Creating the Dockerfile

FROM fallenbagel/jellyseerr:latest

# Environment configuration
ENV LOG_LEVEL=info
ENV TZ=UTC

# Expose the web interface port
EXPOSE 5055

# Health check
HEALTHCHECK --interval=30s --timeout=10s --start-period=60s --retries=3 \
  CMD wget --no-verbose --tries=1 --spider http://localhost:5055/api/v1/status || exit 1

Creating the .dockerignore File

.git
.github
*.md
LICENSE
.gitignore
*.log
.DS_Store
.env
.env.local

Environment Variables Reference

Variable	Required	Default	Description
`LOG_LEVEL`	No	info	Logging verbosity (debug, info, warn, error)
`TZ`	No	UTC	Timezone for the application
`PORT`	No	5055	Port for the web interface

Deploying Jellyseerr on Klutch.sh

Push Your Repository to GitHub

Initialize your repository and push to GitHub:

git init
git add Dockerfile .dockerignore README.md
git commit -m "Initial Jellyseerr deployment configuration"
git remote add origin https://github.com/yourusername/jellyseerr-deploy.git
git push -u origin main

Create a New Project on Klutch.sh

Navigate to the Klutch.sh dashboard and create a new project. Give it a descriptive name like “jellyseerr” or “media-requests”.

Create a New App

Within your project, create a new app:

Connect your GitHub repository
Select the repository containing your Dockerfile
Configure HTTP traffic on port 5055

Set Environment Variables

Configure optional environment variables:

Variable	Value
`LOG_LEVEL`	`info`
`TZ`	`America/New_York` (or your timezone)

Attach Persistent Volumes

Add persistent storage for Jellyseerr data:

Mount Path	Recommended Size	Purpose
`/app/config`	5 GB	Configuration, database, and cache

Deploy Your Application

Click Deploy to start the build process.

Access Jellyseerr

Once deployment completes, access your Jellyseerr instance at https://your-app-name.klutch.sh.

Initial Configuration

Setup Wizard

On first access, complete the setup wizard:

Sign in with Jellyfin: Connect to your Jellyfin server
Configure Jellyfin: Enter server URL and authenticate
Import Users: Optionally import existing Jellyfin users
Configure Services: Set up Radarr and Sonarr (optional)
Complete Setup: Finish initial configuration

Connecting Jellyfin

Configure your Jellyfin server:

Enter your Jellyfin server URL
Provide admin credentials or API key
Select which libraries to sync
Enable automatic library syncing

Configuring Radarr (Movies)

Add Radarr for movie request automation:

Navigate to Settings > Services
Add a Radarr server
Enter Radarr URL and API key
Select default quality profile
Configure root folder
Enable as default for movie requests

Configuring Sonarr (TV Shows)

Add Sonarr for TV show request automation:

Navigate to Settings > Services
Add a Sonarr server
Enter Sonarr URL and API key
Select quality profile and root folder
Configure season folders and monitoring
Enable as default for TV requests

User Management

User Permissions

Configure user access levels:

Permission	Description
Request	Can submit media requests
Auto-Approve	Requests are automatically approved
Manage Users	Can manage other user accounts
Manage Requests	Can approve/deny requests
Admin	Full access to all settings

Creating Users

Add users manually or import from Jellyfin:

Navigate to Users section
Click “Create Local User” or “Import from Jellyfin”
Set username and permissions
Configure quota limits if desired

User Quotas

Limit requests per user:

Edit user settings
Set movie request quota (per week/month)
Set TV request quota
Enable/disable quota

Request Workflow

Submitting Requests

Users request media through:

Search for a movie or TV show
View details and availability
Click “Request”
For TV shows, select seasons
Submit request

Approval Process

Handle incoming requests:

View pending requests in the admin panel
Review request details
Approve or decline with optional message
Approved requests are sent to Radarr/Sonarr

Automatic Approval

Configure auto-approval:

Grant “Auto-Approve” permission to trusted users
Requests bypass the approval queue
Immediately sent to download managers

Notifications

Configuring Notifications

Set up notification channels:

Navigate to Settings > Notifications
Add notification agents:
- Discord webhooks
- Slack webhooks
- Email (SMTP)
- Telegram
- Pushover
- And more

Notification Events

Choose which events trigger notifications:

New request submitted
Request approved/declined
Media available
Issue reported

Discord Integration

Example Discord webhook setup:

Create a webhook in your Discord server
Add Discord agent in Jellyseerr
Paste webhook URL
Configure message format
Select events to notify

Production Best Practices

Security Recommendations

Strong Passwords: Enforce strong admin passwords
Permission Control: Grant minimal necessary permissions
Rate Limiting: Prevent request spam with quotas
HTTPS Only: Always use HTTPS (handled by Klutch.sh)
Regular Updates: Keep Jellyseerr updated

Performance Optimization

Library Sync: Schedule syncs during off-peak hours
Cache Settings: Adjust metadata cache duration
Resource Allocation: Scale based on user count

Backup Strategy

Configuration Backup: Back up the config volume
Database: SQLite database in config folder
Settings Export: Document integration settings

Troubleshooting Common Issues

Jellyfin Connection Issues

Symptoms: Cannot connect to Jellyfin server.

Solutions:

Verify Jellyfin URL is correct
Check network connectivity
Ensure Jellyfin is accessible from Klutch.sh
Verify API key or credentials

Requests Not Sending

Symptoms: Approved requests don’t appear in Radarr/Sonarr.

Solutions:

Verify Radarr/Sonarr connection settings
Check API key validity
Review Jellyseerr logs for errors
Ensure network connectivity between services

Media Not Showing as Available

Symptoms: Library items show as not available.

Solutions:

Trigger a library sync in settings
Check library configuration
Verify media has correct metadata
Wait for sync to complete

Additional Resources

Conclusion

Deploying Jellyseerr on Klutch.sh provides a beautiful, user-friendly media request system for your Jellyfin server. The combination of Jellyseerr’s intuitive interface and Klutch.sh’s reliable hosting enables family members and friends to easily request content.

With integration to Radarr and Sonarr for automated fulfillment, notification support, and user management, Jellyseerr on Klutch.sh delivers everything needed for a professional-grade media request experience.