# Seerr: a request and discovery manager for Jellyfin, Plex and Emby libraries

> Seerr sits between your users and your media server, turning ad hoc requests into a queue that Sonarr and Radarr can act on. It is a Jellyseerr and Overseerr successor, and the README points installers at its own documentation rather than shipping commands.

**seerr-team/seerr** — Open-source media request and discovery manager for Jellyfin, Plex, and Emby.

- Repository: https://github.com/seerr-team/seerr
- Website: https://docs.seerr.dev
- Stars: 12,757 · Forks: 1,058
- Language: TypeScript
- License: MIT
- Published: 2026-09-21 · Updated: 2026-09-21 · Language: en
- Canonical page: https://hysenlabs.com/projects/seerr-team-seerr

## The gap Seerr fills between a media server and a download stack

A media server answers one question: what can I watch right now. It does not answer who asked for something that is not there yet. Without a request layer, that conversation happens in chat, by email, or not at all, and the person running the server ends up manually adding titles to Sonarr and Radarr.

Seerr is aimed at that operator. The README describes it as "a free and open source software application for managing requests for your media library", integrating with Jellyfin, Plex or Emby for authentication and with Sonarr and Radarr for fulfilment. The audience is a self-hoster with an existing library and existing automation, not someone starting from zero. If you have none of those three media servers, Seerr has nothing to authenticate against and no library to scan, so it is the wrong starting point.

## How requests move from a user to Sonarr and Radarr

The data flow has three participants. The media server is the source of identity and of library state: the README lists Jellyfin/Emby/Plex authentication with user import and management, plus a library scan that keeps track of titles already available. Sonarr and Radarr are the fulfilment side. Seerr holds the request records and the permissions that govern them.

That middle position explains most of the feature list. Because Seerr knows what the library already contains, it can mark a request as already available rather than sending it onward. Because it knows which user asked, it can apply the granular permission system and the customizable request system, which the README says allows users to request individual seasons or movies. Watchlisting and blocklisting sit in the same layer: a title can be flagged before anyone requests it, or excluded from requests entirely.

Storage is a choice between PostgreSQL and SQLite, both listed as supported. SQLite keeps deployment to a single container with a file on disk; PostgreSQL is the option for an install where the database is managed separately. The repository also carries compose.yaml and compose.postgres.yaml as separate files, which matches that split. The stack is TypeScript, with a Next.js frontend under src/ and a Node server under server/, and the API documentation is served from the running instance at http://localhost:5055/api-docs.

## Installing Seerr: where the README sends you, and what the repository gives you

The README does not contain install commands. Under Getting Started it says only: "Check out our documentation for instructions on how to install and run Seerr" and links to https://docs.seerr.dev/getting-started/. Anything beyond that link would be invention, so treat the official documentation as the install path and use the repository files as a cross-check on what the deployment actually looks like.

The one fact the repository states plainly is the port. The compose file maps 5055 on the host to 5055 in the container, and the README's API documentation URL uses the same number:

```yaml
services:
  seerr:
    build:
      context: .
      dockerfile: Dockerfile.local
    ports:
      - 5055:5055
```

That compose.yaml is a development file. It mounts the repository into /app and builds from Dockerfile.local, which is the wrong shape for a server you want to keep running. The production image is built from the top-level Dockerfile, which uses node:22.23.2-alpine3.23 as its base and runs as the nod user. For a real deployment, follow the documentation's instructions rather than this compose file.

If you build from source instead, package.json fixes the toolchain: pnpm@10.24.0 is the declared package manager, and a preinstall hook runs only-allow pnpm, so npm and yarn installs are rejected before they start. The build is two steps, a Next.js build followed by the server compile:

```bash
pnpm install
pnpm build
pnpm start
```

After the server is up, the first real use is opening the instance in a browser, completing the setup the documentation describes, and connecting a media server and then Sonarr or Radarr. Once that is done, a request placed in the UI is the thing to watch: it should appear in the request management view for approval, and only then reach the download stack. The API surface is browsable at http://localhost:5055/api-docs on the running instance.

## Where Seerr is the wrong tool

The most concrete limitation is the one the README states by omission. There is no mobile or desktop client described anywhere in it. The feature list says "Mobile-friendly design, for when you need to approve requests on the go", which is a statement about the web interface in a browser, not about a packaged app. Anyone searching for a Seerr Android or iOS app should read that line carefully before assuming one exists; the README does not document one.

A second boundary is scope. Seerr manages requests. It does not download anything itself, and it does not replace Sonarr or Radarr. If your problem is that downloads fail, or that indexers are misconfigured, Seerr will faithfully record requests and pass them along, and the failure will sit somewhere else in the stack.

The third is operational. Seerr is a long-running service with a database behind it. That means backups, upgrades and a database choice, which is more than a single-user media server needs. If exactly one person uses the library and that person is you, the request queue is overhead with no beneficiary.

## Seerr against the tools it grew out of

The README addresses this directly rather than leaving it implied. It carries a section headed "Migrating from Overseerr/Jellyseerr to Seerr", pointing at a release announcement and a separate migration guide at https://docs.seerr.dev/migration-guide. That framing tells you what the practical alternative is: running Overseerr or Jellyseerr, the projects this one descends from.

The difference in approach is less about features than about lineage and integration surface. Seerr's README leads with integration across three media servers, Jellyfin, Plex and Emby, alongside Sonarr and Radarr. The migration guide exists because the data model is close enough that an existing install can be carried over, which is also why the two projects are not meaningfully different choices for a new install. If you are already running one of them, the decision is about migration cost, not about capability. If you are starting fresh, the README's own framing makes Seerr the current option of the three.

## Maintenance, licensing and what upgrades cost you

The repository is not archived, and the last push was on 2026-09-21. Releases are tagged and dated: v3.4.1 on 2026-07-30, v3.4.0 on 2026-07-28, and v3.3.0 on 2026-06-02. That cadence, roughly a minor release every two months with patch releases in between, is the practical upgrade cost: you are tracking a moving target, not a frozen artifact.

Because the server owns a database, upgrades are not just a container swap. The repository contains a migration system built on TypeORM, with package.json exposing migration:generate, migration:create and migration:run scripts that operate against server/datasource.ts. Those scripts exist for contributors and for operators running from source. For container deployments, the documentation is the place to check whether migrations run automatically on start. The README does not document rollback, so if you care about being able to step back a version, verify that before you upgrade rather than after.

Licensing is MIT, per the LICENSE file and the badge in the README. That is a permissive licence, and it means the usual obligations around retaining the licence text apply. It says nothing about the media you index, the services you connect, or the terms of your Plex, Jellyfin or Emby account. Those are separate questions, and this is not legal advice.

## Conclusion

Adopt Seerr if you already run Jellyfin, Plex or Emby plus Sonarr and Radarr, and you want users to request titles instead of asking you directly. Skip it if you have no media server to authenticate against, or if you expect a packaged desktop or mobile client: the README documents a web application and a Docker image, not a store app. Before committing, open https://docs.seerr.dev/getting-started/ and confirm the install path for your platform, then check the migration guide if you are coming from Overseerr or Jellyseerr.

## FAQ

### What is Seerr?

Seerr is a free and open source application for managing requests for a media library. It integrates with Jellyfin, Plex or Emby and with Sonarr and Radarr, and it ships a request management UI, a granular permission system and support for PostgreSQL or SQLite.

### Is Seerr the same as Jellyseerr?

They are separate projects with a shared lineage. The README includes a section on migrating from Overseerr or Jellyseerr to Seerr and links to a dedicated migration guide at https://docs.seerr.dev/migration-guide.

### Does Seerr have an app?

The README documents a web application, not a packaged mobile or desktop client. It lists a mobile-friendly design for approving requests on the go, which describes the browser interface rather than a store app.

### How do I install Seerr on Docker?

The README does not give install commands. It directs readers to https://docs.seerr.dev/getting-started/ for installation and running instructions, and the repository's compose.yaml shows the service on port 5055.

### How do I set up Seerr after installing it?

Setup is not described in the README, which points to the documentation instead. Once the instance is running, the API documentation is available from that install at http://localhost:5055/api-docs.

## Sources

- [License: MIT](https://github.com/seerr-team/seerr/blob/develop/LICENSE)
- [Project website](https://docs.seerr.dev)
- [README](https://github.com/seerr-team/seerr/blob/develop/README.md)
- [Releases](https://github.com/seerr-team/seerr/releases)
- [seerr-team/seerr on GitHub](https://github.com/seerr-team/seerr)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/seerr-team-seerr