SuggestArr

Self-hosted automation for your Plex/Jellyfin/Emby stack, honestly reviewed. No marketing fluff, just what you get.

TL;DR

• What it is: Open-source (MIT) automation layer that watches your recently played content, finds similar titles via TMDb, and automatically submits download requests to Jellyseerr or Overseerr [README].
• Who it’s for: People already running a self-hosted media stack (Plex, Emby, or Jellyfin + a request manager) who want it to self-replenish without manual searching. Not a beginner tool — you need the stack first [1][README].
• Cost savings: SuggestArr itself is free. The savings framing is different here: there’s no paid SaaS doing the same job. The value is automation time, not subscription replacement.
• Key strength: Genuinely solves a specific problem in the self-hosted media world — the gap between “I have a request manager” and “my library proactively grows without me.” Setup wizard is unusually polished for a solo-developer project [1][README].
• Key weakness: It’s a dependent tool, not a standalone one. You need Jellyfin/Plex/Emby and Jellyseerr/Overseerr already running before SuggestArr does anything. AI features are in beta. Single-developer project with 1,076 stars — small community, real bus-factor risk [README].

---

What is SuggestArr

SuggestArr is a background automation daemon that sits between your media server and your request manager. Every time someone in your household watches something, SuggestArr asks TMDb “what’s similar?” and then automatically fires off a download request through Jellyseerr or Overseerr [README].

The pitch on the GitHub README is cleaner than the homepage marketing copy: “Effortlessly request recommended movies, TV shows and anime to Jellyseer/Overseer based on your recently watched content.” That’s an accurate one-sentence description. The homepage calls it “the ultimate media automation tool” — ignore that, it’s a focused utility [README][website].

The project was built by a single developer (giuseppe99barchetta) and sits at 1,076 GitHub stars. It’s not a large project by open-source standards, but it’s stable enough that ElfHosted — a managed self-hosting platform — added it to their catalog, which signals real-world production usage [1][README].

What makes SuggestArr worth looking at in 2026 isn’t just the TMDb-based recommendation engine, which is the original core. It’s the AI layer bolted on top: you can connect any OpenAI-compatible LLM (OpenAI, Ollama, Gemini, LiteLLM) to generate hyper-personalized suggestions with reasoning, or use natural-language search to describe what you’re in the mood for and have it find matching titles from TMDb [README]. Both AI features are clearly marked beta, which is honest.

---

Why People Choose It

The third-party coverage for SuggestArr is sparse compared to larger self-hosted tools — the most substantive external documentation comes from ElfHosted’s hosted app page [1], which documents the setup wizard in detail. That limited review surface is itself a signal: this is a tool used by people deep in the self-hosted media rabbit hole, not a mainstream comparison category.

From what ElfHosted documents and the README describes, the appeal lands in a consistent place: the automation gap in the *arr stack. People who run Plex or Jellyfin typically have a request manager (Overseerr or Jellyseerr) for manually requesting content. SuggestArr closes the loop — instead of someone remembering to search for “more things like what I just watched,” it happens automatically on a schedule [1][README].

The ElfHosted setup guide [1] walks through five configuration steps: pick your media server, validate your TMDb key, configure the server connection, configure Jellyseerr/Overseerr, and set filtering preferences. The fact that ElfHosted built a full guided wizard for it and hosts it as a paid tier suggests real user demand, not just GitHub curiosity.

The content filtering feature gets specific mentions as genuinely useful: you can set a TMDb rating threshold, filter out genres you don’t want, and — notably — exclude content already available on streaming platforms in your country. That last one matters if you’re not trying to download a film you can already watch on Netflix [1][README].

---

Features

Based on the README and ElfHosted documentation:

Core recommendation engine:

• Pulls recently watched history from Jellyfin, Plex, or Emby [README]
• Searches TMDb for similar movies and TV shows [README]
• Automatically submits requests to Jellyseerr or Overseerr [README]
• Cron-based scheduling, configurable from the web interface without editing files [README][1]
• User selection — you can pick which users’ watch history triggers requests, not just “everyone” [README][1]
• Content filtering: TMDb rating threshold, genre exclusions, streaming-platform availability filter [1][README]

AI features (beta):

• LLM-powered recommendations using any OpenAI-compatible endpoint — OpenAI, Ollama, Gemini, LiteLLM, OpenRouter [README]
• Each AI suggestion includes an “AI Reasoning” section explaining why it was picked [README]
• Natural language AI Search: describe what you want to watch in plain English, get matched titles personalized to your history [README]
• Smart deduplication: excludes already-requested IDs from future suggestions [README]
• Arr profile sync: imports download profiles directly from Sonarr and Radarr [README]

Management and operations:

• Web interface for all configuration — no direct file editing required for normal operation [README][1]
• Real-time log viewer with filtering by level (INFO, ERROR, DEBUG) [README][1]
• Configuration pre-validation: validates API keys and server URLs before letting you proceed to next setup step [README][1]
• Multi-user support: assign a specific Seer user for requests, with password authentication [README][1]
• External database support: PostgreSQL and MySQL in addition to the default SQLite, for larger deployments [README]
• Docker and Docker Compose deployment; Python 3.x if you prefer bare metal [README]

What it doesn’t do:

• No built-in media server (needs Plex/Emby/Jellyfin)
• No built-in request manager (needs Jellyseerr/Overseerr)
• No download client (needs Radarr/Sonarr behind the request manager)
• No mobile app — web interface only

---

Pricing: SaaS vs Self-Hosted Math

SuggestArr has no SaaS tier and no commercial license. The software is MIT-licensed and free [README]. This makes the pricing math different from a tool like Activepieces or n8n where there’s a paid SaaS to compare against.

SuggestArr self-hosted:

• Software: $0 (MIT)
• Infrastructure: essentially zero if you’re already running a media server — SuggestArr is lightweight and can share a VPS with Jellyfin or Plex
• If you need a dedicated container: it fits comfortably on any existing Docker host, or a $5–6/mo VPS if you’re starting fresh
• TMDb API key: free for personal use [1]
• LLM costs (optional): only if you use the AI features and connect to a paid provider; Ollama is free if self-hosted

ElfHosted managed hosting: ElfHosted offers SuggestArr as a hosted application [1]. Pricing data for their individual app tiers isn’t in the provided sources — check ElfHosted’s current pricing directly if you want managed hosting without running your own server.

The honest cost framing: There is no paid SaaS alternative that does exactly what SuggestArr does. The value isn’t “replace a $50/mo bill” — it’s “automate 30 minutes of weekly manual searching.” If you’re already spending $10–20/mo on a VPS for your media stack, SuggestArr adds zero marginal cost.

The broader self-hosted media stack is where the real savings math lives: a Plex/Jellyfin stack with Sonarr/Radarr, running on a $10/mo VPS, replaces $50–150/mo in streaming subscriptions. SuggestArr is a quality-of-life layer on top of that infrastructure — not the savings driver, but a reason to get more value out of infrastructure you’re already paying for.

---

Deployment Reality Check

SuggestArr is unusual among self-hosted tools in having a proper setup wizard — ElfHosted documents it as a multi-step guided process that won’t let you advance until each step validates [1]. That’s a meaningful UX investment for a solo-developer project.

What you actually need to deploy SuggestArr:

• A running Plex, Emby, or Jellyfin instance (SuggestArr is useless without one)
• A running Jellyseerr or Overseerr instance (same)
• A free TMDb API key from themoviedb.org [1]
• Docker (recommended) or Python 3.x
• A machine with Docker already running — your existing media server host works fine

What the Docker Compose looks like:

services:
  suggestarr:
    image: ciuse99/suggestarr:latest
    container_name: SuggestArr
    restart: always
    ports:
      - "5000:5000"
    volumes:
      - ./config_files:/app/config/config_files

That’s the minimal config. The web interface at http://localhost:5000 walks you through the rest [README].

ElfHosted-specific note: If you’re running SuggestArr on ElfHosted, the internal URLs for your media server and seerr instance differ from their external addresses. ElfHosted documents the exact internal hostnames to use (e.g., http://jellyfin:8096 instead of the external domain) [1]. This catches people who configure the external URL and then wonder why SuggestArr can’t reach the server.

What can go sideways:

• If your Jellyfin/Plex/Emby instance isn’t accessible at the URL you provide, setup step 3 will fail with a validation error — helpful, but only if you already know what URL to provide in your network topology.
• The AI features require additional configuration in Settings → Advanced → Beta features, and you need to supply your own LLM API key or Ollama endpoint. The base tool works without AI [README].
• The cron scheduler runs in UTC timezone [1]. If you’re expecting “run at midnight local time” behavior, you need to convert manually.
• SQLite is the default database. For households with many users or high watch frequency, the README recommends switching to PostgreSQL or MySQL for better performance [README].

Realistic time estimates: 15–30 minutes if you have Docker running and already know your Jellyfin/Plex and Seerr URLs. The validation at each step means configuration errors surface immediately, not after deployment. For a non-technical user who needs to first figure out internal Docker hostnames: 1–2 hours.

---

Pros and Cons

Pros

• MIT licensed. No commercial restrictions, no “fair-code” games. Fork it, modify it, embed it. [README]
• Addresses a real gap in the self-hosted media stack. The “request manager + no auto-discovery” problem is genuine, and SuggestArr is one of the few purpose-built solutions for it.
• Polished setup wizard for a solo project. Step-by-step validation means you catch configuration errors before they become runtime mysteries [1].
• Flexible media server support. Jellyfin, Plex, and Emby — covers the three main platforms, not just one [README].
• Content filtering. Streaming-platform availability filter is smart: no point auto-requesting a film already on Netflix [README].
• User-scoped automation. You can pick which users’ watch history drives requests — not “everyone’s,” which could lead to chaotic library growth in shared households [README][1].
• AI features available without cloud dependency. Ollama support means the LLM runs locally if you want full privacy [README].
• Lightweight. Runs alongside your existing media server stack without meaningful resource overhead.

Cons

• Hard dependency on existing stack. Zero standalone value. If you don’t have Plex/Emby/Jellyfin and Jellyseerr/Overseerr already running, SuggestArr does nothing. It’s an automation layer, not a product [README][1].
• Single-developer project, 1,076 stars. No corporate backing, no large contributor community. Maintenance continuity depends on one person. The GitHub contributor count isn’t available in the provided data, but the project size signals this clearly.
• AI features are beta. “Beta” in a small open-source project means “works for some users, may break without notice, don’t build critical workflows on it” [README].
• No mobile app. Web interface only. Fine for configuration, but you can’t fire off a quick natural-language search from your phone.
• TMDb API dependency. Recommendations quality depends entirely on TMDb’s similarity data, which is algorithmically generated and not always accurate for niche content. If TMDb doesn’t know your niche anime or foreign films well, the recommendations will miss [README].
• UTC-only scheduling. Minor, but annoying for users who think in local time [1].
• No notification system. When SuggestArr auto-requests content, there’s no push notification to tell you what it added. You watch the real-time logs if you want to know [README].
• Sparse third-party review coverage. Limited community discussion means fewer people have documented failure modes, edge cases, or long-term stability issues.

---

Who Should Use This / Who Shouldn’t

Use SuggestArr if:

• You already have a self-hosted media stack running (Plex/Jellyfin/Emby + Overseerr/Jellyseerr).
• Your library feels stagnant and you want it to grow automatically based on what you actually watch, not what you remember to search for.
• You want the streaming-exclusion filter — you have Netflix/etc. and don’t want to download content you can already stream legally.
• You’re comfortable enough with Docker that adding another container is trivial.
• You want an optional AI search layer on top of your media server with Ollama as the backend.

Skip it if you don’t have the stack yet: SuggestArr without Jellyfin/Plex/Emby and Jellyseerr/Overseerr is useless. If you’re starting from zero, build the base stack first. SuggestArr is a finishing touch, not a foundation.

Skip it (use manual Overseerr/Jellyseerr) if:

• You want to control exactly what goes into your library. Auto-requests based on algorithmic similarity can flood your request queue with content you don’t want. If curation matters to you, manual requests are better.
• You share your media server with many users whose taste you don’t trust. User selection helps, but if everyone’s watch history is in scope, the recommendations will average out to noise.

Skip it (wait for maturity) if:

• You want to use the AI features in production. Beta features in a solo project deserve beta-level trust. The base TMDb recommendation engine is stable; the LLM layer is not there yet.

---

Alternatives Worth Considering

Jellyseerr / Overseerr — the request managers SuggestArr integrates with. They handle manual requests, user permissions, and notification workflows, but don’t auto-discover content. SuggestArr adds the auto-discovery layer on top [README][1].

Ombi — older alternative to Jellyseerr/Overseerr for request management, also supported by ElfHosted [4]. No auto-discovery built in. If you’re on Ombi instead of Jellyseerr, SuggestArr doesn’t currently support it.

Radarr/Sonarr lists and RSS — some users substitute automated recommendation by subscribing to curated RSS feeds or Trakt lists imported into Radarr/Sonarr. Less personalized than watch-history-based discovery but more predictable. No additional tool to manage.

Trakt.tv integration — Trakt has built-in recommendations based on watch history and supports export/sync. Some self-hosted setups pull from Trakt instead of running SuggestArr. Requires a Trakt account (free tier available) and more manual plumbing.

Manual curation — for smaller households or picky viewers, manually browsing TMDb and requesting through Jellyseerr is often good enough. SuggestArr’s automation adds real value at scale (large households, large libraries) but is overkill for one or two people.

No direct open-source competitor doing exactly what SuggestArr does — automated watch-history-based requesting — appears to exist with similar maturity. The niche is narrow, which is why a 1,076-star project can reasonably claim to be the tool for this job.

---

Bottom Line

SuggestArr is a well-scoped utility that fills a genuine gap: if you have a self-hosted media stack, it automates the part where your library grows to match what you actually watch. MIT-licensed, lightweight, zero ongoing cost, and the setup wizard is more polished than you’d expect from a solo project. The honest limitation is that it’s entirely dependent on infrastructure you must already have running — it’s not an entry point, it’s a finishing layer. The AI features are worth watching but not worth relying on yet. For anyone already deep in the *arr stack ecosystem who wants their library to self-replenish, the 30-minute setup is straightforwardly worth it.

If deploying and maintaining Docker stacks is the blocker, upready.dev deploys self-hosted media infrastructure for clients as a one-time service.

---

Sources

1. ElfHosted — SuggestArr hosted app documentation. https://docs.elfhosted.com/app/suggestarr/
2. ElfHosted — Ombi hosted app documentation. https://docs.elfhosted.com/app/ombi/

Primary sources:

• GitHub repository and README: https://github.com/giuseppe99barchetta/suggestarr (1,076 stars, MIT license)
• Official website: https://giuseppe99barchetta.github.io/SuggestArr
• TMDb API documentation: https://www.themoviedb.org/documentation/api