Radarr Homelab Setup Guide: Install, Update, Optimize, Lists, and Tdarr Integration

Radarr is the movie side of a serious homelab media stack. It can watch for movies, search indexers, send jobs to a download client, import completed files, rename and organize your library, track quality, and upgrade files when better releases appear. That sounds automatic, but a good Radarr setup is not just "turn on every list and hope." The best results come from deliberate paths, deliberate profiles, deliberate custom formats, and lists that add good movies without filling your library with noise.

This guide is built around a Plex homelab where Radarr manages movies, Sonarr manages TV, Prowlarr syncs indexers, SABnzbd or another client handles downloads, and Tdarr performs post-import optimization. The end goal is a movie library that is easy to rebuild, easy to audit, efficient on disk, and cleanly integrated with Plex and Tdarr.

Rights and lawful use: Configure Radarr, lists, download services, and post-processing only for media and sources you are authorized to use. Automation does not create permission to acquire, retain, share, or transform copyrighted material.

Before You Start: Safe Defaults

• Use Radarr only with media and services you are allowed to use.
• Create a shared media group and use UMASK=002 so imports, renames, and Tdarr replacements do not break permissions.
• Keep config directories persistent and backed up before changing install method, profiles, lists, or paths.
• Keep admin ports private until authentication, reverse proxy rules, VPN, or access lists are in place.
• Test one item end to end before enabling broad automation.

Where Radarr Fits

Radarr should be the movie authority in your environment. Plex should not be where you fix folder paths. SABnzbd should not decide where final movies live. Tdarr should not be the system of record for movie quality. Radarr is where movies are added, monitored, organized, upgraded, tagged, and rescanned.

• Radarr tracks movies, quality profiles, custom format scores, root folders, imports, and upgrades.
• Prowlarr centralizes indexers and pushes them into Radarr.
• SABnzbd or another download client downloads into a dedicated download path.
• Plex serves the final movie folders.
• Tdarr optimizes the completed file after Radarr has imported it.

The cleanest workflow is: Radarr chooses a release, the download client downloads it, Radarr imports it into the correct movie root folder, Plex sees it, Tdarr optimizes it, Plex refreshes again, and Radarr rescans so MediaInfo and file size stay current.

1. 1. IntakeManual / List / Request

   A movie enters Radarr from a person, Ombi, watchlist, MDBList, Trakt, or another curated source.

2. 2. PolicyProfile + Tags

   Root folder, tags, quality profile, custom formats, and search-on-add behavior determine what happens next.

3. 3. SearchCandidate Scoring

   Radarr accepts or rejects releases based on quality, language, custom formats, cutoff, and minimum score.

4. 4. DownloadSAB movies Category

   Accepted jobs download into staging; SAB does not organize the final movie library.

5. 5. ImportMovie Root Folder

   Radarr imports, renames, tracks, and keeps movie file state current.

6. 6. OptimizeTdarr + Rescan

   Tdarr may replace the file, then Radarr rescans MediaInfo, codec, size, and quality details.

Search on add: review firstEnable automated searching only after the list source, tags, root folder, and quality rules are understood.

Rights gateUse these workflows only for media you own or are authorized to store, download, organize, or transcode.

Install Strategy

Radarr can run well in Docker Compose or as a native Ubuntu service. Docker Compose is usually easier to rebuild because the config path, media path, ports, and environment variables are explicit. Native Ubuntu can be great when you already manage your media stack with systemd. Either way, the two non-negotiables are persistent config storage and consistent media paths.

Docker Compose Example

Before writing the Radarr Compose service, identify the account that should own imported movies and the shared group used by the download client, Plex, and Tdarr. Substitute the host's real UID and group GID below; copied numeric examples can create files that Radarr imports but another service cannot read or replace.

sudo groupadd -f media
id -u mediauser
getent group media | cut -d: -f3

sudo mkdir -p /opt/media-stack
cd /opt/media-stack
cat > .env <<'EOF'
PUID=1000
PGID=1001
TZ=America/Chicago
UMASK=002
EOF

Radarr container update note: The service example favors readability. Once the single-item workflow passes, record or pin the tested Radarr image release, copy its config directory off-box, and update it independently so a simultaneous download-client, Plex, or Tdarr change cannot obscure the cause of an import regression.

The Compose pattern below keeps Radarr config persistent and gives Radarr the same /data view that SABnzbd, Sonarr, Plex, and Tdarr use. That shared path prevents most remote-path-mapping confusion.

services:
  radarr:
    image: lscr.io/linuxserver/radarr:latest
    container_name: radarr
    env_file: .env
    volumes:
      - /opt/media-stack/radarr/config:/config
      - /data:/data
    ports:
      - "127.0.0.1:7878:7878"
    networks:
      - media
    restart: unless-stopped

networks:
  media:
    name: media
    driver: bridge

Bind Radarr to localhost by default, then publish it through a VPN or protected reverse proxy when you are ready. Radarr contains API keys, download-client access, and library control, so treat it like an admin console.

Native Ubuntu Install

A native Radarr install is a normal systemd service. The important parts are the service user, the shared media group, persistent app data under /var/lib/radarr, and a unit that waits for storage before starting. The download URL below uses the official Radarr update endpoint; check the official Linux install page before production use in case the project has changed package guidance.

sudo apt update
sudo apt install -y curl wget sqlite3 tar acl
sudo groupadd -f media

if ! getent passwd radarr >/dev/null; then
  sudo useradd --system \
    --home-dir /var/lib/radarr \
    --shell /usr/sbin/nologin \
    --gid media \
    radarr
fi

sudo install -d -o radarr -g media -m 0750 /var/lib/radarr
sudo install -d -o root -g root -m 0755 /opt

arch="$(dpkg --print-architecture)"
case "$arch" in
  amd64) arr_arch=x64 ;;
  arm64) arr_arch=arm64 ;;
  armhf|armel) arr_arch=arm ;;
  *) echo "Unsupported architecture: $arch"; exit 1 ;;
esac

cd /tmp
download_url="https://radarr.servarr.com/v1/update/master/updatefile"
download_url="$download_url?os=linux&runtime=netcore&arch=${arr_arch}"
wget --content-disposition "$download_url"
tar -xzf Radarr*.linux*.tar.gz
sudo rm -rf /opt/Radarr
sudo mv Radarr /opt/
sudo chown -R radarr:media /opt/Radarr /var/lib/radarr

Create the service unit with the correct user, group, umask, and mount dependency. Change /data/media and /data/downloads if your paths are different.

sudo tee /etc/systemd/system/radarr.service >/dev/null <<'EOF'
[Unit]
Description=Radarr Daemon
After=network-online.target remote-fs.target
Wants=network-online.target
RequiresMountsFor=/data/media /data/downloads

[Service]
User=radarr
Group=media
UMask=0002
Type=simple
ExecStart=/opt/Radarr/Radarr -nobrowser -data=/var/lib/radarr/
Restart=on-failure
TimeoutStopSec=20
KillMode=process

[Install]
WantedBy=multi-user.target
EOF

sudo systemctl daemon-reload
sudo systemctl enable --now radarr
systemctl status radarr --no-pager
journalctl -u radarr --since "10 minutes ago" --no-pager
ss -ltnp | grep ':7878' || true

If Radarr starts but cannot import, the issue is usually not the binary. Check group membership, mount ownership, and whether Radarr sees the same completed-download path that SABnzbd reports.

Updates and Backups

The important rebuild asset is Radarr's config directory. For Docker, that is the folder mapped to /config. For the native install, it is commonly /var/lib/radarr. That folder contains the database, movie records, quality profiles, custom formats, indexer settings, download client settings, lists, exclusions, tags, API key, history, and backups.

# Docker Compose update
cd /opt/media-stack
docker compose pull radarr
docker compose up -d radarr
docker compose logs --tail=100 radarr

# Native service checks
sudo systemctl status radarr
sudo journalctl -u radarr --since "30 minutes ago"

A good backup plan copies Radarr's config directory to NAS or another system, not just another folder on the same boot disk. Also keep a short restore note with the install type, service user, group, root folders, download categories, and any reverse proxy hostname. In a crash, that note saves more time than you think.

Path Planning

Radarr root folders are final movie library folders. They are not download folders. The download client should never place completed or incomplete files directly into a Radarr root folder. Radarr imports from the download area into the movie library. Plex and Tdarr should operate on the final library folders.

/data
  /downloads
    /usenet
      /movies
      /tv
    /torrents
      /movies
      /tv
  /media
    /movies
    /movies-animated
    /movies-comedy
    /tv

• Default movie root: /data/media/movies
• Animated movie root: /data/media/movies-animated
• Stand-up or comedy root: /data/media/movies-comedy
• SABnzbd movie category: /data/downloads/usenet/movies
• Tdarr movie libraries: final media roots only

Separate roots are useful when they reflect real Plex libraries or real retention rules. They are not useful if they become a dumping ground. If all movies should ultimately live in one Plex library, keep them under one root and use Radarr tags or Plex collections for organization.

Permissions

Radarr needs read and write access to the completed download folder and the final movie root. The download client needs write access to the download folder. Plex needs read access to the final library. Tdarr needs read and write access to the final library if it replaces files. The simplest Linux model is a shared media group and a cooperative umask.

sudo groupadd -f media
sudo usermod -aG media radarr
sudo usermod -aG media sabnzbd
sudo usermod -aG media plex
sudo usermod -aG media tdarr
sudo chgrp -R media /data
sudo chmod -R g+rwX /data

For Docker, make PUID, PGID, and UMASK match across the media containers. For native services, check systemd. A permissions setup is not done until new downloads, new imports, renamed files, and Tdarr replacements all inherit usable permissions automatically.

Initial Radarr Configuration

Media Management

• Enable advanced settings.
• Enable movie renaming.
• Use movie folders, not a flat folder full of files.
• Use a naming scheme that includes movie title, year, quality, edition when available, and release group when useful.
• Enable completed download handling.
• Enable hardlinks or atomic moves where storage supports them.
• Set propers and repacks to Do Not Prefer when using custom format scoring for repack/proper behavior.

Movie folders should include the year. That helps Radarr match existing libraries correctly and avoids confusion with remakes, foreign titles, or similarly named movies.

Root Folders

Add only final library roots. A clean setup might have Movies, Animated Movies, and Comedy roots if those are real Plex destinations. Each list and each manually added movie should land in the root that matches how you actually browse the library.

Download Client

• Use a dedicated category such as movies.
• Point the category to the movie download path, not the movie root.
• Keep completed download handling enabled.
• Keep download history long enough for Radarr to import completed jobs.
• Do not let SABnzbd sorting place movies in the final Radarr library.
• Use separate categories for Radarr and Sonarr.

Quality Profiles

Quality profiles are where you define the tradeoff between quality, storage, and patience. If you want an efficient Plex library, do not simply enable every possible quality and set the cutoff to the largest thing. Decide what you want Radarr to chase, then let Tdarr optimize after import.

• Balanced 1080p: WEB 1080p and Bluray 1080p, with a cutoff that stops when a good 1080p release is found.
• Quality-first 1080p: allow higher bitrate Bluray 1080p, reward good release groups, and use a higher custom format score target.
• 4K/HDR: separate profile and root, with Dolby Vision and HDR rules that match your playback devices.
• Kids or animated movies: separate root and profile if you want smaller files, safer language rules, or easier Plex library separation.
• Stand-up comedy: usually 1080p WEB is enough; avoid overpaying in storage for marginal visual gain.

If your final standard is HEVC/H.265 10-bit, reward those releases in Radarr when they are available, but do not make Radarr redownload endlessly for a codec target that Tdarr can produce from a better source. A high-quality H.264 source can become an efficient HEVC 10-bit file after Tdarr. A bad x265 release may remain bad forever.

Custom Formats

Custom formats are one of Radarr's strongest features. They allow release prioritization far beyond the basic quality label. Radarr uses custom formats inside quality profiles, with a minimum score for allowed grabs and an upgrade-until score for knowing when to stop upgrading.

A strong Plex plus Tdarr custom format strategy usually does four things:

1. Reject bad releases. Penalize low-quality, cam, telesync, hardcoded subtitles, wrong language, upscaled, fake, BR-DISK, and other unwanted patterns.
2. Prefer good sources. Reward strong WEB and Bluray sources, known good release groups, and editions you actually want.
3. Protect playback compatibility. Be careful with Dolby Vision, HDR10+, and audio formats your Plex clients cannot direct play.
4. Prefer efficient outcomes. Reward HEVC/H.265 and 10-bit where appropriate, but keep quality and source integrity above codec chasing.

The TRaSH Guides are the practical reference here. They maintain Radarr custom format collections, quality size recommendations, profile examples, and naming recommendations. You can import custom formats manually or use sync tools to keep them aligned. The main thing is to treat the TRaSH values as a starting point, then tune for your storage, displays, playback clients, and tolerance for re-downloads.

A Better Cutoff Strategy

A bad cutoff strategy says, "keep upgrading until the biggest quality label appears." A better cutoff strategy says, "stop when the movie is good enough for the way I actually watch it."

• Use minimum custom format scores to block obviously bad releases.
• Use upgrade-until scores to keep improving until a release matches your real target.
• Set 4K targets only for movies that deserve 4K in your library.
• Do not let a tiny custom format score difference cause endless upgrades.
• Prefer good source quality over tiny file size before Tdarr processing.
• Let Tdarr handle final file-size policy after import.

For many homelabs, a good Radarr target is a strong 1080p WEB or Bluray release, preferably English, with no unwanted hardcoded subtitles, no low-quality flags, and a format profile that Tdarr can safely convert or skip. That creates a library that looks good, streams well, and does not waste storage chasing perfection for every movie.

List Integration

Lists are powerful because they can turn Radarr from a manual movie tracker into a curated intake system. They are also dangerous because a noisy list can add hundreds of movies you never wanted. The best approach is curated, tagged, and destination-aware.

Recommended List Types

• Personal watchlist: high trust, usually safe for search on add.
• Popular good movies: use a filtered list provider such as MDBList or Trakt with rating, vote count, release year, and language filters.
• New high-quality releases: use a list that updates frequently and filters out low-rated or low-vote noise.
• Children's animated movies: use a dedicated list and send it to an animated movie root folder if you keep that library separate.
• Stand-up comedy: use a dedicated comedy list and send it to a comedy root folder or tag it clearly.

List Settings That Matter

• Root folder: the final destination for movies added by that list.
• Quality profile: the quality policy list-added movies should follow.
• Tags: add tags like list-mdblist-popular, list-watchlist, list-animated, or list-comedy.
• Search on add: enable only when you trust the list and want immediate acquisition.
• Monitor: usually enabled for movies you genuinely want Radarr to manage and upgrade.
• Clean library level: keep disabled unless you are intentionally making the list authoritative for removal decisions.
• List exclusions: use exclusions to prevent the same unwanted movies from being re-added later.

Tags are more valuable than they look. They let you answer questions later: did this movie come from a list, a manual add, a request system, or a watchlist? They also let you filter Radarr before bulk editing, searching, or deleting. A library with list tags is much easier to audit than a library where everything looks manually added.

How To Avoid List Noise

For a "popular good movies" list, do not use popularity alone. Popularity catches buzz, marketing, controversy, and franchise noise. Better lists combine popularity with vote count, rating, release date, language, genre filters, and sometimes runtime or certification. MDBList is useful because it can build filtered lists across multiple data sources, then expose them to Radarr.

• Require enough votes so brand-new unknown items do not flood the list.
• Require a reasonable rating floor.
• Filter to languages you actually want.
• Exclude genres you never watch.
• Use separate lists for family animation, comedy, documentaries, or niche interests.
• Review new list additions before enabling aggressive search behavior.

If you later decide a list imported junk, remove those movies through Radarr and add them to list exclusions when appropriate. Do not just delete files behind Radarr's back. Radarr needs to know what changed or the same items may return on the next list sync.

Import Hygiene

Import hygiene is the difference between a library that can be rebuilt and a library that only works because nobody touches it. The rules are simple, but they need to be followed consistently.

• Every movie gets its own folder.
• Movie folders include the movie title and year.
• Download folders are never Radarr root folders.
• Radarr imports completed downloads. The download client does not sort into the library.
• Manual imports are reviewed before moving files.
• Root folder changes are made in Radarr, not only in the filesystem.
• Renames are done through Radarr so its database stays accurate.
• Deleted list movies are excluded if you do not want them re-added.

Tie-In With Tdarr

The companion Tdarr build shows how to process imported media with GPU workers, standardize to HEVC/H.265 10-bit, remove unwanted audio and commentary tracks, keep English subtitles, validate output, refresh Plex, and rescan Radarr or Sonarr after replacement. You can read it here: Building a Production-Grade Tdarr GPU Transcoding Stack for a Homelab.

Radarr and Tdarr should cooperate like this:

• Radarr chooses and imports a good source file.
• Tdarr waits until the file is settled before processing.
• Tdarr skips files already meeting codec, bit-depth, size, audio, and subtitle policy.
• Tdarr re-encodes files that are too large or not in the desired format.
• Tdarr validates the output before replacing the original.
• Tdarr refreshes Plex after replacement.
• Tdarr triggers a Radarr rescan so file size, codec, runtime, and MediaInfo are current.

That last step is essential. If Tdarr replaces a file and Radarr does not rescan it, Radarr may still think the movie is the old codec, old size, or old quality. Your upgrade logic then starts making decisions based on stale data.

Should Radarr Redownload Everything?

Usually, no. A smarter approach is to separate source quality from final file optimization. Use Radarr to redownload when the current source is genuinely bad, incomplete, wrong language, wrong edition, too low quality, or below your real cutoff. Use Tdarr to optimize files that are good sources but not in your final codec or size target.

Redownloading the entire library can burn indexer API calls, fill queues, stress storage, and create a lot of churn without a visible improvement. It makes sense for bad files. It does not make sense for every H.264 file if Tdarr can convert it safely from a good source.

Validation and Evidence

1. Add one test movie manually with the normal movie root and profile.
2. Search interactively and confirm Radarr scores releases the way you expect.
3. Send one release to the download client.
4. Confirm the category and download path are correct.
5. Confirm Radarr imports to the movie root and renames correctly.
6. Confirm Plex sees the movie.
7. Let Tdarr process or skip the file.
8. Confirm Plex refreshes after Tdarr.
9. Confirm Radarr rescans and MediaInfo reflects the final file.
10. Only then enable list search on add for trusted lists.

These are reader-run acceptance checks, not results observed by TechGeeks. Record the Radarr version, install method, container or service identity, exact host and container paths, download category, test item, selected release score, import log, final ownership, Plex refresh, and post-Tdarr Radarr rescan. Keep API keys, provider credentials, and identifying library data out of screenshots.

Rollback and Failure Handling

Before an update, profile rewrite, root-folder move, list rollout, or Tdarr handoff change, stop broad automation and copy the Radarr config directory to a separate target. Export or capture the current profiles, custom-format scores, root folders, list tags, download-client category, service identity, and path mappings. Keep the previous image tag or package and do not delete the old config or movie path during the validation window.

• Update failure: stop Radarr, restore the prior package or image and the matching config backup, then start it without enabling searches.
• Import failure: pause the queue, compare the path reported by the download client with Radarr's visible path, and correct ownership or mappings before retrying one item.
• Profile or list churn: disable automatic search and the affected list, restore the recorded scores or tags, and use list exclusions where rejected titles would return.
• Root-folder move failure: return Radarr to the original root and preserve both trees until database paths, files, Plex visibility, and permissions agree.
• Tdarr replacement failure: stop further processing, retain or restore the source file, refresh Plex, and rescan Radarr only after the replacement validates.

Operational Checklist

• Radarr health checks are clean.
• Config backups are stored off-box or on NAS storage.
• Root folders match Plex library design.
• Download folders are separate from root folders.
• Prowlarr-managed indexers are tested.
• Download client categories are separate for movies and TV.
• Quality profiles have realistic cutoff and custom format scores.
• TRaSH custom formats are imported, reviewed, and tuned.
• Lists are tagged by source.
• List exclusions are used for rejected imports.
• Tdarr refreshes Plex and rescans Radarr after replacement.

Troubleshooting

Radarr Says Downloads Are In The Wrong Folder

Check the path reported by the download client. If SABnzbd says the completed file is in one path and Radarr cannot see that same path, the import will fail. Fix the Docker volume mappings or add a remote path mapping only when the applications truly need different paths.

Movies Keep Coming Back From Lists

Use Radarr's list exclusions. If you delete a movie but do not exclude it, the same list may add it again during the next sync. Also check whether multiple lists are adding the same movie under different tags.

Radarr Keeps Upgrading Too Much

Review the quality cutoff, upgrade-until custom format score, minimum custom format score for upgrades, and whether a tiny scoring difference is enough to trigger another download. Custom formats are powerful, but a scoring model with no practical stopping point will create churn.

Plex Shows Old Codec Or File Size

After Tdarr replaces a file, Plex needs a refresh and Radarr needs a rescan. If only one side updates, your library presentation or Radarr metadata may stay stale.

Security, Privacy, Legal, and Recovery Boundaries

• Security: keep the Radarr UI and API private or behind deliberately configured access controls, use separate service credentials, patch supported components, and restrict filesystem permissions to the required media paths.
• Privacy: movie history, list choices, request sources, logs, API keys, paths, and public hostnames can reveal household interests and infrastructure. Limit retention and redact them from shared diagnostics.
• Legal: use indexers, lists, download clients, and media only where authorized. Check provider terms and local law; a technically successful workflow does not establish a right to obtain or process an item.
• Recovery: protect Radarr config, credentials, path documentation, and any irreplaceable media metadata off-box. Keep source media or a recoverable copy until import, Plex visibility, optional Tdarr replacement, and Radarr rescan all pass.

What This Validation Does Not Prove

One successful movie does not prove every release, edition, language, client, mount, or list will behave the same way. A clean Radarr health page does not prove that a config backup restores, that Plex can direct play the final file, or that Tdarr preserved every required stream. An import log does not prove the source was lawful or the final media is correct.

A working hardlink or atomic move does not prove protection from deletion, filesystem damage, ransomware, or host loss. A list filter does not prove future additions will remain relevant, and TRaSH recommendations do not prove their scores match this household's displays, languages, storage budget, or playback clients.

Final Recommended Baseline

• Run Radarr through Docker Compose or a clean systemd install.
• Use a shared /data layout across Radarr, Sonarr, download clients, Plex, and Tdarr.
• Keep movie download folders separate from movie root folders.
• Use Prowlarr for indexer sync.
• Use TRaSH-based custom formats, then tune for your playback devices.
• Use curated list imports, not noisy popularity-only lists.
• Tag list-added movies by source.
• Use list exclusions for movies you reject.
• Let Radarr select good source files and Tdarr optimize final files.
• Refresh Plex and rescan Radarr after Tdarr replacements.

That setup gives you control without giving up automation. Radarr brings in movies intentionally, Sonarr handles TV with the same discipline, and Tdarr turns the final library into a consistent, efficient Plex collection.

Related TechGeeks

Use the linked storage and Prowlarr guides to establish paths and indexers before broad Radarr automation. The focused list and custom-format guides extend the two highest-churn decisions, while monitoring and disaster-recovery coverage show how to detect and recover failures after the movie workflow is active.

• Plex Homelab Architecture: Storage, GPU Transcoding, and Library Design
• Media Server Storage Design: NAS, CIFS/NFS Mounts, Permissions, and Local Cache
• Prowlarr Setup Guide: Clean Indexer Management for Sonarr and Radarr
• Sonarr Homelab Setup Guide: Install, Update, Optimize, and Connect to Tdarr
• Radarr Homelab Setup Guide: Install, Update, Optimize, Lists, and Tdarr Integration
• SABnzbd Performance Tuning for a Homelab Media Server
• Plex + Tdarr GPU Strategy: Sharing NVIDIA GPUs Without Hurting Playback
• Reverse Proxy for Media Apps: Nginx Proxy Manager, SSL, Access Lists, and Security
• Backup and Disaster Recovery for Plex, Sonarr, Radarr, Tdarr, Prowlarr, and SABnzbd
• Radarr Import Lists That Do Not Fill Your Library With Junk
• Custom Formats and Quality Profiles Explained for Radarr and Sonarr
• Monitoring and Health Checks for a Plex and Arr Homelab
• The Complete Plex, Arr, and Tdarr Homelab Media Automation Series

Related foundation: Building a Production-Grade Tdarr GPU Transcoding Stack for a Homelab.

References

• Radarr official site
• Servarr Radarr Linux Installation
• Servarr Radarr Quick Start Guide
• Servarr Radarr Settings
• Servarr Radarr System and health checks
• Servarr Docker Guide
• TRaSH Guides for Radarr
• TRaSH hardlinks and instant moves
• Tdarr health checks
• Production-grade Tdarr GPU transcoding stack