The Arr Stack Explained: Complete Setup Guide for 2026

The arr stack (Sonarr, Radarr, Prowlarr, Bazarr) automates and organizes a self-hosted media library. Full 2026 setup guide with Docker Compose, hardlink-safe folder layout, and Jellyfin.

Published: 2026-08-28

The arr stack — also called the Servarr apps — is a family of self-hosted automation tools that manage a media library for you. Sonarr handles TV shows, Radarr handles movies, Prowlarr manages the indexers the other apps search, and companion apps cover music, subtitles, and user requests. Together they monitor for new or missing content, hand downloads to a download client, then import, rename, organize, and upgrade files automatically. The stack is almost always paired with a media server such as Jellyfin or Plex, which serves the finished library to your devices. This guide covers every component, how they connect, and a complete Docker Compose setup that works in 2026.

The name comes from the shared suffix: Sonarr, Radarr, Lidarr, Prowlarr, Bazarr. The projects share a common codebase lineage and a nearly identical UI, so once you have configured one of them, the rest feel familiar.

The components

You do not need all of them. A minimal, useful stack in 2026 is Prowlarr, Sonarr, Radarr, Bazarr, and Jellyfin. Add Jellyseerr when other people start using your server, and Lidarr only if you keep a music collection.

How the pieces fit together

The stack is a pipeline, and every app owns exactly one stage of it:

• Request. Someone adds a title — directly in Sonarr or Radarr, or through Jellyseerr, which passes the request along.

• Monitor and search. The arr app watches for the content it is missing. When a release matching your quality profile appears on one of your configured indexers (managed centrally by Prowlarr), it grabs it.

• Download. The arr app sends the release to a download client such as qBittorrent or SABnzbd and tracks its progress over the client's API.

• Import. When the download completes, the arr app hardlinks or moves the file into your library, renames it to a consistent scheme, fetches metadata, and deletes samples and junk.

• Serve. Jellyfin or Plex notices the new file in its watched folder, matches it against metadata providers, and it shows up on your devices with artwork, descriptions, and subtitles courtesy of Bazarr.

The underrated part of this pipeline is the import stage. The real value of the arr stack is not grabbing files — it is the perfectly consistent library it maintains for you. Every episode lands as /data/media/tv/Show Name (2024)/Season 01/Show Name - S01E01 - Episode Title.mkv, every movie as /data/media/movies/Movie Name (2023)/Movie Name (2023).mkv. That consistency is exactly what media servers need for reliable metadata matching, and it is what makes a ten-year-old library of a few thousand items maintainable. The apps also handle upgrades: if you imported a 720p rip of your DVD and later produce a 1080p remux, Radarr swaps it in and keeps the naming intact.

A note on legality

Honest paragraph time: the arr stack is often associated with piracy, and pretending otherwise would be silly. But the software itself is legal, open-source automation tooling — it searches indexes, talks to download clients, and renames files. There is nothing infringing about any of that, and there are entirely legitimate uses: automating and organizing personal DVD and Blu-ray rips, managing public-domain and Creative Commons content, keeping home videos and self-produced media sorted, and maintaining libraries of content you have the rights to. What you point the stack at is your responsibility. This guide does not recommend specific indexers or content sources, and it will not help you infringe copyright — check the law where you live and stick to media you actually have the rights to store.

Setup with Docker Compose

Docker Compose is the standard way to run the stack in 2026: one file defines every service, updates are a pull away, and the whole thing survives reboots. You need Docker Engine with the Compose plugin and a Linux host (a NAS, a mini PC, a Raspberry Pi — more on hardware below).

The /data layout: get this right first

Before touching Compose, create a single directory tree on one filesystem:

/data
├── torrents        # or /data/usenet — download client working area
├── usenet
└── media
    ├── tv
    ├── movies
    └── music

The entire tree must live on one filesystem, and every container that touches files should see it mounted at the same path. The reason is hardlinks and atomic moves. When Sonarr imports a completed download, it can create a hardlink — the file appears in both /data/torrents and /data/media/tv instantly, consuming disk space once, and the copy in the download folder can keep seeding or be cleaned up on its own schedule. Hardlinks only work within a single filesystem. If you mount downloads and media as two separate Docker volumes, the container sees two filesystems, hardlinks fail silently, and every import becomes a slow full copy that briefly doubles your disk usage. This is the single most common arr stack misconfiguration, so mount one /data and let the apps see subfolders of it.

docker-compose.yml

A realistic Compose file with Jellyfin, Sonarr, Radarr, Prowlarr, and Bazarr:

services:
  jellyfin:
    image: lscr.io/linuxserver/jellyfin:latest
    container_name: jellyfin
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=Etc/UTC
    volumes:
      - ./config/jellyfin:/config
      - /data/media:/data/media
    ports:
      - 8096:8096
    restart: unless-stopped

  sonarr:
    image: lscr.io/linuxserver/sonarr:latest
    container_name: sonarr
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=Etc/UTC
    volumes:
      - ./config/sonarr:/config
      - /data:/data
    ports:
      - 8989:8989
    restart: unless-stopped

  radarr:
    image: lscr.io/linuxserver/radarr:latest
    container_name: radarr
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=Etc/UTC
    volumes:
      - ./config/radarr:/config
      - /data:/data
    ports:
      - 7878:7878
    restart: unless-stopped

  prowlarr:
    image: lscr.io/linuxserver/prowlarr:latest
    container_name: prowlarr
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=Etc/UTC
    volumes:
      - ./config/prowlarr:/config
    ports:
      - 9696:9696
    restart: unless-stopped

  bazarr:
    image: lscr.io/linuxserver/bazarr:latest
    container_name: bazarr
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=Etc/UTC
    volumes:
      - ./config/bazarr:/config
      - /data/media:/data/media
    ports:
      - 6767:6767
    restart: unless-stopped

Points worth noting:

• PUID and PGID map each container's internal user to a real user on the host, so files land owned by you instead of root. Run id on the host and use the values it prints (1000 is the default first user on most distros).

• Sonarr and Radarr mount all of /data because they must see both the download area and the media folders through one mount for hardlinks to work. Jellyfin and Bazarr only need /data/media — they never touch downloads.

• Config folders are bind mounts next to the Compose file, which makes backups trivial: stop the stack, copy ./config, done. Each app's entire state lives there.

• restart: unless-stopped brings everything back after a reboot without resurrecting containers you deliberately stopped.

Bring it up with docker compose up -d, then confirm each UI loads: Jellyfin on port 8096, Sonarr 8989, Radarr 7878, Prowlarr 9696, Bazarr 6767.

Configuration walkthrough

Configure in this order — it saves you from re-entering things later:

1. Prowlarr first. Open Prowlarr and add your indexers there, not in each app individually. Then go to Settings → Apps and add Sonarr and Radarr with their URLs (use the container names, e.g. http://sonarr:8989, since the containers share a network) and API keys (found in each app under Settings → General). Prowlarr syncs every indexer to both apps automatically and keeps them in sync when you add or remove one. This is the entire reason Prowlarr exists — before it, you configured every indexer in every app by hand.

2. Download client. In Sonarr and Radarr, add your download client under Settings → Download Clients. Set its download path to /data/torrents (or /data/usenet) so completed files land inside the shared tree.

3. Root folders. In Sonarr, Settings → Media Management, add /data/media/tv as the root folder. In Radarr, add /data/media/movies. Enable "Rename Episodes" / "Rename Movies" and turn on "Use Hardlinks instead of Copy" under importing.

4. Quality profiles. Each app ships with sensible defaults (Any, HD-1080p, Ultra-HD). Pick one per library and resist the urge to over-tune on day one — profiles decide what resolution and source types the app accepts and when it upgrades an existing file. You can refine cutoffs and custom formats once the basics work.

5. Connect the media server. In Jellyfin, add /data/media/tv and /data/media/movies as libraries. Then, in Sonarr and Radarr under Settings → Connect, add a Jellyfin connection so imports trigger an immediate library scan instead of waiting for the periodic one.

6. Bazarr last. Point Bazarr at Sonarr and Radarr (same URL-plus-API-key pattern), create a language profile, and it will backfill subtitles for existing files and grab them for every new import.

Updates and backups

Updating the stack is two commands: docker compose pull followed by docker compose up -d. The linuxserver images track upstream releases closely, and because every app's state lives in its ./config bind mount, an update never touches your data. For backups, an occasional copy of the config directory captures every database, quality profile, and API key in the stack — restore it onto a fresh host, point the same /data at it, and everything comes back exactly as it was. Automated updaters like Watchtower work here too, though many people prefer manual pulls so a breaking release never lands unattended overnight.

Common mistakes

Mismatched paths between containers. If the download client sees a finished file at /downloads/file.mkv but Sonarr expects it at /data/torrents/file.mkv, imports fail with "path does not exist" errors even though the file is right there on disk. The fix is consistency: mount the same host folder at the same container path in every service, as the Compose file above does.

Separate volumes breaking hardlinks. Covered above, but it bears repeating because the failure is silent: imports still work, they just degrade to copies. If imports are slow and disk usage spikes during them, this is why. One filesystem, one /data mount.

Running everything as root. Skipping PUID/PGID means containers write files as root, and sooner or later some app cannot read or delete what another app created. Set the IDs once in Compose and never think about permissions again.

Exposing the web UIs to the internet. The arr apps ship with weak-to-no authentication by default and a public Sonarr instance is an open invitation. Do not port-forward these UIs. If you need remote access, use a mesh VPN like Tailscale or WireGuard — it takes ten minutes and exposes nothing — or put everything behind a reverse proxy with real authentication in front of it. Jellyfin is the only piece designed for cautious public exposure, and even it belongs behind a reverse proxy with HTTPS.

Over-automating on day one. Add a handful of titles, watch one complete the full pipeline from grab to Jellyfin, and confirm naming and hardlinks behave. Then scale up. Debugging a misconfigured stack with 400 queued items is miserable.

Hardware notes

The arr apps themselves are lightweight — each idles at a few hundred MB of RAM and near-zero CPU. A Raspberry Pi 4 or 5, a ten-year-old office PC, or a low-power N100 mini PC runs the whole automation layer without effort. The one component that needs real hardware consideration is Jellyfin, and only for transcoding: converting video on the fly when a client cannot play the original format. If your devices direct-play your files (most modern TVs and phones handle H.264 and H.265), even a Pi is fine. If you need transcoding — remote streaming at lower bitrates, old smart TVs, burned-in subtitles — you want a GPU or, more practically, an Intel CPU with QuickSync. A used Intel 8th-gen-or-newer mini PC is the community's default recommendation for exactly this reason: QuickSync handles several simultaneous transcodes at a few extra watts. Storage is the other axis: media libraries grow, so favor a case or NAS with room for more drives, and keep /data on the big drives rather than the system disk.

FAQ

What is arr stack?

The arr stack is a set of self-hosted automation apps — Sonarr for TV, Radarr for movies, Lidarr for music, Prowlarr for indexer management, Bazarr for subtitles — that monitor, download, rename, organize, and upgrade a media library automatically. The name comes from the shared -arr suffix; the project family is formally called Servarr. The stack is usually paired with a media server such as Jellyfin or Plex that plays the organized library.

Can I run the Arr Stack on Windows?

Yes. Every arr app ships a native Windows installer and runs as a Windows service, and Docker Desktop with WSL2 works too. That said, most of the community runs the stack on Linux via Docker Compose because container updates, permissions, and hardlink behavior are more predictable there. If Windows is what you have, native installs are the smoother path — Docker Desktop's file sharing between the Windows filesystem and containers can break hardlinks and slow imports.

What are the best arr stacks?

For most people in 2026: Prowlarr, Sonarr, Radarr, and Bazarr for automation, Jellyfin as the media server, and Jellyseerr for requests — all free and open source. Swap Jellyfin for Plex if you want the most polished client apps and do not mind a proprietary server, and add Lidarr if you manage music. Readarr is no longer part of a recommended stack since its retirement; use LazyLibrarian or Calibre-Web Automated for books.

What are the components of the arr stack?

The core components are Sonarr (TV), Radarr (movies), Lidarr (music), Prowlarr (indexer manager), and Bazarr (subtitles). Around them sit a download client (qBittorrent or SABnzbd), a media server (Jellyfin, Plex, or Emby), and optionally a request app (Jellyseerr or Overseerr). Readarr (books) was part of the family until the project was archived in 2025.

Where to go from here

If you are building this stack, the talos.tools self-hosted directory has detailed pages on the key pieces: Jellyfin for the media server layer, plus Sonarr and Radarr for the automation core. Choosing between media servers? The Jellyfin vs Plex comparison breaks down the tradeoffs. And for the broader landscape around the stack, see the roundup of the 10 best self-hosted apps for media streaming.

Last updated: August 2026.

Last updated: 2026-08-28