Skip to content

Using the servarr stack

The servarr stack automates the whole media lifecycle: find a release (Prowlarr indexers), decide and grab it (Radarr/Sonarr), download it through the VPN (qBittorrent), organise it into the library (hardlink import), subtitle it (Bazarr), and stream it (Jellyfin). This page covers every component, how they interact, and the day-to-day workflows. It assumes the stack is deployed and wired together per Servarr → Setting up the stack.

Components and what they do

Component Role Talks to
Prowlarr Indexer manager — one place to configure trackers/indexers pushes indexers to Radarr & Sonarr
Radarr Movie manager — chooses what to get and at what quality, then imports it Prowlarr, qBittorrent, Bazarr, /data
Sonarr TV manager — the same, for series/seasons/episodes Prowlarr, qBittorrent, Bazarr, /data
qBittorrent Download client — the only thing moving torrent traffic, all via the Proton VPN Radarr/Sonarr, /data/torrents
Bazarr Subtitles for the Radarr/Sonarr libraries Radarr, Sonarr, /data/media
Jellyfin Media server — streams the finished library reads /data/media
Jellyseerr Request portal — users request titles, it hands them to Radarr/Sonarr Jellyfin, Radarr, Sonarr

The end-to-end flow

  1. You add a movie (Radarr) or series (Sonarr), monitored, with a Quality Profile and a root folder under /data/media.
  2. Radarr/Sonarr search the indexers Prowlarr synced to them — on add, on a manual Search, or automatically via RSS for newly posted releases.
  3. They pick the best release that satisfies the Quality Profile and send its torrent to qBittorrent, tagged with a category (radarr / sonarr).
  4. qBittorrent downloads into /data/torrents, entirely through the Proton VPN, using the forwarded port for inbound peers.
  5. On completion, Radarr/Sonarr import: they hardlink the file from /data/torrents into /data/media/{movies,tv} with a clean Title (Year) name, leaving the torrent seeding.
  6. Bazarr sees the new media and fetches subtitles next to it.
  7. Jellyfin (which reads /data/media) picks it up — immediately if the Radarr/Sonarr → Jellyfin connection is set (see Servarr → Auto-refresh), otherwise on its next scheduled scan — and it is ready to stream.

Because /data/torrents and /data/media are on one volume, step 5 is an instant hardlink — the file lives in both places without using double the space, and seeding continues.

Prowlarr — indexers

  • Role: the single place you configure indexers/trackers. It proxies searches and syncs those indexers into Radarr and Sonarr, so you never configure the same indexer twice.
  • Add indexers: Indexers → Add Indexer → pick the tracker, fill in credentials/API key, Test, Save.
  • Sync to the apps: Settings → Apps → add Radarr and Sonarr (done in setup). After that, any indexer you add or remove in Prowlarr appears or disappears in them automatically. Sync Profiles control which indexers go to which app.
  • Manual search: the Search tab queries all indexers at once — useful to confirm an indexer actually returns results.
  • FlareSolverr (optional): some indexers sit behind Cloudflare; add a FlareSolverr proxy under Settings → Indexers if a tracker needs it. Not deployed here by default.
  • Interaction: Prowlarr itself downloads nothing — Radarr/Sonarr use the indexer definitions it synced when they search.

Radarr — movies

  • Role: decides which movies to keep, at what quality, finds releases, sends them to qBittorrent, and imports the result.
  • Add a movie: Movies → Add New → search → select → choose Root Folder (/data/media/movies), a Quality Profile, and Monitored; tick "Search on add" to grab immediately → Add.
  • Monitoring: a monitored movie is one Radarr will grab. Unmonitor to keep it in the library but stop managing it.
  • Quality Profiles (Settings → Profiles): an ordered list of allowed qualities plus an upgrade cutoff. Radarr grabs the best allowed release and keeps upgrading until it reaches the cutoff. Custom Formats add scoring (release groups, HDR, etc.).
  • Search: the movie's Search icon (or Movies → Wanted → Missing → Search) runs a search across indexers now — needed for anything already released, since RSS only surfaces new uploads.
  • Activity → Queue shows in-progress downloads and import status; Activity → History shows grabs, imports, and failures.
  • Failed grabs: if a release stalls or fails, Radarr blocklists it and tries another on the next search.
  • Manual import: Wanted → Manual Import (or from the movie) if something didn't auto-import, e.g. odd naming.
  • Interactions: indexers from Prowlarr; downloads to qBittorrent (host qbittorrent:8080, category radarr); imports into /data/media/movies; Bazarr subtitles that library; Jellyfin serves it.

Sonarr — series

  • Role: the same as Radarr, for TV — tracks series, seasons, and episodes.
  • Add a series: Series → Add New → search → select → Root Folder (/data/media/tv), a Quality Profile, a Monitor option (All / Future / Missing / First Season / etc.), Season Folders → Add.
  • Monitoring granularity: toggle monitoring per series, per season, or per episode to control what Sonarr chases.
  • RSS vs search: airing episodes are grabbed automatically via RSS; back-catalogue episodes need a Series/Season Search.
  • Release/quality: Quality Profiles as in Radarr, plus release profiles (preferred/ignored words) and per-series language.
  • Interactions: identical wiring to Radarr — Prowlarr indexers, qBittorrent (category sonarr), /data/media/tv, Bazarr, Jellyfin.

qBittorrent — download client

  • Role: the only component moving bittorrent traffic, and it does so entirely through the Proton VPN (gluetun sidecar with a kill-switch).
  • Categories: Radarr/Sonarr set a category (radarr / sonarr) per torrent. The default save path /data/torrents is fine; you can map categories to sub-paths if you prefer.
  • VPN & port: all traffic exits via Proton; the leased forwarded port is kept in sync by the port-updater sidecar (see servarr.md). qBittorrent must be bound to the tunnel by IP address 10.2.0.2 (Settings → Advanced → Network Interface → Optional IP address to bind to), not the tun0 interface name — see the setup warning for why binding by name or leaving it unbound silently stalls every download at 0%. qBittorrent has no built-in public-IP display — verify the exit IP with kubectl -n servarr exec deploy/qbittorrent -c qbittorrent -- curl -s https://ipinfo.io/ip.
  • Seeding & auto-removal: after import the torrent keeps seeding from /data/torrents (the hardlink means no duplicate file). Under Settings → BitTorrent → Seeding Limits set a seeding-time, ratio, or inactive-seeding-time limit plus an action for when it's hit: Remove torrent (drops the torrent, keeps the files) or Remove torrent and its files. Because imports are hardlinks, "Remove torrent and its files" is safe here — it only removes the /data/torrents hardlink, and the /data/media library copy survives — so it's the option that actually stops /data/torrents from growing. Plain "Remove torrent" leaves the file in /data/torrents, which still shares its inode with the library copy, so it frees no disk until that copy is also deleted.
  • Interaction: receives grabs from Radarr/Sonarr over the in-cluster Service; they poll it for progress and import when a download completes.

Bazarr — subtitles

  • Role: watches the Radarr/Sonarr libraries and downloads subtitles for them.
  • Connect: Settings → Radarr and Settings → Sonarr (done in setup). Bazarr reads the same /data/media, so no path mapping is needed.
  • Languages & providers: Settings → Languages (which languages, plus a language profile per library) and Settings → Providers (subtitle sources).
  • How it works: on new or upgraded media, Bazarr searches its providers and drops the subtitle file next to the video. A manual per-item search is available for tricky matches; scoring controls how good a match must be.

Jellyfin — media server

  • Role: streams the finished library to browsers and native apps.
  • Libraries: Movies → /data/media/movies and Shows → /data/media/tv (mounted read-only). Jellyfin scans on a schedule; trigger it manually with Dashboard → Libraries → Scan All Libraries. For imports to appear instantly, set up the Radarr/Sonarr → Jellyfin connection — real-time monitoring alone won't do it on the NFS-backed volume.
  • Playback: prefer direct play. The nodes are arm64 Raspberry Pi with no hardware transcoding wired, so heavy transcodes are slow — pick client-friendly formats and let clients direct-play.
  • Users & clients: create users in Dashboard → Users; point apps (phone/TV/web) at jellyfin.local.spaelling.xyz. Jellyfin uses its own login (no SSO — see servarr.md).
  • Metadata: Jellyfin fetches artwork/metadata, and the Title (Year) naming that Radarr/Sonarr produce is what makes matching reliable.

Jellyseerr — requests

  • Role: the friendly front door. Users browse movies/series and request them; Jellyseerr hands approved requests to Radarr/Sonarr, which grab and import exactly as if you had added them by hand.
  • Sign-in: Jellyseerr authenticates against Jellyfin, so your Jellyfin users log in with the same accounts. Admins approve requests (or enable auto-approval per user/quota).
  • Connect (Settings → Services): point it at Radarr (http://radarr:7878) and Sonarr (http://sonarr:8989) with their API keys, and set a default Quality Profile and root folder for each. Jellyseerr matches media against Jellyfin so it knows what you already have.
  • Requesting: search a title → Request → (approval, if required) → it appears in Radarr/Sonarr as monitored and is searched/grabbed → it lands in the library and shows up in Jellyfin. The requester can watch the status in Jellyseerr.
  • Interaction: Jellyseerr never touches /data — it only calls the Jellyfin, Radarr, and Sonarr APIs.

Common operations

  • Get something already released: add it monitored, then Search — RSS will not find it.
  • Upgrade quality: raise the Quality Profile cutoff; Radarr/Sonarr re-grab a better release when one appears and re-import over the old file.
  • A download is stuck (no seeders): it stalls in qBittorrent; Radarr/Sonarr time it out, blocklist it, and try another release on the next search.
  • Downloaded but not in the library: check Activity → Queue for an import error (naming/permissions), then Manual Import.
  • New media missing from Jellyfin: trigger a library scan, or wait for the scheduled one.
  • Test the pipe only: paste a magnet straight into qBittorrent — it bypasses Radarr/Sonarr entirely.

Troubleshooting the interactions

Symptom Likely cause
Radarr/Sonarr find nothing no indexers synced from Prowlarr, or none match the Quality Profile
"Unable to connect to qBittorrent" on Test Use SSL is on (qBittorrent's WebUI is plain HTTP — turn it off), or wrong host (qbittorrent, no scheme) / port (8080) / WebUI login. The network path itself is in-cluster and needs nothing special.
A grab never downloads qBittorrent not configured as a download client in Radarr/Sonarr, or wrong host/port/login
Downloaded but not imported naming/permissions, or the download is not on the same /data volume (breaks the hardlink)
No subtitles Bazarr not connected to Radarr/Sonarr, or no provider/language set
Not showing in Jellyfin wrong library path, or no scan since the import — set up the Radarr/Sonarr → Jellyfin connection so imports auto-scan (inotify real-time monitoring doesn't fire on the NFS-backed volume)
No peers / stuck at 0% (metaDL), DHT 0, trackers time out qBittorrent bound to the wrong thing: it must bind by IP 10.2.0.2 (the tunnel address), not the tun0 interface name and not left unbound — otherwise it sources from eth0 and gluetun's kill-switch drops everything. Check connection status: connected in the status bar. See the setup warning.
Real IP leaks check the VPN exit IP and the port-updater log; the 10.2.0.2 bind is also the app-level kill-switch