How to Install Radarr on Ubuntu 24.04 — Self-Hosted Movie Automation

Radarr turns movie collecting from a manual chore into an automated pipeline. You tell it what you want, it watches for releases that match your quality rules, grabs them through your download client, renames and organizes the files, and drops them in a folder that Plex or Jellyfin picks up automatically. This guide walks you through installing Radarr v5 on an Ubuntu 24.04 VPS, wiring it up to a download client and Prowlarr, configuring the quality and custom format rules that separate a messy library from a curated one, and publishing the UI securely behind Nginx with HTTPS.

Heads up: Radarr does not download or provide any copyrighted content. It is a metadata and automation tool. Make sure you comply with the copyright laws in your jurisdiction and only manage content you are legally entitled to.

Table of Contents

What is Radarr?

Radarr is an open-source movie collection manager that forked from Sonarr to handle movies instead of TV shows. It's part of the broader "Servarr" family alongside Sonarr (TV), Prowlarr (indexers), Lidarr (music), Readarr (books), and Bazarr (subtitles).

Radarr's job is essentially three things. First, it keeps a catalog of movies you want — either added manually or pulled from a list (your IMDb watchlist, a Trakt collection, a Letterboxd list). Second, it monitors indexers for releases matching those movies and your quality rules, and when a suitable release shows up it hands the download off to your download client. Third, once the file lands, it renames, moves, and organizes it into a clean folder structure that media servers like Plex and Jellyfin can read.

Radarr v5 runs on .NET 6, uses SQLite or PostgreSQL as its database, ships a clean web UI on port 7878, exposes a REST API for integrations, and handles tens of thousands of movies without strain. It's the automation layer that makes a self-hosted movie library feel like Netflix — except you choose what's on it, you own the files, and nothing gets pulled from the catalog because a licensing deal expired.

Why Self-Host Movie Automation Instead of Streaming Services?

Subscription streaming looks convenient until you add up what it costs and what you actually get. A Radarr-powered self-hosted library gives you a fundamentally different deal:

• You own the files. Movies don't vanish when a licensing deal expires. If a title is in your library, it stays in your library. No "this title is no longer available in your region."
• One subscription, everything accessible. Instead of paying for Netflix + Disney+ + Max + Apple TV + Paramount+ to chase specific titles, you maintain one library and pay once per VPS month.
• Quality you actually choose. Streaming services compress aggressively, and even their "4K" tiers are typically 15-25 Mbps. A 1080p Blu-ray remux is 30-40 Mbps. A 4K HDR remux is 80-100 Mbps. If you care about picture quality, self-hosting is the only option that gives you reference-grade files.
• No ads, no autoplay, no UI redesigns. Your interface is Plex or Jellyfin, not whatever a streaming service's design team pushed last week.
• Privacy. Your viewing habits stay on your server. No data is sold, no recommendations are driven by an algorithm optimized to retain you.
• Offline-friendly. Files live on a disk. You can sync to a laptop for flights or a road trip without worrying about offline-download DRM expiring mid-movie.
• Integrations you can't get elsewhere. Automatic subtitle fetching, upgrade-on-better-release, deleted-movie alerts, IMDb-list-synced libraries. None of this exists in any streaming app.

Cost Comparison: Streaming Bundle vs. Self-Hosted

Prerequisites

Before you start, confirm you have:

• A VPS running Ubuntu 24.04 LTS with root or sudo access
• SSH access from your workstation
• At least 2 GB of RAM (Radarr itself is light; more helps if you run Sonarr/Prowlarr/Jellyfin alongside)
• Enough disk space for your planned library — plan for at least 500 GB for a starter 1080p collection
• A domain name pointing at the VPS (required for the TLS step)

Recommended Plan: CloudCore Starter

For a Radarr + Sonarr + Prowlarr + Bazarr stack on one host, we recommend the CloudCore Starter plan:

- 4 vCPU cores

- 8 GB RAM

- 200 GB NVMe SSD (add block storage for the movie library)

- Unmetered bandwidth

- EUR 7.99/month

This leaves plenty of headroom for running the whole Servarr stack plus Jellyfin or Plex on a single VPS. For larger 4K-focused libraries, scale up the storage with additional block volumes.

Connect to the server over SSH:

ssh root@your-server-ip

Step 1: Update System Packages

Always start with a current system. This pulls the latest security patches and makes sure apt dependency resolution behaves correctly during the Radarr install.

sudo apt update && sudo apt upgrade -y

Install a few tools the installer will need:

sudo apt install -y curl sqlite3 ca-certificates gnupg

If the kernel was updated, reboot:

sudo reboot

Reconnect once the server is back.

Step 2: Install Radarr v5

The Servarr team publishes an official install script that handles everything: downloading the correct .NET 6 bundle for your architecture, creating a dedicated radarr user, placing the application in /opt/Radarr, and installing a systemd service.

Run the installer:

curl -s https://raw.githubusercontent.com/Servarr/Wiki/master/servarr/servarr-install-script.sh | sudo bash

The script asks a few questions interactively:

Select the application to install:
  1) Lidarr
  2) Prowlarr
  3) Radarr
  4) Readarr
  5) Sonarr
  6) Whisparr

Choose 3 for Radarr. Then:

Enter the user account to run Radarr as (default: radarr):  radarr
Enter the group for this user (default: media):             media
Enter the data directory (default: /var/lib/radarr):        /var/lib/radarr

Accept the defaults unless you have a reason to deviate. The media group is a common convention that lets Radarr, Sonarr, Jellyfin, and your download client all share access to the same files without permission friction.

Expected output (abbreviated):

Creating user 'radarr' and group 'media'...
Downloading Radarr v5.x.x.xxxx linux-x64...
Extracting to /opt/Radarr...
Installing systemd unit /etc/systemd/system/radarr.service...
Enabling radarr.service...
Starting radarr.service...
Install complete. Radarr is available at http://<host>:7878

Verify the service is up:

sudo systemctl status radarr

You should see Active: active (running). If firewalls are in play, open port 7878 temporarily so you can reach the web UI (we'll close this again once Nginx is in front of it):

sudo ufw allow 7878/tcp

Step 3: First Login and Authentication

Open http://your-server-ip:7878 in a browser. Radarr v5 requires authentication by default — you'll be prompted to set it up on first run.

Choose Forms (Login Page) as the authentication method and create a username and password. Set Authentication Required to Enabled (rather than Disabled for Local Addresses) since you'll be exposing this through Nginx later.

Once logged in, head to Settings → General and take note of:

• The API Key (you'll use this to connect Prowlarr and other tools)
• The Bind Address (leave as * so Nginx can reach it on localhost)
• The URL Base (leave empty for now; set it later if you want to serve Radarr at /radarr/)

Step 4: Configure a Download Client

Radarr doesn't download anything itself — it hands magnet links or NZBs off to a download client. The three most common choices are qBittorrent (torrents), Deluge (torrents), and SABnzbd or NZBGet (Usenet).

This section uses qBittorrent as the example; the flow is nearly identical for the others.

Install qBittorrent-nox

sudo apt install -y qbittorrent-nox

Create a systemd service to run qBittorrent as the radarr user (so file permissions line up):

sudo tee /etc/systemd/system/qbittorrent.service > /dev/null <<'EOF'
[Unit]
Description=qBittorrent-nox
After=network.target
[Service]
Type=simple
User=radarr
Group=media
UMask=0002
ExecStart=/usr/bin/qbittorrent-nox --webui-port=8080
Restart=on-failure
[Install]
WantedBy=multi-user.target
EOF

Start and enable:

sudo systemctl daemon-reload
sudo systemctl enable --now qbittorrent

Open http://your-server-ip:8080. The default credentials on first launch are printed in the service log:

sudo journalctl -u qbittorrent --no-pager | grep -i "temporary password"

Log in, accept the EULA, and immediately set a real username and password under Tools → Options → Web UI.

Wire qBittorrent Into Radarr

In Radarr, go to Settings → Download Clients → + → qBittorrent and fill in:

• Name: qBittorrent
• Host: localhost
• Port: 8080
• Username and Password: the qBittorrent credentials
• Category: radarr (Radarr will create this category so it can track its own downloads separately from anything else in the client)

Then under Settings → Download Clients → Completed Download Handling, make sure Enable and Remove Completed are both on, so Radarr imports finished downloads and qBittorrent cleans up after it.

Step 5: Connect Indexers via Prowlarr

Indexers are the search engines Radarr uses to find releases. You can add indexers one by one directly in Radarr, but Prowlarr exists specifically to manage indexers centrally and push them to Radarr, Sonarr, Lidarr, and Readarr simultaneously.

Install Prowlarr with the same Servarr script (choose option 2 this time):

curl -s https://raw.githubusercontent.com/Servarr/Wiki/master/servarr/servarr-install-script.sh | sudo bash

Prowlarr runs on port 9696. Complete the authentication setup the same way you did for Radarr, then:

Prowlarr will immediately push every configured indexer into Radarr. Back in Radarr, Settings → Indexers should now show them all. Any new indexer you add in Prowlarr going forward appears in Radarr automatically.

Step 6: Root Folders and Media Management

A root folder is where Radarr stores imported movies. This is what Plex or Jellyfin points at. Conventionally it lives on a dedicated data disk or block storage volume, not the VPS root disk.

Assuming you have a block volume mounted at /mnt/media, create the movie folder:

sudo mkdir -p /mnt/media/movies
sudo chown -R radarr:media /mnt/media/movies
sudo chmod -R 775 /mnt/media/movies

Also align the download client's save path:

sudo mkdir -p /mnt/media/downloads
sudo chown -R radarr:media /mnt/media/downloads

In qBittorrent Tools → Options → Downloads, set the default save location to /mnt/media/downloads.

In Radarr, go to Settings → Media Management and configure:

• Rename Movies: Yes
• Standard Movie Format: {Movie CleanTitle} ({Release Year}) {Quality Full}
• Movie Folder Format: {Movie CleanTitle} ({Release Year})
• Create empty movie folders: No
• Delete empty folders: Yes
• Use Hardlinks instead of Copy: Yes (saves disk space if downloads and library are on the same filesystem)
• Unmonitor Deleted Movies: Yes

Step 7: Quality Profiles

Quality profiles tell Radarr what release quality to accept and prefer. Go to Settings → Profiles → Quality Profiles.

Radarr ships with defaults, but most people want a profile tailored to their preferences. Here are two that cover the common cases:

Profile: "Standard 1080p"

• Qualities allowed: WEBDL-1080p, Bluray-1080p, Bluray-1080p Remux
• Upgrades allowed: Yes
• Upgrade until: Bluray-1080p

Profile: "4K HDR"

• Qualities allowed: WEBDL-2160p, Bluray-2160p, Bluray-2160p Remux
• Upgrades allowed: Yes
• Upgrade until: Bluray-2160p Remux

Apply a profile per movie (on the movie's edit page) or set a default profile under Settings → Media Management.

Step 8: Custom Formats

Custom formats are how Radarr distinguishes between releases of the same nominal quality. A 1080p WEB-DL from one source can be a beautifully encoded 8 GB file with Atmos audio, while another is a 2 GB re-encode with stereo. Custom formats let you prefer the former.

The TRaSH Guides are the gold-standard reference for Radarr custom formats. Rather than building formats by hand, install the companion tool Recyclarr to sync TRaSH-recommended formats automatically.

Install Recyclarr:

sudo mkdir -p /opt/recyclarr
cd /opt/recyclarr
curl -L https://github.com/recyclarr/recyclarr/releases/latest/download/recyclarr-linux-x64.tar.xz | sudo tar -xJ
sudo chmod +x /opt/recyclarr/recyclarr
sudo ln -s /opt/recyclarr/recyclarr /usr/local/bin/recyclarr

Generate a starter config:

recyclarr config create

Edit ~/.config/recyclarr/recyclarr.yml to enable the TRaSH Radarr HD Bluray + WEB template and reference your Radarr instance with its API key, then sync:

recyclarr sync radarr

This creates the recommended custom formats in Radarr, assigns scores, and maps them to your quality profiles. Schedule it to run weekly with a cron entry so TRaSH's updated scoring keeps flowing in:

sudo crontab -e -u radarr

Add:

0 3   0 /usr/local/bin/recyclarr sync radarr

Step 9: Import IMDb and Trakt Lists

Lists turn Radarr from a manual catalog into a subscription. Add your IMDb watchlist or a Trakt collection and Radarr will auto-add any movie on that list.

Go to Settings → Lists → + → and choose:

IMDb List

• Name: My Watchlist
• List ID: the ls... or ur... ID from the IMDb list URL (e.g. ur12345678 is your personal watchlist ID; find it by going to your IMDb profile and looking at the URL)
• Quality Profile: Standard 1080p
• Root Folder: /mnt/media/movies
• Monitor: Yes
• Search on Add: No (let the regular RSS sync find releases)

• Name: Trakt Collection
• Authenticate with your Trakt account via OAuth
• List Type: User Custom List / User Watchlist / Popular
• Configure quality profile and root folder as above

Step 10: Nginx Reverse Proxy with TLS

Exposing port 7878 directly to the internet is a bad idea. Put Nginx in front of it with a Let's Encrypt certificate.

Install Nginx and Certbot:

sudo apt install -y nginx certbot python3-certbot-nginx

Create the site config:

sudo tee /etc/nginx/sites-available/radarr > /dev/null <<'EOF'
server {
    listen 80;
    server_name radarr.yourdomain.com;
    return 301 https://$host$request_uri;
}
server {
    listen 443 ssl http2;
    server_name radarr.yourdomain.com;
    # TLS certificates populated by Certbot below
    ssl_certificate     /etc/letsencrypt/live/radarr.yourdomain.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/radarr.yourdomain.com/privkey.pem;
    # Reasonable TLS defaults
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers HIGH:!aNULL:!MD5;
    # Security headers
    add_header X-Content-Type-Options nosniff;
    add_header X-Frame-Options SAMEORIGIN;
    add_header Referrer-Policy strict-origin-when-cross-origin;
    client_max_body_size 20m;
    location / {
        proxy_pass http://127.0.0.1:7878;
        proxy_http_version 1.1;
        proxy_set_header Host              $host;
        proxy_set_header X-Real-IP         $remote_addr;
        proxy_set_header X-Forwarded-For   $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        # Required for Radarr's SignalR websocket
        proxy_set_header Upgrade    $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_buffering off;
        proxy_read_timeout 600s;
    }
}
EOF

Enable and obtain a certificate:

sudo ln -s /etc/nginx/sites-available/radarr /etc/nginx/sites-enabled/
sudo nginx -t
sudo certbot --nginx -d radarr.yourdomain.com
sudo systemctl reload nginx

Now close direct access to port 7878 at the firewall since Nginx is proxying it:

sudo ufw delete allow 7878/tcp
sudo ufw allow 'Nginx Full'
sudo ufw status

Radarr is now reachable at https://radarr.yourdomain.com over HTTPS, and only port 80/443 are exposed to the internet.

Manual Install from the Tarball

The Servarr script is the recommended path, but if you need manual control (custom install location, air-gapped server, or an unusual distro) you can install Radarr from the official tarball.

Install the .NET 6 runtime first:

sudo apt install -y aspnetcore-runtime-6.0

Download and extract Radarr:

cd /tmp
curl -L -o Radarr.master.tar.gz "https://radarr.servarr.com/v1/update/master/updatefile?os=linux&runtime=netcore&arch=x64"
sudo tar -xzf Radarr.master.tar.gz -C /opt
sudo chown -R radarr:media /opt/Radarr

Create the systemd unit:

sudo tee /etc/systemd/system/radarr.service > /dev/null <<'EOF'
[Unit]
Description=Radarr Daemon
After=syslog.target network.target
[Service]
User=radarr
Group=media
UMask=0002
Type=simple
ExecStart=/opt/Radarr/Radarr -nobrowser -data=/var/lib/radarr
TimeoutStopSec=20
KillMode=process
Restart=on-failure
[Install]
WantedBy=multi-user.target
EOF

Enable and start:

sudo mkdir -p /var/lib/radarr
sudo chown -R radarr:media /var/lib/radarr
sudo systemctl daemon-reload
sudo systemctl enable --now radarr

Then follow Step 3 onwards in this guide.

Troubleshooting

Viewing Logs

Stream live Radarr logs:

sudo journalctl -u radarr -f

Or dig into Radarr's own application logs (more detail than systemd's):

sudo tail -f /var/lib/radarr/logs/radarr.txt

FAQ

Is Radarr legal to use?

Radarr itself is free, open-source software that manages metadata and automates your media library. It does not download or provide any copyrighted content. Legality depends entirely on what you do with it: organizing movies you legally own (DVD/Blu-ray rips, purchased digital copies) is fine, while downloading copyrighted material without a license is illegal in most jurisdictions.

Do I need Sonarr and Radarr separately?

Yes. Radarr handles movies and Sonarr handles TV shows. They share the same codebase and UI conventions but are separate applications with different metadata providers (TMDb for movies, TheTVDB for shows) and folder structures. You typically run both alongside Prowlarr for shared indexer management.

How much disk space do I need for Radarr?

Radarr's application files and database use less than 1 GB. Storage requirements are driven entirely by your movie library. A 1080p Blu-ray remux is typically 25-40 GB per movie, a 1080p WEB-DL is 4-8 GB, and a 4K HDR remux can exceed 60 GB. For a starter library of 100 1080p movies, budget around 500-800 GB.

Can I run Radarr without a VPN?

Radarr itself doesn't need a VPN because it only communicates with indexers and your download client over HTTPS for metadata. However, the download client (qBittorrent, Deluge) may benefit from a VPN depending on your jurisdiction and content. Many users route only the download client through a VPN container and leave Radarr on the direct connection.

What's the difference between Radarr v4 and v5?

Radarr v5 runs on .NET 6 (instead of Mono on v4), has significantly better performance and memory usage, supports custom formats natively in the UI, and has improved PostgreSQL support. v4 reached end-of-life in 2024, and all new installs should target v5.

Do I need Prowlarr, or can I add indexers directly?

You can add indexers directly in Radarr, but Prowlarr is strongly recommended. Prowlarr lets you manage all your indexers in one place and automatically syncs them to Radarr, Sonarr, Lidarr, and Readarr. Without Prowlarr, you'd have to add and maintain every indexer in every app separately.

How do I back up my Radarr configuration?

Radarr has a built-in backup system at Settings → General → Backup. It creates a zip of the database and config.xml. Back up the full /var/lib/radarr directory for disaster recovery. Enable scheduled backups and copy them off-server (rsync to S3, Backblaze B2, or another VPS) at least weekly.

Next Steps

Now that Radarr is running cleanly, here are the logical next additions to complete the stack:

• Install Sonarr — Do for TV shows what Radarr does for movies. Shares the same install script, same patterns, same Prowlarr integration.
• Install Prowlarr — If you haven't already, this is the single biggest quality-of-life improvement for any Servarr setup.
• Install Bazarr — Automatic subtitle downloading in any language, synced to your Radarr and Sonarr libraries.
• Install Jellyfin or Plex — The media server that actually plays the files. Point it at /mnt/media/movies and it picks up everything Radarr drops in.
• Read the Servarr Wiki — The official documentation covers advanced topics like PostgreSQL migration, release profiles, and the full REST API reference.
• Subscribe to the TRaSH Guides — The community bible for quality profiles and custom formats. Re-sync your Recyclarr config whenever the guides update.

Ready to build your self-hosted media stack?

The CloudCore Starter plan is the sweet spot for running the full Servarr stack plus a media server on a single VPS:

- 4 vCPU cores / 8 GB RAM / 200 GB NVMe SSD

- Unmetered bandwidth

- Add block storage volumes for the movie library

- EUR 7.99/month

Launch a Starter VPS and start building your library tonight.