Maintainerr

Self-hosted media library management, honestly reviewed. No marketing fluff, just what happens when you let a rule engine clean your Plex or Jellyfin library.

TL;DR

• What it is: MIT-licensed media library automation tool that scans your Plex or Jellyfin library against a configurable rule set, shows a “Leaving Soon” warning collection, then deletes what nobody watches [README].
• Who it’s for: Self-hosters running Plex or Jellyfin with an *arr stack (Radarr/Sonarr) who are tired of manually hunting down media that hasn’t been touched in months.
• Cost: Free. No tiers, no cloud version, no commercial license. Software cost is $0; you need a server to run it on [README].
• Key strength: Closes a genuine gap in the *arr ecosystem — Radarr and Sonarr download media on request, but neither has a first-class story for cleaning up what nobody watched afterward.
• Key weakness: Thin third-party coverage and a relatively small community (1,750 GitHub stars) make it harder to diagnose edge cases. If your setup breaks, you’re mostly on Discord [README][1].

---

What is Maintainerr

Maintainerr describes itself in two ways: the website headline calls it “The Perfect Media Janitor,” and the GitHub description is blunter — “Looks and smells like Seerr, does the opposite. A library maintenance tool for Plex and Jellyfin.” [README]

The reference to Seerr (Overseerr/Jellyseerr) is the fastest way to understand what Maintainerr solves. Seerr lets your users request movies and shows. They click “request,” Radarr or Sonarr grabs it, it lands in your library. Then a lot of those users never actually watch it. Over time, a Plex or Jellyfin server running with an open request system accumulates a long tail of media that costs storage and contributes nothing. Maintainerr’s job is to find that tail and remove it, on a schedule, with configurable rules, and with a grace-period warning before anything gets deleted.

The core workflow is:

1. You define rules combining criteria from Plex/Jellyfin (watch count, last watched date, library metadata), Sonarr/Radarr (monitoring status, file size, add date), Tautulli (play history, user statistics), and Seerr (request metadata).
2. Media matching those rules gets added to a Maintainerr collection.
3. That collection can optionally appear on your media server home screen as a “Leaving Soon” shelf — users see what’s about to go.
4. After your configured countdown period, Maintainerr deletes files from disk, unmonitors or removes from Radarr/Sonarr, and clears the request from Seerr [README].

The project sits at 1,750 GitHub stars as of this review, runs on Docker (both amd64 and arm64), and is licensed MIT. Data is persisted in a single volume at /opt/data, which makes backups trivial [README][1].

---

Why people choose it

The honest answer is that Maintainerr solves a problem the existing *arr stack doesn’t. Radarr and Sonarr were built around acquisition, not eviction. Tautulli shows you who watched what, but it doesn’t act on that data. Plex and Jellyfin have no native mechanism to remove unwanted content on a schedule. Maintainerr is the missing piece that connects all of them into a deletion pipeline.

The self-hosted community has been living with this gap for years. The common workaround was either a manual monthly pass through the library (“let me check what nobody’s watched”) or brittle shell scripts piped together from multiple API calls. Maintainerr replaces both with a GUI-configured rule engine [README].

The “Leaving Soon” collection feature is the detail that separates Maintainerr from a blunt deletion script. Because the collection appears on the Plex or Jellyfin home screen for a configurable number of days before anything gets deleted, it functions as a social signal to your household or friends: these titles are going away, watch them or lose them. In practice, this prompts some viewings that wouldn’t otherwise happen, and it eliminates the complaints about a show disappearing without warning [README][website].

The Marius Hosting installation guide [1] — targeting Synology NAS users on Docker — is the most detailed third-party walkthrough available for Maintainerr at this writing. It covers version 3.7.0, runs on port 6246 (mapped externally to 8164 in the guide’s example), and flags a specific gotcha: if you’re having communication issues between Maintainerr and Sonarr, Radarr, Seerr, or Plex, the most common cause is a container networking misconfiguration [1]. This kind of operational detail is rarely in the official docs but matters a lot for first-time setups.

---

Features

Rule engine:

• Rules combine parameters from Plex, Jellyfin, Sonarr, Radarr, Tautulli, and Seerr — any combination [README]
• Rules can filter on watch count, last play date, request metadata, file age, monitoring status, and more [README]
• Results populate a collection automatically; the collection can appear on your media server home screen [README]
• Countdown timer: configurable number of days before the collection’s contents are deleted [README][website]

Manual override controls:

• Manually add media to a collection even if it doesn’t match any rule — useful for one-off removals [README]
• Selectively exclude specific titles from a collection even when they do match a rule [README]
• Manual collection mode: Maintainerr shows what would be deleted without taking any automated action [README]
• Manage media directly from within the Plex or Jellyfin collection interface; Maintainerr syncs includes/excludes [README]

Deletion actions:

• Delete files from disk [README]
• Remove or unmonitor from Radarr/Sonarr [README]
• Clear requests from Seerr [README]

Platform support:

• Plex and Jellyfin — switch between them with automatic rule migration [README]
• Sonarr, Radarr, Seerr, Tautulli as rule data sources [README]
• Docker images for amd64 and arm64 (ghcr.io is the recommended registry) [README][1]
• REST API [merged profile]

Migration tools:

• Rule migration when switching from Plex to Jellyfin (or vice versa) — unusual feature for this category [README]

---

Pricing: SaaS vs self-hosted math

Maintainerr has no SaaS version and no commercial tier. The software cost is $0 [README]. What you’re paying for is compute and storage to run it.

The tool itself is lightweight — the Marius Hosting guide sets a 4GB memory limit as a ceiling, but in practice Maintainerr uses a fraction of that during idle operation [1]. It runs comfortably alongside other Docker containers on a NAS or a small VPS.

Self-hosted cost breakdown:

• Software: $0 (MIT license)
• Compute: shares a host you’re already running for Plex/Jellyfin/*arr — marginal cost near $0
• If deploying on a dedicated VPS: $5–10/month on Hetzner or similar

The more relevant cost comparison is what Maintainerr saves:

Storage cost of not having it:

• A self-hosted media server running with open Seerr requests accumulates unwatched content steadily. A single 4K Blu-ray rip is 50–80GB. Ten movies nobody watched = 500–800GB of dead weight.
• At cloud storage pricing (Backblaze B2: $0.006/GB/month), 500GB of unwatched media costs ~$3/month to back up indefinitely for no reason. On a NAS with 20TB drives at $300 each, that 500GB represents a real slice of hardware budget.
• More practically: disk space runs out, and the options are either buy more drives or clean up. Maintainerr makes “clean up” automatic rather than a weekend project.

Time cost of doing it manually:

• A manual monthly library audit — pulling Tautulli stats, cross-referencing with Radarr, deciding what to delete, executing deletions — takes a competent self-hoster 1–3 hours per month. At any consulting rate you’d put on your time, that’s real money.
• Maintainerr runs the same audit on whatever schedule you configure, automatically, at 2am, with no context switching [README].

There’s no “should I pay for the SaaS?” calculation here because the SaaS doesn’t exist. The question is whether the setup time is worth it. Given that Maintainerr runs on Docker Compose and the Marius Hosting guide [1] shows a working stack in under a dozen steps, the break-even point is your first automated deletion cycle.

---

Deployment reality check

Maintainerr is a Docker-first project. The README recommends ghcr.io/maintainerr/maintainerr over Docker Hub for the primary image source, with both amd64 and arm64 builds available [README].

Minimum viable setup:

• A running Plex or Jellyfin instance
• At minimum one *arr application (Sonarr or Radarr) — Maintainerr is most useful when it can act on the *arr side, not just the media server side
• Docker or Docker Compose on the host
• A persistent volume mounted to /opt/data

What you actually wire up:

• Plex or Jellyfin API credentials
• Sonarr/Radarr API keys and URLs
• Optionally: Tautulli API key (for watch statistics), Seerr API key (for clearing requests)

The Marius Hosting guide [1] covers the Synology + Portainer path specifically, which is one of the more common self-hosted deployment targets. The stack file in that guide is 20 lines of YAML. Port mapping: container listens on 6246, mapped to whatever external port you choose. The guide defaults to 8164 but that’s arbitrary [1].

What can go sideways:

The biggest operational risk flagged in [1] is container networking: when Maintainerr and your *arr applications run in different Docker networks, API communication fails silently or with cryptic errors. The fix is to put Maintainerr and the *arr stack on the same Docker network, or to use host-mode networking. This is standard Docker housekeeping but it’s a common first-install stumble [1].

The other thing to understand before you start: Maintainerr’s rule engine requires you to think through your deletion criteria carefully before going live. A misconfigured rule — say, “delete everything with fewer than 5 plays” applied to a library of content you’re actively seeding — will do exactly what you told it to. The manual collection mode (which shows what would be deleted without acting) is the right way to validate rules before enabling countdown timers. This is a UI affordance the project provides, but it requires you to actually use it [README].

Realistic setup time for a technical user already running *arr: 30–60 minutes to a working installation with rules configured and validated. For someone new to the *arr ecosystem who needs to understand what Sonarr and Tautulli even are before wiring them up: half a day.

---

Pros and cons

Pros

• Solves a real gap. No other well-maintained open-source tool combines rule-based selection across Plex/Jellyfin + *arr + Tautulli + Seerr into a coordinated deletion workflow. This problem was previously solved with scripts or manual work [README].
• “Leaving Soon” collections. Showing a grace-period collection on the media server home screen before anything is deleted is a thoughtful design choice that prevents complaints and occasionally prompts viewings [README][website].
• MIT licensed. No commercial restrictions, no “fair-code” gotchas, no license expiry concerns [README].
• Plex and Jellyfin parity. Supports both major self-hosted media servers with rule migration when switching between them — rare in this category [README].
• Manual override system. You can add items to a collection by hand (for one-off deletions) or exclude items from matching rules (to protect specific titles). The tool doesn’t force you into pure automation [README].
• Lightweight. Runs alongside your existing Docker stack without requiring a dedicated host or significant resources [1][README].
• ARM64 support. Runs on Raspberry Pi and ARM-based NAS hardware — critical for the NAS-heavy self-hosted demographic [README].

Cons

• Limited third-party coverage. At 1,750 GitHub stars and with a small documentation footprint beyond the official docs, troubleshooting edge cases means Discord or reading GitHub issues. The community is active but not large [README].
• Rule setup requires discipline. The tool will delete whatever you tell it to delete. There’s no safety net beyond the grace-period countdown and the manual collection preview mode. A misconfigured rule on a library of hundreds of items can cause real damage before you notice [README].
• No standalone web UI for discovery. Maintainerr is purely a management tool — it doesn’t replace Overseerr/Jellyseerr for request management or Tautulli for analytics. You need those tools already running; Maintainerr is the coordinator, not the stack [README].
• No multi-instance support. If you run multiple Plex or Jellyfin servers, you’d need a separate Maintainerr instance per server. Data not available on whether this is on the roadmap.
• Deletion is permanent. Once Maintainerr removes a file from disk, it’s gone unless you have a separate backup strategy. The *arr applications can re-download on a new request, but that takes time and bandwidth [README].
• No alerting / notification system. The tool takes action silently on schedule. There’s no native email or webhook notification when a deletion run completes. You’d need to build that externally if you want visibility [README].

---

Who should use this / who shouldn’t

Use Maintainerr if:

• You run Plex or Jellyfin with Radarr/Sonarr and your library grows faster than people watch things.
• You have Seerr open to household members or a small friend group, and requests have outpaced viewings.
• You’ve done the manual “what hasn’t been watched in six months?” audit at least once and found it tedious.
• You’re comfortable with Docker Compose and setting up API connections between containers.
• You want the “Leaving Soon” shelf behavior — a grace period before deletion that’s visible on the media server home screen.

Skip it if:

• You’re the only user of your media server and you already know what you’ve watched — manual cleanup is fast enough.
• Your library is small enough that storage isn’t a concern yet.
• You don’t run Radarr or Sonarr — Maintainerr’s rule engine is most powerful when it can act on the *arr side. Without *arr integration, it can still delete files from disk, but it loses the ability to unmonitor and prevent re-downloading.
• You’re not comfortable setting up API connections across multiple self-hosted containers — the configuration requires touching API keys for every connected application.

---

Alternatives worth considering

• Manual cleanup. The default “alternative” for most self-hosters. Works, doesn’t scale, takes time every month.
• Tautulli alone. Tautulli has notification agents and some scripting capabilities that can approximate Maintainerr’s watch-based deletion triggers, but you’d be writing Python and it doesn’t have Maintainerr’s collection/countdown UI [README].
• Kometa (formerly Plex Meta Manager). Primarily a collection creation tool — it curates how your library looks, not what gets removed. Different problem, occasionally mentioned in the same breath.
• Plex Autodelete. An older project that does automated deletion for Plex. Less maintained than Maintainerr and doesn’t have the Jellyfin support or the integrated *arr workflow [README comparison].
• Radarr/Sonarr “Unmonitoring” workflows. Both *arr applications have some built-in automation for unmonitoring after download. This doesn’t delete files and doesn’t use Tautulli watch statistics. Maintainerr is a more complete solution.

For the Jellyfin user specifically, Maintainerr is one of the few tools in this space with genuine first-class Jellyfin support rather than treating Plex as the primary case and Jellyfin as an afterthought.

---

Bottom line

Maintainerr is a focused, well-scoped tool that does one thing the broader self-hosted media stack can’t do on its own: turn watch statistics and request metadata into automated, rule-driven cleanup. It doesn’t have the community breadth of the *arr applications it integrates with, and it requires genuine care in rule configuration — a wrong rule deletes real files. But for the self-hoster running an open Seerr instance or a large family library that accumulates unwatched content faster than anyone can track manually, it closes a real operational gap. The “Leaving Soon” collection feature is the detail that makes it feel considered rather than blunt. If your Plex or Jellyfin library is a source of storage anxiety and you’re already running the *arr stack, Maintainerr is worth the afternoon it takes to configure it correctly.

---

Sources

1. Marius Hosting — “How to Install Maintainerr on Your Synology NAS”. https://mariushosting.com/how-to-install-maintainerr-on-your-synology-nas/

Primary sources:

• GitHub repository and README: https://github.com/maintainerr/maintainerr (1,750 stars, MIT license)
• Official website: https://maintainerr.info
• Documentation: https://docs.maintainerr.info