The Complete *Arr Stack Guide: Sonarr, Radarr, Prowlarr, and More

Media 2026-02-08 sonarr radarr prowlarr lidarr media-automation

You've set up Jellyfin or Plex and you have a media library. But manually finding, downloading, renaming, and organizing media files is tedious. You end up with inconsistent file names, missing episodes, and a folder structure that makes no sense.

The *arr stack automates all of this. It's a collection of tools that work together to monitor, find, download, rename, and organize your media library — hands-free, once configured.

What Each *Arr App Does

The naming convention comes from Sonarr (the original), and each app handles a specific media type:

App	Purpose	Media Type
Sonarr	TV show management	TV series and episodes
Radarr	Movie management	Movies
Lidarr	Music management	Albums and tracks
Readarr	Book management	eBooks and audiobooks
Prowlarr	Indexer management	Manages indexers for all *arr apps
Bazarr	Subtitle management	Subtitles for movies and TV
Overseerr	Request management	User requests for media

You don't need all of them. Most people start with Prowlarr + Sonarr + Radarr and add others as needed.

How the pieces fit together

The data flow looks like this:

You add a movie or show to Sonarr/Radarr (or a user requests it via Overseerr)
Prowlarr searches your configured indexers (Usenet or torrent) for matching releases
Sonarr/Radarr evaluates results against your quality profile and sends the best match to your download client
Your download client (SABnzbd, qBittorrent, etc.) downloads the file
Sonarr/Radarr detects the completed download, renames it, and moves it to your media library
Jellyfin/Plex picks up the new file automatically

Once configured, adding a movie is literally: search, click "Add," done. It shows up in your media server within minutes.

Docker Compose: The Full Stack

Here's a production-ready compose file for the core stack. All services share a common data structure for efficient file handling.

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

  sonarr:
    image: lscr.io/linuxserver/sonarr:latest
    container_name: sonarr
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=America/Los_Angeles
    volumes:
      - ./config/sonarr:/config
      - /path/to/data:/data
    ports:
      - "8989:8989"
    restart: unless-stopped

  radarr:
    image: lscr.io/linuxserver/radarr:latest
    container_name: radarr
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=America/Los_Angeles
    volumes:
      - ./config/radarr:/config
      - /path/to/data:/data
    ports:
      - "7878:7878"
    restart: unless-stopped

  lidarr:
    image: lscr.io/linuxserver/lidarr:latest
    container_name: lidarr
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=America/Los_Angeles
    volumes:
      - ./config/lidarr:/config
      - /path/to/data:/data
    ports:
      - "8686:8686"
    restart: unless-stopped

  bazarr:
    image: lscr.io/linuxserver/bazarr:latest
    container_name: bazarr
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=America/Los_Angeles
    volumes:
      - ./config/bazarr:/config
      - /path/to/data:/data
    ports:
      - "6767:6767"
    restart: unless-stopped

docker compose up -d

Critical: The folder structure

The single most important thing for an efficient *arr stack is getting the folder structure right. You want all services to see the same filesystem so that moves are instant (hardlinks or atomic moves, not copies).

/data/
  torrents/
    movies/
    tv/
    music/
  usenet/
    movies/
    tv/
    music/
  media/
    movies/
    tv/
    music/

Map /path/to/data to /data in every container. When Sonarr moves a completed download from /data/torrents/tv/ to /data/media/tv/, it's a move within the same filesystem — instant, no disk I/O, no doubled storage.

The biggest mistake people make is mapping separate volumes for downloads and media. This forces a copy-and-delete instead of a move, which doubles your disk usage during processing and hammers I/O.

Setting Up Prowlarr (Indexer Management)

Prowlarr is the hub for all your indexers. Instead of configuring indexers separately in Sonarr, Radarr, and Lidarr, you configure them once in Prowlarr and it syncs to all connected apps.

Adding indexers

Open Prowlarr at http://your-server:9696
Go to Indexers → Add Indexer
Search for your indexer (supports hundreds of Usenet and torrent indexers)
Enter your API key or credentials
Test the connection

Connecting to *arr apps

In Prowlarr, go to Settings → Apps
Click + and select Sonarr, Radarr, or Lidarr
Enter the app's URL and API key (found in each app under Settings → General)
Prowlarr will automatically push your indexers to each connected app

From this point on, any indexer you add or remove in Prowlarr is automatically synced everywhere.

Quality Profiles: Getting the Right Files

Quality profiles are how you tell Sonarr and Radarr what quality you want. This is where most people spend their tuning time.

Recommended movie profile (Radarr)

For most setups with a 4K-capable TV:

Go to Settings → Profiles
Create a profile called "HD/4K"
Enable: Bluray-2160p, WEB-2160p, Bluray-1080p, WEB-1080p
Set minimum quality to WEB-1080p
Set upgrade until: Bluray-2160p

This grabs the best 1080p release immediately, then upgrades to 4K if a good release appears.

Recommended TV profile (Sonarr)

TV shows rarely need 4K. A sensible profile:

Enable: Bluray-1080p, WEB-1080p, HDTV-1080p, WEB-720p
Set minimum quality to WEB-720p
Set upgrade until: Bluray-1080p

Custom formats

Both Sonarr and Radarr support custom formats — rules that score releases based on attributes like:

Preferred audio codec (TrueHD Atmos scores higher than AAC)
Release group reputation
HDR format (Dolby Vision, HDR10+)
Avoiding unwanted attributes (hardcoded subtitles, cam releases)

The TRaSH Guides are the definitive resource for custom format configuration. Follow them — they'll save you hours of trial and error.

Connecting Download Clients

Usenet (SABnzbd/NZBGet)

In Sonarr/Radarr, go to Settings → Download Clients → +:

Host: your SABnzbd/NZBGet address
API Key: from your download client's settings
Category: set a category like "tv" or "movies" so downloads are organized

Torrents (qBittorrent/Transmission)

Same process, different fields:

Host: your torrent client address
Username/Password: your torrent client credentials
Category: same idea — "tv," "movies," etc.

Important: Remote path mappings

If your download client and *arr apps see different paths for the same files (common when some services run in Docker and others don't), you'll need remote path mappings under Settings → Download Clients → Remote Path Mappings.

Integration with Jellyfin/Plex

Once Sonarr/Radarr moves files to your media library, your media server needs to know about them.

Jellyfin

Jellyfin monitors library folders automatically. Just make sure your Jellyfin media library points to the same /data/media/ directory that Sonarr/Radarr uses as the root folder.

You can also configure Sonarr/Radarr to send a notification:

Settings → Connect → +
Select Jellyfin/Emby
Enter your Jellyfin URL and API key
Enable "On Import" and "On Upgrade"

Now Jellyfin rescans immediately when new media arrives, instead of waiting for the scheduled scan.

Plex

Same approach — add a Plex connection under Settings → Connect with your Plex URL and token.

Hardlinks and Atomic Moves: Storage Efficiency

This is the part most guides gloss over, but it's critical for disk efficiency.

When Sonarr/Radarr imports a completed download, it can either:

Copy + delete — Doubles disk usage temporarily, slow, hammers I/O
Hardlink (torrents) — Creates a second reference to the same data on disk. The file appears in both the torrent client's folder (for seeding) and the media library, but only uses disk space once.
Atomic move (Usenet) — Instant rename/move within the same filesystem

For hardlinks to work:

Download and media directories must be on the same filesystem
All containers must use the same base path (that's why we use /data for everything)
The PUID/PGID must match across all containers

If you followed the folder structure above, hardlinks work automatically. You can verify by checking that a newly imported file doesn't consume additional disk space.

Adding Overseerr for User Requests

If family members want to request movies and shows without accessing Sonarr/Radarr directly, Overseerr provides a clean request interface:

  overseerr:
    image: lscr.io/linuxserver/overseerr:latest
    container_name: overseerr
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=America/Los_Angeles
    volumes:
      - ./config/overseerr:/config
    ports:
      - "5055:5055"
    restart: unless-stopped

Users search for a movie or show, click "Request," and Overseerr sends it to the appropriate *arr app automatically. You can configure approval workflows or let requests auto-approve.

The Honest Trade-offs

*The arr stack is great if:

You have a large or growing media library
You want automated quality upgrades as better releases appear
You're tired of manually renaming and organizing files
You want a "set and forget" media pipeline

*The arr stack is not ideal if:

You have a small, static collection that doesn't change often
You want something simple — the learning curve is real
You're not comfortable with Docker and networking basics

Bottom line: The initial setup takes a few hours, and there's a learning curve with quality profiles and custom formats. But once it's dialed in, the *arr stack is genuinely hands-free. You add a show, and it appears in your media server with the right name, the right quality, and the right subtitles. The TRaSH Guides are essential reading — don't try to figure out custom formats from scratch.

Resources

Sonarr documentation
Radarr documentation
Prowlarr documentation
TRaSH Guides — The definitive resource for quality profiles and custom formats
Hardlinks and atomic moves explained
LinuxServer.io images — Maintained Docker images for all *arr apps