When Family Stops Texting You About Missing Movies
You’ve got Sonarr auto-grabbing shows, Radarr hunting movies, and a media server humming along in your basement. Life is good. Then your partner says: “Hey, can you add that new sci-fi thing?”
And you’re staring at SSH, database schemas, and API keys. Your 2 AM self is not pleased.
This is where a request UI comes in. A friendly web interface that lets non-technical people ask for content instead of bugging you directly. It’s the difference between being a sysadmin and being a household hero.
Two main contenders exist: Overseerr (Plex-only, polished, the original) and Jellyseerr (a community fork that added Jellyfin and Emby support). Both feed requests into your *arr stack. The question is: which one fits your media server?
The *Arr Stack Needs a Frontend
Quick context if you’re new here: Sonarr and Radarr are the workhorses. They monitor RSS feeds, find torrents or Usenet articles, and hand them off to your downloader (qBittorrent, sabnzbd, whatever). But they’re not user-friendly. They’re APIs and databases. Your mom shouldn’t have to touch them.
That’s where Overseerr or Jellyseerr lives—between your family and your download infrastructure. It’s a request aggregator: your sister wants The Expanse season 6, she clicks a button, it goes into a queue, you (or automatic approval rules) greenlights it, and Sonarr/Radarr takes it from there.
Think of it like a mailroom. People drop requests in the mailbox (the web UI), they pile up, and then the mail sorter (Sonarr/Radarr) distributes them to the right departments (your indexers, your downloaders). Without the mailroom, everyone’s just yelling at you directly.
Overseerr: The Plex-Native Original
Overseerr is the OG. It was built for Plex. If Plex is your media server, Overseerr feels native—like it was designed for you specifically.
The good:
- Plex OAuth/SSO: Login with your Plex account. Your users are already in Plex; Overseerr just mirrors that. Dead simple.
- Plex library integration: It knows what you already have. No duplicate requests for content that’s sitting in your library right now.
- Polished UI: It’s had a few years to mature. The design is clean, responsive, the UX is thoughtful.
- Smaller ecosystem: Plex has a smaller, tighter user base. The project is focused.
- Active maintenance: The community is engaged. It gets security patches and features regularly.
The catch:
- Plex only: This is the whole story. If you’re running Jellyfin or Emby, Overseerr doesn’t authenticate against them. You can still use it (the API integrations work), but you lose the automatic user sync. You’re manually adding users, managing permissions—back to the sysadmin hole.
How auth works: Overseerr trusts your Plex token. You connect it to your Plex server, it reads your user list, and boom—everyone who’s on your Plex share can log into Overseerr. It’s managed by your Plex admin account. No separate password database.
# Overseerr in Docker (simplified)overseerr: image: sctx/overseerr:latest ports: - "5055:5055" environment: LOG_LEVEL: info volumes: - ./config:/app/config restart: unless-stoppedFirst run, you’ll hit the web UI, authenticate with your Plex account, and it pulls your server info automatically.
Jellyseerr: The Fork That Went Wider
Jellyseerr is a community fork of Overseerr that does one crucial thing differently: it supports Jellyfin and Emby in addition to Plex.
The good:
- Multi-server: If you’ve ditched Plex for Jellyfin (open source, no phone-home, no subscription drama), Jellyseerr still works. Same for Emby.
- Feature parity: It’s not a stripped-down knockoff. Nearly everything Overseerr does, Jellyseerr does.
- Active development: Community maintains it. Security patches flow regularly.
- Jellyfin native auth: Jellyseerr can authenticate against Jellyfin users directly. Your Jellyfin login is your Jellyseerr login.
The catch:
- It’s a fork: Forks have a shelf life. The Overseerr maintainers could introduce features Jellyseerr takes time to catch up on. Conversely, Jellyseerr might diverge in ways that break compatibility.
- Slightly smaller community: More niche than Overseerr. Fewer Stack Overflow answers when something breaks at 3 AM.
- Jellyfin’s own ecosystem chaos: Jellyfin is open source and decentralized. Auth, APIs, database schemas shift. Jellyseerr has to keep up with that churn.
How auth works: If you’re on Jellyfin, Jellyseerr talks to your Jellyfin instance directly. Your Jellyfin users are your Jellyseerr users. No token nonsense. Just your existing user database.
# Jellyseerr in Docker (simplified)jellyseerr: image: fallenbagel/jellyseerr:latest ports: - "5055:5055" environment: LOG_LEVEL: info volumes: - ./config:/app/config restart: unless-stoppedDuring setup, you’ll point it at your Jellyfin server URL and give it admin credentials. It syncs users from there.
Decision Tree: Which One Picks You?
Running Plex? → Overseerr. It’s home field. OAuth, library sync, no friction.
Running Jellyfin and married to open source? → Jellyseerr. It’s your only option with native auth. Overseerr will technically work if you manually add users, but that defeats the point.
Running Emby? → Jellyseerr. Overseerr doesn’t support it.
Running multiple servers (Plex + Jellyfin)? → Jellyseerr can do it, but it’s one instance per server. You’d need two Jellyseerr installations if you want both to talk to their respective backends. Overseerr can’t bridge that gap at all.
Integration with Sonarr and Radarr
Both Overseerr and Jellyseerr talk to Sonarr and Radarr the same way: API keys.
Log into each *arr app, generate an API key (Settings → General, or in Radarr/Sonarr settings), then paste it into Overseerr/Jellyseerr:
Overseerr/Jellyseerr settings: Sonarr: Host: http://sonarr:8989 API Key: [your-sonarr-api-key] Quality Profile: "1080p" (or whatever you named it)
Radarr: Host: http://radarr:7878 API Key: [your-radarr-api-key] Quality Profile: "1080p"Both apps will then:
- Check if the requested content already exists in your library (Plex/Jellyfin)
- Submit the request to Sonarr/Radarr
- Queue it for download based on your rules
Quality profiles matter. When someone requests a show, Overseerr/Jellyseerr picks a quality profile (4K, 1080p, whatever). You set this per-app. A request for The Expanse will grab 1080p WEB-DL if that’s your Sonarr profile, not some crusty 480p rip.
Approval Workflows and Automation
You can go two ways:
1. Auto-approve everything (chaos mode)
Settings → Requests → Auto-approve: ✓ Enable auto-approval for TV ✓ Enable auto-approval for MoviesUseful if it’s just your household and you trust everyone. Requests become downloads immediately.
2. Require approval (sane mode) Leave auto-approve off. Requests sit in a queue. You review them (via the UI, or notifications—more on that in a sec), and click “Approve” when it makes sense. Overseerr/Jellyseerr then submits to Sonarr/Radarr.
You can also set rules like “auto-approve if request is from admin” or “auto-approve if it already exists on disk.”
Notifications: Keeping Requests Visible
Notifications tell you when a request lands, gets approved, or finishes downloading.
Both apps support:
- Discord: Hook it up and get pinged in a channel.
- Email: SMTP config, and you’re notified.
- ntfy.sh: Free, no-auth push notifications. Pair it with your phone.
- Webhook: If you want to integrate with your own automation.
Example Discord setup:
Settings → Notifications → Discord: Webhook URL: [your-discord-webhook-url] Notification types: ✓ Request submitted ✓ Request approved/denied ✓ Available (when download completes)Your household can see real-time status. “Your request is being downloaded.” “It’s here!” No more “is this done yet?” messages.
Docker Compose Example
Here’s a minimal setup with Overseerr + Sonarr + Radarr (Jellyseerr would be the same, just swap the image):
version: '3.8'
services: overseerr: image: sctx/overseerr:latest container_name: overseerr ports: - "5055:5055" environment: LOG_LEVEL: info TZ: America/New_York volumes: - ./overseerr_config:/app/config restart: unless-stopped
sonarr: image: lscr.io/linuxserver/sonarr:latest container_name: sonarr ports: - "8989:8989" environment: PUID: 1000 PGID: 1000 TZ: America/New_York volumes: - ./sonarr_config:/config - /mnt/media/tv:/tv - /mnt/downloads:/downloads restart: unless-stopped
radarr: image: lscr.io/linuxserver/radarr:latest container_name: radarr ports: - "7878:7878" environment: PUID: 1000 PGID: 1000 TZ: America/New_York volumes: - ./radarr_config:/config - /mnt/media/movies:/movies - /mnt/downloads:/downloads restart: unless-stoppedSpin this up:
docker-compose up -dThen:
- Hit
http://localhost:8989(Sonarr), set up your indexers and downloader - Hit
http://localhost:7878(Radarr), same story - Hit
http://localhost:5055(Overseerr), authenticate with Plex, link Sonarr/Radarr APIs - Tell your family the URL and let them go nuts
Reverse Proxy and HTTPS
Running this behind a reverse proxy? (You should be.)
Caddy example:
seerr.your-domain.com { reverse_proxy localhost:5055}Both apps handle proxies fine. Just make sure:
- Base path is set correctly (if you’re proxying at
/overseerr/, config that in the UI) - HTTPS works (Caddy handles this automatically)
- Your Plex server can see the Overseerr callback URL (for OAuth)
Plex OAuth gotcha: If Overseerr is behind HTTPS and your Plex account is authenticating from the internet, Plex needs to redirect back to your URL. Make sure your reverse proxy’s public domain is reachable from outside your network (or at least, accessible where your users will be logging in from).
Common Gotchas
1. Plex token rotation Your Plex token (the auth credential Overseerr uses) can expire or rotate. If logins suddenly fail, go to Overseerr → Settings → Plex Server, re-authenticate. Takes 30 seconds.
2. Base path confusion
If you’re proxying at /overseerr/ instead of a subdomain, you need to set this in the UI (Settings → General → Base URL). Otherwise, CSS and JS load from the wrong paths and the UI looks broken.
3. Jellyfin user sync lag Jellyseerr caches user lists. If you add a new Jellyfin user, they might not show up in Jellyseerr immediately. Restart the container or wait for the sync interval to refresh.
4. Sonarr/Radarr API mismatches
Make sure your Sonarr and Radarr versions match what Overseerr/Jellyseerr expects. Older versions (pre-v3) have different APIs. If requests fail silently, check the logs: docker logs overseerr.
5. Certificate headaches If Sonarr/Radarr are HTTPS (self-signed certs), Overseerr/Jellyseerr might refuse the connection due to cert validation. You can disable cert checks in Docker (not recommended for prod), or use proper certificates.
The Fork Reality
Here’s the honest bit: Jellyseerr is a fork. Forks are maintained by volunteers who also have day jobs. Overseerr is the upstream, and Jellyseerr has to keep pace.
Most of the time, it’s fine. Security patches flow. Features get backported. But if Overseerr introduces some radical change to authentication or database schema, Jellyseerr might lag a few weeks.
This isn’t a deal-breaker—just reality. If you’re on Jellyfin, you don’t have a choice anyway. If you’re on Plex, you could jump to Overseerr at any time. Consider it low-risk.
Pick the Seerr That Matches Your Server
Overseerr if you’re Plex. Dead simple, Plex-native, polished, one less thing to think about.
Jellyseerr if you’re Jellyfin or Emby, or if you want a UI that could support multiple servers down the line.
Either way, you’ve solved the “Mom, can you add X?” problem. Your family gets a friendly web UI. You get your sanity back. Everyone wins.
Set up notifications so you know when things are approved and ready. Tweak your quality profiles so downloads meet your standards. And then step back and let the *arr stack do what it does best: feed your media addiction without you lifting a finger.
Your 2 AM self thanks you.
