Your Own Media Server: The *arr Stack

Introduction

We’ve built a Docker host, given it DNS and clean local domains, and self-hosted our photos. This part is the one a lot of people build a home lab for: a fully automated media server - your own private Netflix - running on the same little Intel N100 box.

The collection of tools that makes this happen is affectionately called the *arr stack (Sonarr, Radarr, Prowlarr - notice the pattern). Together they turn “I’d like to watch that” into “it’s on the TV”, automatically: you ask for a film, the stack finds it, downloads it, files it neatly, and your media player picks it up minutes later.

It’s the biggest compose file in the series so far, so we’ll take it a piece at a time.

Meet the Stack

Eight containers cooperate here. It sounds like a lot, but each has one clear job:

• Prowlarr - the indexer manager. It knows where to search and feeds that list to everyone else, so you configure your sources in one place.
• Radarr - movies. Watches for films you want, asks Prowlarr to find them, hands the result to the download client, then renames and files the finished movie.
• Sonarr - exactly the same, but for TV shows.
• Transmission - the download client (BitTorrent), the thing that actually fetches files.
• Jellyfin - the media player: the Netflix-style interface you actually watch, with apps for the TV, phone, and browser.
• Seerr - the friendly “request” front-end. Household members search and click “request”; it tells Radarr/Sonarr to go get it.
• Huntarr & FlareSolverr - two helpers: Huntarr backfills missing items and quality upgrades, FlareSolverr helps Prowlarr get past Cloudflare on some indexers. Both optional.

The flow, end to end: Seerr (request) → Radarr/Sonarr (decide what’s needed) → Prowlarr (find it) → Transmission (download) → Radarr/Sonarr file it into the library → Jellyfin plays it.

Step 1: The Compose File

As always, its own folder:

1
mkdir -p ~/apps/arr

Create ~/apps/arr/docker-compose.yml. It’s long, but it’s just the nine services from above, each following the same shape we’ve used all series:

1
services:
2
  jellyfin:
3
    image: ghcr.io/jellyfin/jellyfin:10.11.11
4
    container_name: jellyfin
5
    environment:
6
      - PUID=1000
7
      - PGID=1000
8
      - UMASK=002
9
    devices:
10
      - /dev/dri/renderD128:/dev/dri/renderD128 # GPU for transcoding
11
    group_add:
12
      - "992" # the host's "render" group - lets Jellyfin use the GPU
13
    volumes:
14
      - ./jellyfin/config:/config
15
      - ./jellyfin/cache:/cache
16
      - /mnt/storage/media:/media
17
    restart: unless-stopped
18
    networks: [arr, reverse-proxy]
19

20
  prowlarr:
21
    image: ghcr.io/hotio/prowlarr:release-2.4.0.5397
22
    container_name: prowlarr
23
    environment: [PUID=1000, PGID=1000, UMASK=002, TZ=Etc/UTC]
24
    volumes:
25
      - ./prowlarr/config:/config
26
    restart: unless-stopped
27
    networks: [arr, reverse-proxy]
28

29
  radarr:
30
    image: ghcr.io/hotio/radarr:release-6.2.1.10461
31
    container_name: radarr
32
    environment: [PUID=1000, PGID=1000, UMASK=002, TZ=Etc/UTC]
33
    volumes:
34
      - ./radarr/config:/config
35
      - /mnt/storage/media:/media # one shared mount - see Step 2
36
    restart: unless-stopped
37
    networks: [arr, reverse-proxy]
38

39
  sonarr:
40
    image: ghcr.io/hotio/sonarr:release-4.0.17.2952
41
    container_name: sonarr
42
    environment: [PUID=1000, PGID=1000, UMASK=002, TZ=Etc/UTC]
43
    volumes:
44
      - ./sonarr/config:/config
45
      - /mnt/storage/media:/media
46
    restart: unless-stopped
47
    networks: [arr, reverse-proxy]
48

49
  seerr:
50
    image: ghcr.io/seerr-team/seerr:v3.3.0
51
    container_name: seerr
52
    environment: [PUID=1000, PGID=1000, UMASK=002, TZ=Etc/UTC]
53
    volumes:
54
      - ./seerr/config:/app/config
55
    restart: unless-stopped
56
    networks: [arr, reverse-proxy]
57

58
  huntarr:
59
    image: ghcr.io/plexguide/huntarr:8.2.10
60
    container_name: huntarr
61
    environment: [PUID=1000, PGID=1000, UMASK=002, TZ=Etc/UTC]
62
    volumes:
63
      - ./huntarr/config:/config
64
    restart: unless-stopped
65
    networks: [arr, reverse-proxy]
66

67
  flaresolverr:
68
    image: ghcr.io/flaresolverr/flaresolverr:v3.5.0
69
    container_name: flaresolverr
70
    environment:
71
      - TZ=Etc/UTC
72
    restart: unless-stopped
73
    networks: [arr]
74

75
  transmission:
76
    image: lscr.io/linuxserver/transmission:4.1.1
77
    container_name: transmission
78
    environment: [PUID=1000, PGID=1000, UMASK=002, TZ=Etc/UTC]
79
    volumes:
80
      - ./transmission/config:/config
81
      - /mnt/storage/media/downloads:/downloads
82
    restart: unless-stopped
83
    networks: [arr, reverse-proxy]
84

85
networks:
86
  arr:
87
    driver: bridge
88
  reverse-proxy:
89
    name: reverse-proxy

Two details to notice:

• Jellyfin gets the GPU, just like Immich in part 4. That renderD128 device and the 992 render group let the N100’s iGPU transcode video on the fly - the difference between smooth playback on a phone and a stuttering mess.
• Every service joins the shared reverse-proxy network alongside its private arr network, so Caddy can reach each one by container name - and none of them needs to publish a port to the host.

Step 2: One Shared Media Folder (and Why)

This is the detail that trips up most first-time setups. Notice that Radarr, Sonarr and Jellyfin all mount the same folder - /mnt/storage/media - rather than separate “downloads” and “movies” folders. That’s deliberate.

Lay out one media tree on your storage drive (the SATA disk from part 1):

1
/mnt/storage/media/
2
├── downloads/   # Transmission writes here
3
├── movies/      # Radarr files finished films here
4
└── shows/       # Sonarr files finished episodes here

Because downloads, movies and shows live on one filesystem, Radarr and Sonarr can move a finished download into the library with an instant hardlink instead of copying gigabytes around. No wasted space, no slow copies, and the original stays seeded for others. Mount separate volumes and you lose this - every import becomes a slow, space-doubling copy. One mount, one filesystem: that’s the trick.

The PUID=1000 / PGID=1000 / UMASK=002 you see on every service make all the apps run as the same user and write group-friendly permissions, so none of them trip over files another one created.

Step 3: Launch It

Bring the whole stack up at once:

1
cd ~/apps/arr
2
docker compose up -d

Docker pulls the eight images and starts them. Give it a minute, then move on to giving each app a clean address.

Step 4: Put It Behind Caddy

Each app has a web interface, and thanks to the wildcard DNS from part 3 we can give them all clean names. Open ~/apps/proxy/Caddyfile and add these blocks inside the existing http://*.home.arpa { ... } site:

1
http://*.home.arpa {
2
  # ...your existing dns / portainer / photos blocks...
3

4
  @movies host movies.home.arpa
5
  handle @movies {
6
    reverse_proxy jellyfin:8096
7
  }
8

9
  @radarr host radarr.home.arpa
10
  handle @radarr {
11
    reverse_proxy radarr:7878
12
  }
13

14
  @sonarr host sonarr.home.arpa
15
  handle @sonarr {
16
    reverse_proxy sonarr:8989
17
  }
18

19
  @prowlarr host prowlarr.home.arpa
20
  handle @prowlarr {
21
    reverse_proxy prowlarr:9696
22
  }
23

24
  @seerr host seerr.home.arpa
25
  handle @seerr {
26
    reverse_proxy seerr:5055
27
  }
28

29
  @transmission host transmission.home.arpa
30
  handle @transmission {
31
    reverse_proxy transmission:9091
32
  }
33
}

Reload Caddy and you’re done:

1
docker compose restart caddy

You can now reach everything at movies.home.arpa, radarr.home.arpa, and so on.

Step 5: Wire Them Together

The containers are running; now they need to know about each other. This part happens in each app’s web UI, and it’s mostly a matter of pasting API keys around. The short version:

1. Prowlarr (prowlarr.home.arpa) - add your indexers under Indexers. Then under Settings → Apps, add Radarr and Sonarr so Prowlarr pushes its indexer list to them automatically. (If an indexer sits behind Cloudflare, add FlareSolverr under Settings → Indexer Proxies at http://flaresolverr:8191.)
2. Radarr & Sonarr - under Settings → Download Clients, add Transmission with host transmission and port 9091. Set the root folder to /media/movies for Radarr and /media/shows for Sonarr.
3. Jellyfin (movies.home.arpa) - run the setup wizard, add two libraries pointing at /media/movies and /media/shows, and enable hardware transcoding (VAAPI) so the GPU does the work.
4. Seerr (seerr.home.arpa) - connect it to Jellyfin and to Radarr/Sonarr. Now anyone in the house can request a title and watch it appear.

Wrapping Up

That’s a complete, automated media server: request a film in Seerr, and minutes later it’s in Jellyfin, downloaded and filed away without you lifting a finger. It’s also the most moving parts we’ve assembled at once - and they still follow the same template as every other service in this series: one folder, one compose file, a private network plus the shared reverse-proxy one, and a handful of Caddy blocks.

As with the rest of the stack, the config directories are runtime data, so keep them out of Git - a .gitignore in ~/apps/arr that ignores jellyfin, radarr, sonarr, prowlarr, seerr, huntarr and transmission means you commit the compose file and nothing sensitive.