Media request dashboard for Radarr, Sonarr or nexcrate, with Plex, Jellyfin, Emby and OIDC sign-in.
2.5K
Find something to watch — and request it straight from Radarr and Sonarr, or from nexcrate.
Nexview is a self-hosted media discovery dashboard for a household — family, flatmates, a circle of friends. It shows new releases from TMDB, marks what is already in your library, and hands requests to whatever procures for you: Radarr (movies) and Sonarr (shows), or nexcrate, which does both in one. Everyone gets their own account, with roles, approvals and quotas.
You pick one of the two when you set Nexview up, and you can switch later — an assistant walks through it and writes a backup first, because there is no other way back.
It downloads nothing itself and stores no media. It is the front door to a setup you already run — it does not replace any part of it.
Without a TMDB key Nexview starts with sample data, so you can look around before deciding anything.
The home page. What each person marks as a favourite shapes what they get suggested.
Requesting a title, and the same installation seen by a child.
Finding something
Requesting
Who may do what
With a media server
Plex is optional. Connect one and four things arrive:
Staying informed
Running it
And
Nexview runs as one container: FastAPI serves the API and the built interface together. No extra web server is needed.
The image is on the GitHub Container Registry and is built for Intel/AMD and ARM, so nothing has to be compiled:
docker compose up -d
Nexview is then reachable at http://<your-server>:5173.
To build from source instead, replace image: ghcr.io/derkezorm/nexview:latest in
docker-compose.yml with build: . and add --build when starting.
Everything that matters lives in the directory mapped to /data:
| File | Contents |
|---|---|
nexview.db | accounts, requests, feedback, settings |
secret.key | the key your stored API keys are encrypted with |
avatars/ | profile pictures |
trash/ | the fetched TRaSH guides your quality profiles were built against |
hausordnung/ | the images used in the house rules |
logs/ | error log |
secret.key belongs with the database. Without it the stored TMDB, Radarr, Sonarr
and SMTP credentials cannot be decrypted. Back both up together — and never put that
backup in a public repository.
trash/ matters for a subtler reason: each quality profile records which TRaSH snapshot
it was written against. Restore a database without it and Nexview measures those profiles
against a different snapshot, reporting drift on profiles nobody touched.
hausordnung/ has the same catch on a smaller scale: the database holds only the name
of each image in the house rules, never the file. Restore without the folder and the text
survives with holes in it.
Nexview's own backups (Settings → System → Backups) already contain all of this: database, key, avatars, TRaSH snapshot and house-rules images. The list above is for backing up the directory by hand.
Only the download is encrypted. The copies Nexview keeps for itself, the automatic
one before every schema change and anything you create with Back up now, sit in
sicherungen/ inside the data directory as plain SQLite files. Whoever can read that
directory can read every account out of them, and out of every older state still being
kept. The password you type when downloading protects the archive you take away, not the
copies that stay behind. If that gap matters in your setup, the answer is to protect the
directory, not the file: a backup that Nexview could decrypt on its own would have to keep
the key next to it, which protects nobody.
secret.key is created with mode 0600 and tightened to it on every start, so an older
installation gets there too. That is hardening, not a wall: it helps when the database
travels somewhere without the directory around it.
In Container Manager under Project → Create, pick the project folder and use the
docker-compose.yml. Two adjustments are worth making:
ports:
- "5173:8000" # change the left number if 5173 is taken
volumes:
- /volume1/docker/nexview/data:/data
A fixed path instead of ./data makes backing up through Hyper Backup easier.
With network_mode: host there is no port mapping — the port inside the container is
the port on your server, and if something already sits on 8000, Nexview will not come up.
NEXVIEW_PORT moves it:
network_mode: host
environment:
NEXVIEW_PORT: 8123
Everyone else can ignore this. Without the variable Nexview listens on 8000 as before, and
the left number in ports: is what you reach it at.
You do not need to sort out permissions on that folder — the container sets them on
start. If you want the files to belong to a particular user, put their numbers in
PUID/PGID (find them over SSH with id username).
docker compose pull
docker compose up -d
The database is kept. Nexview brings it up to date itself on start: missing tables,
columns and indexes are added. Before anything is changed it writes a copy to
/data/sicherungen/, keeping the five most recent — so if something does go wrong, the
previous state is still there. The latest copy taken before an update is never rotated
out: it is the way back to the version you came from.
Do not simply start the older image on the updated data directory. An older Nexview cannot read what a newer one has written, and it changes data without saying so: it cancels open requests, drops 4K rights and rebuilds storage entries. From 1.0.0 on, Nexview guards against the worst of it:
That guard is deliberately narrow. Everything else can still change under a version older than 1.0.0: favourites, settings, invitations, tickets, the blocklist, children's wishes. A session that was already open keeps working there too. So if a version older than 1.0.0 was started on the updated database, even briefly, always go back with the backup below instead of carrying on with that database.
The way back is the backup taken before the update. It sits in sicherungen/ inside the
data directory and carries the comment Before update to … in its name, for example
nexview-automatisch-0.35.2-or-later-2026-09-26_091050-before-update-to-1-0-0.db. The
version in the name is the one the data came from; before 1.0.0 no version wrote itself
into the database, so for those it is the oldest it can be ("or later"). The start log of
the update names the exact file.
⚠️ Take that file, not a newer one. An older version started on the updated database
writes a backup of its own first, for example nexview-automatisch-0.35.2-….db without
the comment. It already holds the new data and does not take you back.
Going back works by swapping the file while Nexview is stopped, not through Restore in the settings:
docker compose down.nexview.db.nexview.db-wal and nexview.db-shm if they exist. They belong to the newer
database and would be replayed onto the old one.ghcr.io/derkezorm/nexview:0.35.2)
and start it: docker compose up -d.Everything done since the update (new requests, changed settings, new accounts) is not in that backup and is gone on the old version. Updating again later starts from the restored state and runs the update once more.
Nexview follows the usual MAJOR.MINOR.PATCH numbering:
| Image | Contents |
|---|---|
ghcr.io/derkezorm/nexview:latest | the latest released version — the recommendation |
ghcr.io/derkezorm/nexview:0.20.0 | exactly that one version, never changes |
ghcr.io/derkezorm/nexview:main | the current development state, may be broken |
The running version is in the footer and in detail under About Nexview, which also reports when a newer one exists. For that it asks GitHub at most once a day. The check sends nothing out of Nexview and can be switched off on the same page.
The full README is on GitHub: https://github.com/DerKezorm/nexview#readme
Content type
Image
Digest
sha256:a35f746d9…
Size
80.6 MB
Last updated
1 day ago
docker pull derkezorm/nexview