Seerr Setup for Plex or Jellyfin, Sonarr, and Radarr

Rights, lawful use, and scope: This guide is for private administration of media requests for media you own or are authorized to use. It is not legal advice and it is not a guide to acquiring, sharing, or processing copyrighted works without permission. A request in Seerr is only user intent; it is not proof that the media may be obtained or stored.

Quick Answer

Run Seerr from its signed official Docker image with /app/config on persistent local storage. Connect either Plex or Jellyfin first, then add Sonarr and Radarr with deliberate root folders, profiles, tags, and manual approval. Prove one authorized movie request and one show request from a non-admin account, then back up and restore the config. A healthy container does not prove request routing, import, library availability, or least-privilege access.

Safe default: Keep Seerr LAN-only, VPN-only, or behind a trusted HTTPS reverse proxy with authentication while you build it. Do not expose Seerr publicly before admin roles, user permissions, rate limits, request approval rules, and backups are proven.

Evidence status: This revision was checked against current Seerr documentation and release records on August 24, 2026. Seerr v3.4.1 is the current stable GitHub release, Docker remains the recommended installation method, and source builds remain advanced. TechGeeks did not deploy Seerr, submit a request, capture a screenshot, update a container, or restore a backup. Every command, output, and success state below is an unperformed example or planned acceptance test.

Seerr is the request desk for a media homelab. It lets approved users discover library availability and ask for a movie or show. Sonarr and Radarr remain the systems of record for quality, root folders, imports, and upgrades. Plex, Jellyfin, or Emby remains the playback and final-availability authority.

Where Seerr Fits

Seerr belongs before Sonarr and Radarr in the workflow. A user searches or browses Seerr, places a request, and Seerr applies permission and approval rules. Only after approval should Seerr route the item to the correct Radarr or Sonarr instance with the correct root folder, quality profile, tags, and search behavior.

1. 1. Discover User Browse

   An approved user finds a movie, show, or season in Seerr. This is a request surface, not a source of rights.

2. 2. Request Movie or Seasons

   The user requests a movie, a whole show, or selected seasons. The request should carry intent, not automatic approval.

3. 3. Gate Permissions

   Roles, quotas, watchlists, blocklists, request rules, and content boundaries decide what needs review.

4. 4. Approve Admin Review

   The operator approves, declines, or adjusts the destination, quality profile, root folder, tags, or search behavior.

5. 5. Route Radarr or Sonarr

   Approved movies go to Radarr; approved shows go to Sonarr. Those apps remain responsible for quality and imports.

6. 6. Track Library Sync

   Seerr syncs against Plex, Jellyfin, or Emby so it can show whether requested media is already available.

7. 7. Notify User Update

   When the media server sees the item, Seerr can notify the requester through the configured notification agents.

Requests are intent

A request means someone wants something. It does not grant copyright rights or override your sourcing policy.

Search after approval

For a new setup, approve manually and verify routing before broad auto-search behavior.

Public edge needs protection

If household users reach Seerr remotely, put it behind HTTPS, strong authentication, and least-privilege roles.

The App Ownership Model

Layer	Owner	Beginner Explanation	Operator Check
Request intake	Seerr	Users request movies or shows and see availability.	Roles, request limits, approval rules, and notification settings are deliberate.
Movie decisions	Radarr	Radarr decides movie quality, root folder, upgrades, and imports.	The Seerr movie service points to the right Radarr URL, API key, profile, tags, and root folder.
TV decisions	Sonarr	Sonarr decides show monitoring, seasons, episodes, quality, and imports.	The Seerr TV service points to the right Sonarr URL, API key, profile, language, tags, and root folder.
Source management	Prowlarr	Prowlarr manages lawful indexer definitions for the Arr apps.	Seerr should not bypass your Arr rules by becoming a second decision engine.
Playback availability	Plex, Jellyfin, or Emby	The media server shows whether a title is available.	Seerr library sync sees the same final libraries users see.
File optimization	Tdarr	Tdarr may optimize after import.	Radarr/Sonarr and Plex rescans stay current after file replacement.

Who This Is For

• A homelab operator who already has Plex, Jellyfin, or Emby running.
• Someone with working Radarr and Sonarr root folders, quality profiles, imports, and API keys.
• A household or small group that needs a controlled request portal instead of text messages or manual spreadsheets.
• An operator who wants a Docker-first deployment with persistent state, logs, backups, and explicit rollback.
• An advanced operator who may need the preserved source-build appendix after reviewing its maintenance burden.

Before You Start: Safe Defaults

Decision	Recommended Starting Point	Why It Matters
Access	LAN, VPN, or trusted reverse proxy only	Seerr exposes request history, user identities, app integrations, and admin controls.
Auto-approval	Off for the first test	Manual approval proves routing before users fill queues.
Search on approval	Off until root/profile rules are proven	A bad root folder or wrong profile can create noisy queues quickly.
Movie routing	One main Radarr root first	Add animated, comedy, 4K, or special roots only after the basic path works.
TV routing	One main Sonarr root first	Whole-show requests can become large; prove one season first.
Admin accounts	Separate admin from requester users	Least privilege keeps a request portal from becoming an Arr admin surface.
Backups	Back up Ombi, existing request tools, Seerr config, and service files	Request data and integration settings are small but rebuild-critical.

Terms You Need Before Clicking Around

Term	Plain-English Meaning	Where It Matters
Request	A user asks for a movie, show, or season.	Seerr approvals and notifications.
Approval	An admin decision to accept, decline, or modify a request.	Prevents uncontrolled adds.
Availability	The media server already has the item and can show it to users.	Seerr library sync.
Root folder	The final library destination used by Radarr or Sonarr.	Wrong roots create messy libraries.
Quality profile	The allowed quality lane and cutoff rules.	Seerr must pick the right Radarr/Sonarr default.
Tags	Labels used to mark or route items.	Useful for list-vs-request audits and custom rules.
API key	A secret that lets Seerr talk to Radarr or Sonarr.	Never paste real keys into public posts or screenshots.
Watchlist	A user list that may create high-intent requests.	Useful only after approval and routing rules are proven.
Blocklist	Media intentionally excluded from request workflows.	Prevents recurring requests for unwanted items.

Install Seerr with Docker Compose

The current official guide recommends Docker for most users. It documents ghcr.io/seerr-team/seerr, persistent /app/config storage, UID 1000 for the image's node user, init: true, port 5055, and the public-settings health check. Official images are signed and include a Software Bill of Materials. This example pins the stable v3.4.1 tag checked on August 24, 2026; recheck the release page before deploying.

Example configuration (not performed in a TechGeeks lab):

services:
  seerr:
    image: ghcr.io/seerr-team/seerr:v3.4.1
    container_name: seerr
    init: true
    environment:
      LOG_LEVEL: info
      TZ: Etc/UTC
      PORT: "5055"
    ports:
      - "127.0.0.1:5055:5055"
    volumes:
      - /opt/seerr/config:/app/config
    healthcheck:
      test: ["CMD-SHELL", "wget --no-verbose --tries=1 --spider http://localhost:5055/api/v1/settings/public || exit 1"]
      start_period: 20s
      timeout: 3s
      interval: 15s
      retries: 3
    restart: unless-stopped

The localhost binding assumes a reverse proxy or SSH tunnel on the same host. For direct LAN access, bind to a specific trusted LAN address instead of every interface, or publish 5055:5055 only after host and network firewall rules restrict the source network.

Example commands (not performed):

sudo install -d -o "$USER" -g "$(id -gn)" -m 0750 /opt/seerr
sudo install -d -o 1000 -g 1000 -m 0750 /opt/seerr/config
cd /opt/seerr
docker compose config --quiet
docker compose pull seerr
docker compose up -d
docker compose ps seerr
docker image inspect ghcr.io/seerr-team/seerr:v3.4.1 \
  --format '{{index .RepoDigests 0}}'

Example expected output (not observed):

NAME    IMAGE                                  STATUS
seerr   ghcr.io/seerr-team/seerr:v3.4.1        Up ... (healthy)

ghcr.io/seerr-team/seerr@sha256:<ARCHITECTURE_SPECIFIC_DIGEST>

Record the actual digest from the host; do not paste the placeholder into Compose. The stable tag identifies the intended application release, while the recorded digest identifies the exact architecture-specific image pulled for rollback.

Verify the Container and Persistent State

Example commands (not performed):

docker compose ps seerr
docker compose logs --tail=100 seerr
curl -fsS http://127.0.0.1:5055/api/v1/settings/public >/dev/null
test -d /opt/seerr/config/db
docker compose restart seerr
docker compose ps seerr

Example expected result (not observed): the container returns to healthy, the public-settings endpoint exits 0, and /opt/seerr/config remains populated after restart. This establishes process health and persistence only. It does not establish media-server sync, requester permissions, Arr handoff, import, or restore.

Advanced Appendix: Native Ubuntu Source Build

The source path below is preserved for operators who intentionally accept application build, Node.js, pnpm, systemd, and database-migration ownership. Upstream labels source builds advanced. Reconcile every prerequisite with the exact release tag before use; none of the source commands or outputs were run for this revision.

Host binding warning: The example below binds Seerr to 127.0.0.1 for safety. If you change HOST to 0.0.0.0, Seerr listens on all interfaces. Only do that when host firewall, VPN, or reverse-proxy controls are already in place.

Preflight the Ubuntu Host

Advanced-path example commands (not performed):

lsb_release -a
uname -a
df -h /
ss -ltnp | grep -E ':5055|:7878|:8989' || true
systemctl is-active postgresql redis-server || true

Example expected result (not observed): the commands identify the Ubuntu release, available disk space, existing listeners, and relevant service state without changing the host. Record the real values privately. If Ombi is still installed, back it up and leave it restorable until Seerr is fully tested.

Install Node.js 22, pnpm, and Build Tools

Advanced-path example commands (not performed; reconcile with the selected release):

sudo install -d -m 0755 /etc/apt/keyrings

curl -fsSL https://deb.nodesource.com/gpgkey/nodesource-repo.gpg.key \
  | sudo gpg --dearmor -o /etc/apt/keyrings/nodesource.gpg

NODE_REPO="deb [signed-by=/etc/apt/keyrings/nodesource.gpg]"
NODE_REPO="$NODE_REPO https://deb.nodesource.com/node_22.x nodistro main"

printf '%s\n' "$NODE_REPO" \
  | sudo tee /etc/apt/sources.list.d/nodesource.list >/dev/null

sudo apt-get update

sudo apt-get install -y \
  ca-certificates \
  curl \
  git \
  build-essential \
  python3 \
  pkg-config \
  nodejs

sudo corepack enable
corepack prepare pnpm@10.24.0 --activate

node -v
pnpm -v

Create the Seerr User and Paths

Advanced-path example commands (not performed):

sudo useradd --system \
  --home-dir /opt/seerr-src \
  --shell /usr/sbin/nologin \
  seerr 2>/dev/null || true

sudo install -d -m 0755 /opt
sudo install -d -m 0750 -o seerr -g seerr /etc/seerr
sudo install -d -m 0750 -o seerr -g seerr /etc/seerr/config

The source tree lives in /opt/seerr-src. Runtime configuration lives in /etc/seerr. The separate path also prevents this advanced procedure from colliding with the primary Docker install at /opt/seerr. Backups should clearly include the secret-bearing config path.

Clone, Install, and Build Seerr

Advanced-path example commands (not performed; pin and review a release before use):

SEERR_SRC=/opt/seerr-src
test ! -e "$SEERR_SRC" || {
  printf 'refusing to replace existing path: %s\n' "$SEERR_SRC" >&2
  exit 1
}
sudo git clone --branch v3.4.1 --depth 1 https://github.com/seerr-team/seerr.git "$SEERR_SRC"
sudo chown -R seerr:seerr "$SEERR_SRC"

cd "$SEERR_SRC"
sudo -u seerr HUSKY=0 CYPRESS_INSTALL_BINARY=0 pnpm install --frozen-lockfile
sudo -u seerr pnpm build

sudo -u seerr git rev-parse --short=12 HEAD

Record the exact tag and commit you built. The example pins the rechecked stable release rather than tracking main. Capture the commit, Node version, pnpm version, and build date in restore notes.

Create the Seerr Environment File

Advanced-path example configuration commands (not performed):

sudo tee /etc/seerr/seerr.conf >/dev/null <<'EOF'
PORT=5055
HOST=127.0.0.1
NODE_ENV=production
DB_TYPE=sqlite
CONFIG_DIRECTORY=/etc/seerr/config
LOG_LEVEL=info
EOF

sudo chown root:seerr /etc/seerr/seerr.conf
sudo chmod 0640 /etc/seerr/seerr.conf

SQLite is fine for many homelabs and is the simplest first install. Seerr also supports PostgreSQL. If you expect a busier request portal or want database consistency with the rest of your stack, plan PostgreSQL deliberately and back it up with dumps, not raw file copies.

Create the systemd Service

Advanced-path example service configuration (not performed):

sudo tee /etc/systemd/system/seerr.service >/dev/null <<'EOF'
[Unit]
Description=Seerr Service
Wants=network-online.target
After=network-online.target

[Service]
User=seerr
Group=seerr
EnvironmentFile=/etc/seerr/seerr.conf
Environment=NODE_ENV=production
Type=exec
Restart=on-failure
RestartSec=10
WorkingDirectory=/opt/seerr-src
ExecStart=/usr/bin/node /opt/seerr-src/dist/index.js
UMask=0027

[Install]
WantedBy=multi-user.target
EOF

sudo systemctl daemon-reload
sudo systemctl enable --now seerr

Verify Seerr Starts Cleanly

Advanced-path example validation commands (not performed):

systemctl status seerr --no-pager
journalctl -u seerr -n 100 --no-pager
curl -fsS http://127.0.0.1:5055/api/v1/settings/public

Example expected result (not observed): the service is active, logs do not show database or permission errors, and the public settings endpoint responds locally. Do not move on to user onboarding until this basic health check works after a reboot.

First-Run Setup

1. Open Seerr through the intended local tunnel, VPN, LAN hostname, or protected reverse proxy.
2. Create the first owner account and store its recovery details privately.
3. Connect one media server first: Plex or Jellyfin. Add Emby only when it is part of the actual environment.
4. Run a library sync and confirm already-available synthetic or non-sensitive titles are represented correctly.
5. Add Radarr and Sonarr through private service URLs.
6. Choose one root folder, one balanced profile, a request-source tag, and manual approval for the first test.
7. Create a separate requester account without Seerr administration or media-server administration.
8. Leave broad auto-approval, watchlist automation, and automatic search disabled until controlled requests pass.

Plex and Jellyfin Are Equal Setup Paths

Check	Plex path	Jellyfin path
Connection identity	Use the supported Plex sign-in/token flow and keep the resulting token private.	Use a dedicated Jellyfin integration identity or supported API credential with no unrelated admin use.
Server address	Prefer a private URL reachable from the Seerr container.	Prefer a private URL reachable from the Seerr container.
Library proof	Confirm one known movie and one show already in Plex appear as available.	Confirm one known movie and one show already in Jellyfin appear as available.
Requester account	A Plex viewer does not need Plex server administration to request through Seerr.	A Jellyfin viewer does not need Jellyfin server administration to request through Seerr.
Removal test	Revoking request rights must block a new request without changing Plex playback rights.	Revoking request rights must block a new request without changing Jellyfin playback rights.

Request rights and media-server administration are separate controls. A requester needs only the Seerr permissions required for the approved request classes and limits. They do not need access to Jellyfin Dashboard, Plex server settings, Sonarr, Radarr, API keys, root folders, or approval controls. Test this with the requester account, not the owner account.

Connect Radarr and Sonarr Carefully

Setting	Radarr Guidance	Sonarr Guidance
URL	http://radarr:7878 on a shared private Compose network, or a private host/LAN URL reachable from Seerr	http://sonarr:8989 on a shared private Compose network, or a private host/LAN URL reachable from Seerr
API key	Copy from Radarr settings and store only in Seerr.	Copy from Sonarr settings and store only in Seerr.
Root folder	Start with the main movies root.	Start with the main TV root.
Quality profile	Use your default balanced movie profile.	Use your default balanced TV profile.
Tags	Add a seerr-request tag if you audit intake sources.	Add a seerr-request tag if you audit intake sources.
Search on add	Start disabled or manual.	Start disabled or manual.
4K/special roots	Add later after basic routing works.	Add later only if you intentionally run separate libraries/profiles.

In this Docker pattern, 127.0.0.1 inside Seerr means the Seerr container itself, not Radarr or Sonarr. Use loopback only for a native same-host service or an intentionally shared host network. Run each integration's built-in connection test before saving, then prove the handoff with a manually approved synthetic request.

Request Policy That Does Not Create Chaos

1. 1. Role Who Can Request?

   Separate admin, trusted requester, and limited requester roles. A user should not get admin power just to request media.

2. 2. Scope What Can Be Requested?

   Use permissions, quotas, and blocklists to keep requests aligned with your library purpose and rights scope.

3. 3. Destination Where Does It Go?

   Match movie, animated, comedy, TV, or 4K destinations before enabling automatic adds.

4. 4. Profile Which Quality Rules?

   Choose Radarr/Sonarr profiles that match your storage, audio, subtitle, and codec strategy.

5. 5. Search When Does It Search?

   Start with manual search or approval search. Turn on broad search only after several correct requests.

6. 6. Notify Who Gets Updates?

   Send notifications to requesters without exposing admin logs, private URLs, or API errors.

Approval is a control point

Approval is where you can prevent wrong roots, wrong profiles, and unsupported requests.

Do not publish secrets

Screenshots should hide Plex tokens, Arr API keys, request history, usernames, and private hostnames.

Validation: One Safe End-to-End Test

Planned acceptance test, not performed: use synthetic user names and media that TechGeeks owns, created, or is licensed to test. Run the same workflow once with a Jellyfin-backed Seerr configuration and once with a Plex-backed configuration; do not imply that one passing path proves the other.

1. Record Seerr, media-server, Sonarr, and Radarr versions plus the container image digest.
2. Submit one movie and one selected-season request from the non-admin requester account.
3. Confirm the requester cannot approve the item, open administration, or alter service settings.
4. Approve manually and confirm the movie reaches Radarr and the show reaches Sonarr with the expected root, profile, tags, monitoring, and search state.
5. Follow the authorized acquisition/import workflow without changing the request to force a pass.
6. Confirm the intended media server scans the final path and the normal client can open the final item.
7. Confirm Seerr changes availability only after the media server reports the item.
8. Run a safe negative case with a disabled or deliberately mismatched test root, preserve the real failure, correct it, and collect a new artifact.

Migrate from Ombi Without Losing Your Exit

Treat Seerr as a replacement only after it works. Back up Ombi configuration and database first, document the existing service, and keep the old install stopped-but-restorable until users, request rules, notifications, and integrations are proven. Migration is not just app startup. It is policy parity.

Example Ombi discovery and backup commands (not performed; paths vary by installation):

sudo systemctl status ombi --no-pager || true
sudo systemctl cat ombi.service || true

sudo install -d -m 0750 /opt/app-backups/ombi-pre-seerr

sudo tar -C / -czf \
  /opt/app-backups/ombi-pre-seerr/etc-Ombi.tgz \
  etc/Ombi 2>/dev/null || true

sudo tar -C / -czf \
  /opt/app-backups/ombi-pre-seerr/opt-Ombi.tgz \
  opt/Ombi 2>/dev/null || true

Example expected result (not observed): the actual Ombi service definition is recorded and archives are created only for paths that exist. A successful archive is not restore proof; inspect it and rehearse restoration separately.

Backup privacy: Request databases may contain usernames, request titles, private URLs, notification targets, API keys, and household behavior. Store them on restricted or encrypted storage and sanitize anything used in screenshots or public examples.

Reverse Proxy and Access Design

Seerr can be household-facing, but it is still an app connected to your media server and Arr APIs. Use HTTPS, strong app authentication, reverse-proxy access lists where practical, and a firewall stance that does not publish every media admin app. App-to-app communication should usually use internal URLs. Users can reach Seerr through a friendly hostname, while Seerr reaches Radarr and Sonarr through private addresses.

1. 1. User Approved Requester

   A household user reaches only the Seerr request portal through HTTPS, VPN, or LAN.

2. 2. Proxy HTTPS Boundary

   The reverse proxy handles certificates, trusted headers, access lists, and logging.

3. 3. Seerr Request Portal

   Seerr authenticates users, enforces roles, and stores request state.

4. 4. Internal APIs Arr Services

   Radarr and Sonarr API calls use internal URLs and private API keys.

5. 5. Media Server Library Sync

   Plex, Jellyfin, or Emby availability is synced without exposing admin APIs broadly.

Seerr is not harmless

It can create requests, reveal private media interests, and hold integration secrets.

Keep admin apps private

Radarr, Sonarr, Prowlarr, SABnzbd, Tdarr, NAS, and proxy admin pages should stay LAN/VPN by default.

Backups

The official backup guide says to stop Seerr before copying the SQLite-backed config folder unless the backup mechanism provides a consistent filesystem snapshot or you use the SQLite CLI backup method. Preserve db/db.sqlite3 and settings.json; cache and logs are optional. PostgreSQL deployments need a database-aware dump plus the config. Backups contain request history, identities, server addresses, and secrets, so keep them restricted.

Example stopped-container backup (not performed):

cd /opt/seerr
sudo tar -tzf /var/backups/seerr/config-pre-update.tgz >/dev/null
docker compose stop seerr
sudo install -d -m 0700 /var/backups/seerr
sudo tar -C /opt/seerr -czf \
  /var/backups/seerr/config-pre-update.tgz config compose.yaml
sudo chmod 0600 /var/backups/seerr/config-pre-update.tgz
sudo sha256sum /var/backups/seerr/config-pre-update.tgz
docker compose start seerr

Example expected output (not observed):

<SHA256>  /var/backups/seerr/config-pre-update.tgz

A checksum proves which archive was copied; it does not prove the archive restores. Copy the archive off-host, then rehearse a restore in an isolated Compose project before relying on it.

Upgrade Routine

1. Read every release note between the installed and target versions.
2. Record the current tag, image digest, Compose file, config ownership, and backup checksum.
3. Stop the container and take a consistent config/database backup.
4. Change the Compose image to the reviewed stable tag and pull it.
5. Recreate the container and watch startup or migration logs.
6. Verify health, login, media-server sync, requester permissions, Radarr/Sonarr tests, request history, and notifications.
7. Keep the previous image and matched backup until the complete request path passes.

Example commands (not performed):

cd /opt/seerr
docker compose pull seerr
docker compose up -d seerr
docker compose ps seerr
docker compose logs --tail=150 seerr

Example expected result (not observed): the selected release image starts healthy without migration or permission errors. Treat Plex/Jellyfin sync and both Arr request paths as separate gates.

Rollback Routine

Do not point an older image at state that a newer release has migrated unless the release notes explicitly support that downgrade. Restore the matched pre-upgrade config/database into an isolated path, set Compose back to the recorded image tag or digest, start it, and repeat the acceptance tests. Preserve the failed state separately for diagnosis.

Example recovery commands (not performed):

cd /opt/seerr
docker compose stop seerr
FAILED_CONFIG="config.failed.$(date -u +%Y%m%dT%H%M%SZ)"
sudo mv -- config "$FAILED_CONFIG"
sudo tar -C /opt/seerr -xzf \
  /var/backups/seerr/config-pre-update.tgz config
sudo chown -R 1000:1000 config
# Set image: to the recorded prior tag or digest in compose.yaml.
docker compose up -d seerr
docker compose ps seerr
docker compose logs --tail=150 seerr

Example expected result (not observed): the prior image starts against its matched state and the owner can log in, see request history, sync the media server, and test both Arr connections. If restore fails, stop and retain both state trees; do not keep retrying destructive migrations.

Troubleshooting

Symptom	Likely Cause	What to Check
Seerr page will not load	Container down, wrong bind address, reverse proxy issue, or port conflict.	docker compose ps seerr, docker compose logs seerr, ss -ltnp, proxy target, and firewall rules. For the advanced source path, inspect its systemd unit instead.
Plex/Jellyfin/Emby sync fails	Wrong URL, token/API problem, TLS/proxy mismatch, or server unreachable.	Use a private URL first and test from Seerr's network namespace.
Request does not appear in Radarr	Wrong Radarr API key, wrong URL, disabled service, or missing default settings.	Test the Radarr connection and confirm profile/root folder choices.
Request does not appear in Sonarr	Wrong Sonarr API key, wrong URL, disabled service, or missing language/profile settings.	Test the Sonarr connection and confirm show/season behavior.
Everything goes to the wrong folder	Seerr default root folder is wrong.	Fix Seerr defaults before approving more requests.
Users can approve too much	Roles are too broad.	Create separate admin and requester permissions.
Settings disappear after update	Config directory was not persistent or permissions are wrong.	Verify /etc/seerr/config or Docker /app/config persistence.
Notifications reveal private details	Notification templates or channels are too broad.	Send only what the requester needs and keep admin errors private.

Evidence Boundaries: What This Does Not Prove

This revision checked the commands and architecture against current Seerr documentation and v3.4.1 release records on August 24, 2026, but it does not claim a completed TechGeeks installation, request, migration, restore, screenshot set, or update. The acceptance steps describe evidence the operator should collect. They do not prove that a particular Plex, Jellyfin, Emby, Radarr, Sonarr, reverse-proxy, identity, or notification configuration is compatible.

One Plex request and one Jellyfin request would still not establish compatibility with every client, account provider, media-server release, Arr instance, indexer, download path, notification agent, or reverse proxy. A health endpoint proves only that the web service responds. A checksum proves only which backup file was tested. Neither proves least privilege, lawful media handling, import correctness, final playback, or recovery.

Planned Evidence Checklist

• Planned lab run: create artifacts/labs/seerr-setup-media-requests-sonarr-radarr/YYYY-MM-DD/ with environment, image digest, Compose hash, versions, UTC times, commands, exit codes, and results.
• Planned positive paths: use synthetic requester accounts and authorized test media to trace one Plex-backed request and one Jellyfin-backed request through approval, Radarr/Sonarr, import, media-server scan, availability, and notification.
• Planned negative path: preserve the actual failure from a disabled or mismatched test root, correct it, and capture a second artifact rather than editing the failure into a pass.
• Planned persistence and recovery: restart the container and host, create a consistent config/database backup, update a disposable copy, and restore the prior image plus matched state.
• Planned screenshots: capture initial server selection, redacted Plex/Jellyfin connection state, Arr defaults, requester permissions, request transitions, health, and restore proof with synthetic names.
• Required redaction review: remove tokens, API keys, user identities, hostnames, IP addresses, media titles, request history, notification targets, and image metadata before any artifact is publishable.

Until those artifacts exist and pass review, this article remains documentation-backed. None of the planned screenshots or outputs may be described as observed.

FAQ

Does Seerr replace Sonarr or Radarr?

No. Seerr is the request and approval layer. Sonarr and Radarr remain the systems that track library state, quality rules, root folders, custom formats, imports, and upgrades.

Should Seerr be exposed to the internet?

Only after you intentionally design the access boundary. A safer pattern is VPN or reverse proxy with HTTPS, app authentication, strong admin passwords, least-privilege requester roles, and logging.

Should search on add be enabled?

Not on day one. First prove that requests route to the correct app, root folder, quality profile, and tags. Then enable search for request types you trust.

What should I back up?

Back up Seerr config, database, service file, source commit notes, reverse-proxy notes, and integration settings. Keep those backups private because they may include tokens, user data, and request history.

Series Navigation

Related TechGeeks resources

Seerr is part of the TechGeeks Plex, Arr, and Tdarr homelab series. These companion articles fill in the surrounding architecture, security, storage, monitoring, and automation decisions.

• Jellyfin home media server: start here
• Jellyfin Docker setup and playback test
• Complete Plex and Arr beginner setup
• Sonarr setup
• Radarr setup
• Prowlarr setup
• Seerr request stuck troubleshooting
• Reverse proxy security
• Backups and disaster recovery
• Docker volume and database backup guide

References

• Seerr supported installation paths
• Seerr Docker installation, image tags, signing, persistence, health check, and update guidance
• Seerr advanced source-build guide
• Seerr backup and restore guide
• Seerr database configuration
• Seerr v3.4.1 release notes
• SQLite Online Backup API
• OWASP Secrets Management Cheat Sheet