Jellyseerr Tagging Workflows for Real Libraries

You Have Five Friends with Accounts and Zero Accountability

You remember adding them. You thought it’d be fine. One is your roommate. One is your sister-in-law. One is that guy from work who “just wants to watch one thing.” Now it’s eight months later, your Radarr queue has 47 pending movies, your 4K library is somehow full, and someone requested a three-season animated series in UHD that nobody in the house watches.

Whose request was that? You genuinely cannot tell. Jellyseerr says “Requested by: Local User.” That’s it. That’s the audit trail.

Here’s the thing: Jellyseerr has a tagging system that passes request metadata directly into Sonarr and Radarr. When you wire it up correctly, every request carries a label — who asked, what quality they’re allowed, and whether that content gets nuked in 30 days if nobody watches it. You go from “mystery library” to a system where every file traces back to a person, a quality profile, and a retention policy.

This is how you build that.

Why Tags Are the Load-Bearing Wall

Sonarr and Radarr both have a tag system that most people ignore. Tags on their own do nothing — they’re just sticky notes. The power comes from what you attach to those tags:

• Quality profiles — gate who gets 4K vs 1080p vs 720p-web
• Root folders — physically separate libraries on disk
• Indexer restrictions — limit which trackers/indexers fetch content for a tag
• Delay profiles — make certain users wait longer before a grab triggers
• Maintainerr rules — delete content associated with a tag after N days

When Jellyseerr passes a tag to Sonarr or Radarr on a request, that tag becomes the hook for all of the above. Tag user-alice on a movie, and Sonarr/Radarr can automatically apply Alice’s quality profile, download to Alice’s root folder, and Maintainerr knows to clean it up if Alice stops watching.

One tag. Everything else follows.

Step 1: Create Your User Tags in Sonarr and Radarr

First, create the tags in both apps before you touch Jellyseerr. Go to Settings → Tags in each app and add one tag per user:

user-alice
user-bob
user-charlie
user-roommate
user-work-guy

Naming convention matters. Prefix everything with user- so you can distinguish person tags from purpose tags (quality-uhd, retain-30d). This saves you from a confusing mess when you have 20 tags and can’t remember what bob means vs user-bob.

Also create your quality and retention tags:

quality-uhd
quality-1080p
quality-720p
retain-30d
retain-permanent

You’ll combine these. A single request can carry multiple tags: user-alice, quality-uhd, retain-permanent. Each tag independently triggers its own rules.

Step 2: Wire Up Jellyseerr’s Request Tags

In Jellyseerr, go to Settings → Users, pick a user, and look for the Request tags fields — one for movies (Radarr) and one for TV (Sonarr). Enter the tags exactly as you created them.

For Alice, who gets 4K and permanent retention:

Radarr tags: user-alice, quality-uhd, retain-permanent
Sonarr tags: user-alice, quality-uhd, retain-permanent

For the work guy who gets 1080p and a 30-day cleanup window:

Radarr tags: user-work-guy, quality-1080p, retain-30d
Sonarr tags: user-work-guy, quality-1080p, retain-30d

Now every request that user submits automatically carries those tags into Sonarr/Radarr. No manual tagging, no guessing. The system does it at submission time.

Note: Jellyseerr’s tag passthrough only works when the user has a linked Sonarr/Radarr profile configured. If you’re using the default service settings for that user (not a custom profile), check that the default settings include your tag fields. Some older Jellyseerr versions put this under Notifications — just search the settings page for “tags.”

Step 3: Quality Profiles Per Tag in Radarr

This is where it gets real. You can have multiple quality profiles in Radarr and attach them to tags, but Radarr doesn’t natively say “if tag X, use profile Y” at the per-request level — that’s done through Custom Formats and Profile scoring, or through running multiple Radarr instances.

Option A: Multi-Instance Radarr (Recommended for True 4K Separation)

Run two Radarr instances:

• radarr-1080p on port 7878, root folder /media/movies/
• radarr-4k on port 7879, root folder /media/movies-4k/

In Jellyseerr, configure two Radarr service entries. Then in each user’s settings, assign them to the appropriate Radarr service:

• Standard users → radarr-1080p
• 4K-approved users → radarr-4k

The tags still apply within each instance for retention and identification. This is the TRaSH Guides recommended approach, and honestly it’s the right call — mixing 4K and 1080p in one Radarr instance gets messy fast.

# Example Docker Compose snippet for dual Radarr
services:
  radarr:
    image: lscr.io/linuxserver/radarr:latest
    container_name: radarr-1080p
    ports:
      - "7878:7878"
    volumes:
      - /opt/radarr-1080p:/config
      - /media/movies:/movies
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=America/New_York

  radarr-4k:
    image: lscr.io/linuxserver/radarr:latest
    container_name: radarr-4k
    ports:
      - "7879:7878"
    volumes:
      - /opt/radarr-4k:/config
      - /media/movies-4k:/movies
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=America/New_York

Option B: Custom Format Scoring (Single Instance)

If you want one Radarr instance, use Custom Formats to score quality and build separate profiles. A quick crash course:

1. Settings → Custom Formats — create formats that match resolution/source (e.g., score 2160p formats as +1000)
2. Settings → Quality Profiles — create Standard-1080p profile with max score cap of 999 (so UHD content scores too high and gets blocked) and Premium-4K profile with no cap
3. Tag-based routing to profiles isn’t directly supported — you’d need to use the separate service approach in Jellyseerr or manually review 4K requests under a different approval flow

Multi-instance is less elegant but more bulletproof. Do it if you can.

Step 4: Permission Tiers and Auto-Approve

Jellyseerr has a layered permission system that you should map to your user tiers before you start handing out accounts.

Settings → Users → Edit User → Permissions:

For the work guy: no auto-approve, no 4K. Every request comes to you for review. You can approve or deny it in 10 seconds from your phone. The tag still gets applied automatically when you approve, so the workflow is the same.

For your roommate and sister-in-law: auto-approve with 1080p cap. They request, it downloads, tags are applied, done.

For yourself: everything. Obviously.

Step 5: Maintainerr for Tag-Based Auto-Deletion

Maintainerr is a companion tool that runs cleanup rules on your Plex/Jellyfin library. You point it at your Sonarr/Radarr instances and define rules like:

• Delete movies with tag retain-30d that haven’t been watched in 30 days
• Delete TV seasons with tag user-work-guy that are fully watched and over 60 days old
• Exclude anything with tag retain-permanent from all deletion rules

# Maintainerr Docker Compose
services:
  maintainerr:
    image: ghcr.io/jorenn92/maintainerr:latest
    container_name: maintainerr
    ports:
      - "6246:6246"
    volumes:
      - /opt/maintainerr:/opt/data
    environment:
      - TZ=America/New_York
    restart: unless-stopped

Once running, create a collection rule in Maintainerr:

1. Add Rule → Select Radarr as source
2. Filter: Tag contains retain-30d
3. Condition: Not watched in 30 days (requires Plex/Jellyfin watch history sync)
4. Action: Delete from Radarr (and optionally delete file)

Add a second rule with Tag contains retain-permanent and action Exclude from all rules to protect your keeper content.

Now the work guy’s requests auto-clean after a month. Your own requests stay forever. The system does it without you touching anything.

Step 6: The Audit Trail — Webhooks to Discord or ntfy

You want to know when someone requests something dumb at 2 AM. Jellyseerr has a built-in webhook notification system.

Settings → Notifications → Webhook:

{
  "url": "https://ntfy.sh/your-jellyseerr-topic",
  "authHeader": "",
  "jsonPayload": "{\"topic\": \"jellyseerr\", \"message\": \"{{requestedBy_username}} requested {{media_title}} ({{media_type}}) — tags: {{requestedBy_email}}\"}"
}

Or use Discord’s webhook format for a proper embed in your server:

{
  "username": "Jellyseerr",
  "embeds": [{
    "title": "New Request",
    "description": "**{{media_title}}** ({{media_year}})\nRequested by: **{{requestedBy_username}}**\nType: {{media_type}}\nStatus: {{event_type}}",
    "color": 5763719
  }]
}

Now every request hits your Discord or ntfy topic in real time. You see who asked, what they asked for, and you can act on it from your phone before it even downloads.

Putting It All Together: The 4K Request Workflow

Here’s the full flow when Alice (your trusted 4K user) requests a film:

1. Alice opens Jellyseerr, finds the movie, hits Request
2. Jellyseerr sees Alice has 4K permission + auto-approve
3. Request is submitted to radarr-4k instance with tags: user-alice, quality-uhd, retain-permanent
4. Radarr-4k picks up the request, applies the 4K quality profile (2160p Remux preferred)
5. Download completes, file lands in /media/movies-4k/
6. Discord webhook fires: “alice requested Dune: Part Two (movie)”
7. Maintainerr sees retain-permanent tag and excludes it from all deletion rules

When the work guy requests the same movie:

1. He opens Jellyseerr, finds the movie, hits Request
2. Jellyseerr sees he has no auto-approve — request goes into pending
3. You get a Discord notification: “work-guy requested Dune: Part Two (movie) — awaiting approval”
4. You approve it (or deny it if you’ve seen this pattern before)
5. Request goes to radarr-1080p with tags: user-work-guy, quality-1080p, retain-30d
6. Downloads at 1080p, lands in /media/movies/
7. Maintainerr checks every night — if it’s unwatched after 30 days, it’s gone

Same movie. Different users. Completely different paths through your system, all driven by tags.

Quick Tag Reference

A cheat sheet for your own setup:

# Identity tags (one per user)
user-alice
user-bob
user-charlie
user-roommate
user-work-guy

# Quality tags (applied by Jellyseerr user profile)
quality-uhd        → routes to radarr-4k, sonarr with 4K profile
quality-1080p      → routes to radarr-1080p, standard profile
quality-720p       → web-only grabs, smallest files

# Retention tags (drives Maintainerr rules)
retain-permanent   → never deleted
retain-60d         → deleted if unwatched after 60 days
retain-30d         → deleted if unwatched after 30 days

# Special tags
no-auto-grab       → request queued but paused (manual review before download)
kids               → routes to root folder /media/kids/, restricted profiles

The Bottom Line

The “five friends with accounts” problem is a configuration problem, not a people problem. Once tags flow from Jellyseerr into Sonarr and Radarr, you have a real system instead of a shared drive with good intentions.

Start simple: one tag per user, one quality profile per tier. Get that working first. Then add Maintainerr for auto-cleanup and webhooks for the audit trail. Multi-instance Radarr sounds overkill until you realize mixing 4K and 1080p in one instance creates more headaches than it solves.

Your future self — the one who didn’t spend Saturday morning auditing 300 GB of animated shows nobody watched — will appreciate the hour you spent on this.

Related Reading

• Immich vs PhotoPrism vs Ente: Self-Hosted Photo Libraries
• LazyLibrarian + Readarr: Automating Your Book Library
• Plex Meta Manager: Posters, Collections, Sanity
• Whisparr & Mylar3: Specialty *arr Apps Explained
• BirdNET-Pi for Self-Hosted Bird Identification