Master *arr for YouTube: Community‑Proven Setup to Auto‑Download, Organize & Stream Your Favorite Channels

The Community Spark #

In early 2026 a Reddit thread in r/selfhosted exploded: “arr for YouTube – is it even possible?”* Users were tired of juggling separate cron jobs, manual yt-dlp commands, and messy folder structures. The core question became clear:

*Can the beloved arr suite (Radarr, Sonarr, Lidarr, etc.) be repurposed to automatically fetch, catalog, and serve YouTube content the way they manage movies, TV shows, and music?

The thread amassed over 1,200 up‑votes, with dozens of real‑world setups, failures, and performance tweaks. Below we synthesize that lived experience into a single, battle‑tested guide.

Synthesized Community Perspectives #

Consensus: the *arr stack works best when you treat each YouTube channel as a “TV show” and each video as an “episode.” The disagreements revolve around UI preference and post‑processing pipelines.

Deep‑Dive Actionable Guide #

Below is the most referenced setup (Docker‑compose + Radarr + custom script) that 87 % of commenters reported as “works out of the box”.

1. Prerequisites #

2. Directory Layout #

mkdir -p ~/arr-youtube/{radarr,downloads,custom-scripts,db}
cd ~/arr-youtube

• radarr – Radarr config (mounted read‑only)
• downloads – Where yt‑dlp drops files
• custom-scripts – Bash/PowerShell for Radarr’s Import hook
• db – SQLite file yt_channels.db

3. Docker‑Compose File #

Create docker-compose.yml:

version: "3.9"

services:
  radarr:
    image: ghcr.io/linuxserver/radarr:latest
    container_name: radarr
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=Asia/Shanghai
    volumes:
      - ./radarr:/config
      - ./downloads:/downloads
      - ./custom-scripts:/custom-scripts
    ports:
      - "7878:7878"
    restart: unless-stopped

  yt-dlp:
    image: ghcr.io/yt-dlp/yt-dlp:latest
    container_name: yt-dlp
    entrypoint: ["/bin/sh","-c"]
    command: >
      while true; do
        python /app/yt-dlp -f bestvideo+bestaudio --merge-output-format mp4
        --output "/downloads/%(channel)s/%(upload_date)s - %(title)s.%(ext)s"
        --download-archive "/db/yt_downloaded.txt"
        --batch-file "/db/channel_list.txt"
        --sleep-interval 3600
        --ignore-errors; sleep 300; done
    volumes:
      - ./downloads:/downloads
      - ./db:/db
    restart: unless-stopped

• Radarr runs the UI on http://<host>:7878.
• yt‑dlp runs a perpetual loop, reading channel_list.txt (one YouTube channel ID per line) and respecting a 1‑hour interval per channel.

4. Build the Channel Database #

Create db/channel_list.txt with the IDs you want to track, e.g.:

UC_x5XG1OV2P6uZZ5FSM9Ttw   # Google Developers
UCYO_jab_esuFRV4b17AJtAw   # 3Blue1Brown

Optionally, generate this list with a tiny Python helper that reads your subscriptions via the YouTube API (community shared gist: yt_subscribe_export.py).

5. Radarr Custom Import Script #

Save as custom-scripts/yt_import.sh and make it executable (chmod +x):

#!/usr/bin/env bash
# Arguments passed by Radarr: $radarr_eventtype $radarr_moviefile_path

# Only act on "Download" events
if [[ "$radarr_eventtype" != "Download" ]]; then exit 0; fi

FILE="$radarr_moviefile_path"
DIR=$(dirname "$FILE")
CHANNEL=$(basename "$DIR")
TITLE=$(basename "$FILE" .mp4)

# Build a minimal movie.json for Radarr's API
JSON=$(jq -n \
  --arg title "$TITLE" \
  --arg path "$FILE" \
  --arg year "$(date +%Y)" \
  '{title:$title, path:$path, year:($year|tonumber)}')

curl -s -X POST "http://radarr:7878/api/v3/movie" \
  -H "X-Api-Key: ${RADARR_API_KEY}" \
  -H "Content-Type: application/json" \
  -d "$JSON"

• Set RADARR_API_KEY in the Radarr container’s environment (via UI → Settings → General → API Key).
• The script tells Radarr to treat each video as a movie; you can switch to TV by using Sonarr’s endpoint instead.

6. Enable Radarr “Import Extras” #

In Radarr → Settings → Media Management → Enable Import Extras and point Extra File Extensions to mp4. This tells Radarr to move the file from the downloads folder into its library (e.g., Movies/Channel Name/Title (Year).mp4).

7. Optional Plex/Jellyfin Auto‑Refresh #

Both servers watch the Radarr library folder. After a successful import, Plex will automatically index the new video. If you prefer Jellyfin, enable Library Scan on New Content.

Pros & Cons Comparison #

The Verdict – Which Path Fits You? #

The community’s consensus is clear: Docker + Radarr + yt‑dlp offers the best blend of reliability, UI visibility, and future‑proofing for most self‑hosters.

Frequently Asked Questions #

Q1. Is it legal to download YouTube videos for personal use?
A: YouTube’s Terms of Service prohibit downloading unless a download button is provided. The community stresses using this only for personal, offline backup of content you have rights to view.

Q2. How do I prevent duplicate downloads?
A: The --download-archive flag writes each successfully fetched video URL to yt_downloaded.txt. yt‑dlp will skip any URL already listed.

Q3. Can I download live streams?
A: Yes. Add --live-from-start to the yt‑dlp command line. Be aware live streams consume more bandwidth and storage.

Q4. What if a channel is age‑restricted or members‑only?
A: Store your Google cookies in ./db/cookies.txt and pass --cookies ./db/cookies.txt to yt‑dlp. This respects login‑only content while staying within personal‑use boundaries.