A self-hosted web panel to download films, TV series and anime into a Jellyfin library.
Request queue, followed series, notifications to Discord and Telegram, and an integrated
file manager.
The start page — the source's own shelves, browsable before you have searched for anything.
- Search and download films, TV series, and anime
- Recovers the source domain on its own when it rotates: finds the new one, verifies it, and proposes it for one click
- Plot, genres, rating, artwork and trailers on the title page — no API key required
- Automatic quality selection (1080p → 720p → 480p → 360p)
- Parallel HLS segment download with AES-CBC decryption
- Multi-audio track merge via FFmpeg
- Subtitle download (
.vtt) for non-Italian audio tracks - Real-time download progress with per-phase steps (video → audio → merge)
- Integrated file manager with drag-and-drop, video streaming and free space on the media volume
- Jellyfin library path configuration, and an optional library refresh when a download lands
- Post-download webhooks with a body template
- Configurable file and folder names
- Scheduled downloads
- Follow a series or anime and get new episodes as the source publishes them
- Notifications to Discord, Telegram, ntfy and anything else Apprise speaks, with per-channel event selection
- One notification per download — and a single summary for a whole season or series
- Optional login with Jellyfin credentials — no second account, no local password store
- Independent permissions: download directly, request, approve, manage users, manage settings
- Request queue with approval, preserving the audio and subtitle tracks the requester chose
- Request status on the search result cards, and an in-app notification bell
- MCP server for AI agents (Claude Code, Cursor, …): search, download, follow series and work the request queue
- Docker ready
curl -O https://raw.githubusercontent.com/EdoardoFiore/StreamingCommunity-downloader/main/docker-compose.template.yml
# Edit the volume paths — create the config one — then:
docker compose -f docker-compose.template.yml up -dThe panel is available at http://localhost:8000. Set the source domain in Impostazioni on first
use: it is not shipped in the image, because it rotates.
The image is published to GitHub Container Registry on every push to main:
ghcr.io/edoardofiore/streamingcommunity-downloader:latest
By default the container runs as root, so the files it downloads belong to root. To have them
belong to you instead, uncomment user: in the compose file with your uid and gid (id -u,
id -g):
user: "1000:1000"That user has to be able to write the library and the config folder on the host. If the panel ran as root before, hand them over once:
sudo chown -R 1000:1000 /srv/scpanel/config # and the library, if root wrote files thereIf it still cannot write its config or its temp folder, the panel does not start, and the log names the uid and every path it is missing. A library it cannot write is only a warning — it may be a network mount that comes up later — but downloads into it will fail.
The release image, latest included, is published only by a v* tag, so following it means getting
releases and nothing else. A push to main runs the tests and publishes nothing.
Every push to a branch other than main publishes to a separate package, so a work-in-progress
build can never be pulled by a deployment pointing at the release image:
ghcr.io/edoardofiore/streamingcommunity-downloader-dev:dev # the latest branch build
ghcr.io/edoardofiore/streamingcommunity-downloader-dev:my-branch # that branch only
ghcr.io/edoardofiore/streamingcommunity-downloader-dev:sha-abc1234 # one exact commit
Tests have to pass first: a red pytest -q publishes nothing.
curl -O https://raw.githubusercontent.com/EdoardoFiore/StreamingCommunity-downloader/main/docker-compose.dev.template.yml
# Point panel_config_dev at a NEW directory, then:
docker compose -f docker-compose.dev.template.yml up -dIt listens on http://localhost:8001 so it can run alongside the release panel. Give it its own
config directory: database migrations only run forwards, so pointing a dev image at the
production config volume upgrades the real database with no way back.
git clone https://github.com/EdoardoFiore/StreamingCommunity-downloader.git
cd StreamingCommunity-downloader
pip install -r requirements.txt
python main.py
pip install -r requirements-dev.txt # tests only
pytest -qPrerequisites: Python ≥ 3.11, FFmpeg.
v1 is the panel before the Jellyfin login existed. Pulling the new image changes nothing by default: a panel that was running without a login keeps running without one. You will see the redesigned interface, and you have to set the source domain once (see above).
To turn the login on, copy the /app/config volume and the DB_FILE / DATA_FILE /
SCHEDULE_FILE variables from docker-compose.template.yml, then connect Jellyfin from
Impostazioni → Accesso e utenti. That volume is not optional: users, sessions and requests live
in panel.db, which without it sits inside the container and is lost on every pull — including the
answer to the setup question, which would then be asked again on every restart.
To stay on v1, pin the tag instead of following latest:
image: ghcr.io/edoardofiore/streamingcommunity-downloader:1.0.0If you were running the -jellyfin image from the development branch, change the image: line to
the main one above — that package is frozen and no longer built. Nothing else changes: the variables
and the /app/config volume are the same, so panel.db and your users carry over as they are.
On first run the panel asks once, on its setup screen, whether to use Jellyfin. Choosing Collega a Jellyfin configures the panel and creates its administrator from that sign-in; only a Jellyfin administrator can do it. After that, Jellyfin accounts do not get access automatically — an administrator imports them from Utenti and assigns permissions. Opening the panel to every Jellyfin account is a switch on that page, off by default.
Permissions are independent flags, not a ladder:
| Permission | Grants |
|---|---|
DOWNLOAD |
start and schedule downloads directly |
REQUEST |
search and create requests |
MANAGE_REQUESTS |
see the queue, approve, deny, fix |
MANAGE_USERS |
import users, assign permissions, disable accounts |
MANAGE_SETTINGS |
source domain, libraries, performance |
MANAGE_FILES |
move, rename and delete in the file manager |
VIEW_LIBRARY |
browse and stream the library |
There is deliberately no "admin" flag that implies the rest, so you can have an administrator who manages settings and users but never sees the request queue.
A user without DOWNLOAD sees the same form and the same audio and subtitle checkboxes; the button
says Richiedi and creates a request. On approval the source is re-resolved against the current
domain — a dead link or a missing audio track parks the request for a human instead of downloading
the wrong thing.
Two people asking for the same content with the same tracks share one download and are both notified. Asking for different tracks makes two distinct requests, because merging them would give one of them the wrong file — but they resolve to the same path in the library, so the download fetches the union of what everyone asked for. Two people wanting one film in Italian and English get one file carrying both, and the player picks. A request whose tracks are already in the file is satisfied without downloading anything: the check reads the file's audio and subtitle streams, not its name.
Press Continua senza Jellyfin on the setup screen and the panel runs with no login at all: every visitor gets direct download, settings and the file manager. You can connect Jellyfin later from Impostazioni → Accesso e utenti, without a restart.
There is no environment variable for this. It used to be AUTH_ENABLED, which is gone: set to 0
it did not just default to open mode, it hid the setup screen altogether, so the choice the panel
offers could not be made. An existing deployment that was running without it keeps open mode across
the upgrade — the panel writes that answer into panel.db the first time it starts.
Going back — from a connected Jellyfin to no login — is deliberately not offered in the UI: the imported users and their permissions would be left in an ambiguous state.
Any series or anime can be followed from its page. From then on the panel checks the source periodically and picks up new episodes as they are published. Following means from here on: everything already released is recorded as seen, so you do not get eight seasons queued the next morning.
What happens to a new episode depends on the permissions of whoever follows it:
- someone who can download finds it in the library on its own;
- someone who can only request produces an ordinary request for an approver to accept.
In the second case the approver is told when the series is followed, not weeks later when an episode finally appears, and can approve the series once: from then on its new episodes go straight through, and only that series is affected. The choice is on the Serie seguite page, or on the "Auto i prossimi" checkbox of the request itself.
A watch never downloads anything by itself — it creates a normal request and lets the queue, the library check and the notifications do their work, so nothing is duplicated and nothing is silently substituted. Controlla ora forces a check immediately instead of waiting for the next cycle; the interval is in Impostazioni → Download.
The Serie seguite page lists what you follow, when it was last checked, and whether it downloads automatically or goes through the queue. An approver also sees everyone else's, with who follows each one.
The panel notifies in two directions.
In-app, the bell holds request and download events for the signed-in user, and they can be marked read or deleted, one at a time or all at once. On a panel running without Jellyfin the bell belongs to the panel itself, so an open installation still sees its own downloads.
Outward, any number of channels can be configured in Impostazioni → Notifiche by pasting an Apprise URL — Discord, Telegram, ntfy, Gotify, Slack, email, and everything else Apprise supports. No key in the compose file, no restart. Each channel chooses which events it wants; selecting none means all of them. Messages carry a title and are coloured by outcome where the service supports it, and errors have their query strings stripped before they leave the panel, since external channels are somebody else's servers.
Channels are global, not per user: whoever configures one decides what reaches everybody reading it.
Download notifications are grouped by the action that caused them — one for a film or a single episode, and a single summary for a whole season, series or anime, listing any episodes that failed and why.
| Variable | Default | Purpose |
|---|---|---|
HOST / PORT |
127.0.0.1 / 8000 |
bind address |
VIDEOS_DIR |
videos |
download destination |
DB_FILE |
panel.db |
users, sessions, requests — put this on a persistent volume |
DATA_FILE |
data.json |
source domain, libraries, performance settings |
SCHEDULE_FILE |
schedule.json |
scheduled downloads |
TMP_DIR |
tmp |
HLS segments while a job runs, cleaned up afterwards; writable by any uid in the image |
FFMPEG_PATH |
— | full path to ffmpeg, when it is not on PATH |
FFPROBE_PATH |
— | full path to ffprobe; see the note below |
DOMAIN_SOURCE_URL |
a public page | where replacement domains are read from |
DOMAIN_NAME_PATTERN |
streaming(community|unity)… |
which names may be adopted automatically |
COOKIE_SECURE |
0 |
set to 1 when serving over HTTPS |
COOKIE_SAMESITE |
lax |
none (with COOKIE_SECURE=1) only to embed the panel cross-site |
TRUST_PROXY_HEADERS |
0 |
set to 1 only behind a reverse proxy you control |
The source domain and the Jellyfin library paths are configurable from Impostazioni in the UI.
FFmpeg and ffprobe. ffmpeg is required; the Docker image installs it. Without one on PATH
the panel falls back to the static binary bundled with imageio-ffmpeg, which is what makes it work
on Windows. ffprobe is optional but recommended: it is what lets the panel read which audio and
subtitle tracks a file in the library already carries, so a request for a track that is missing is
not mistaken for one that is already satisfied. Debian's ffmpeg package ships both, so the image
has it; where it is absent the panel treats an existing file as satisfying the request and says so
in the log.
panel.db holds the Jellyfin service API key: keep it out of any web-served directory and off
world-readable storage.
Run one process. Download state is held in memory by a single process, so do not add
--workers or scale the service — a second replica would neither see nor report on the first's
downloads.
Point an iframe at the panel; nothing else is required. Sign in once inside the tab and stay signed in — the session lasts 30 days and renews on every visit, so in practice you log in once and forget about it.
With Jellyfin and the panel on subdomains of the same domain over HTTPS — say jf.example.com and
request.example.com — the frame is same-site and the session cookie is sent inside it with the
default COOKIE_SAMESITE=lax. On different domains, or different schemes, the frame is cross-site
and a Lax cookie is dropped silently: every request inside the frame looks logged out and login
bounces back on itself, which reads as an infinite loop. Either set COOKIE_SAMESITE=none together
with COOKIE_SECURE=1 — browsers reject a SameSite=None cookie that is not also Secure — or
reverse-proxy the panel under the same site as Jellyfin.
Chromium browsers separately enforce Private Network Access: the Jellyfin page and the panel must both resolve to public addresses, or both to private ones, from the browser's point of view. Mixing tiers fails with "the connection was blocked".
POST /api/auth/jellyfin-token trades an already-issued Jellyfin access token for a panel session,
for skipping even that one login. It needs a script running on the Jellyfin page, which posts the
token to the frame. Do not put that script in the custom tab HTML: tab content is injected as a
string, so quoting breaks the page, and <script> tags inserted that way never execute.
The source's domain changes every few weeks, and until now that simply stopped the panel: searches failed and nothing said why. It now notices, reads the current address from a public page, checks it actually serves the source, and shows a banner offering to switch.
It proposes; you apply. That page is edited by people nobody here controls, and the domain decides where every search, image request and download referer goes — so adopting one because a web page said so, with nobody looking, is not something the panel does by default. Only second-level domains whose name matches the expected one are ever considered, and only if they answer like the source. Anything refused is reported rather than swallowed, because a genuine rebrand and an edited page look identical from the inside; you can always type a domain in by hand.
Impostazioni → Sorgente has a switch for adopting the new domain without asking, off unless you turn it on, and a "Controlla ora" button.
Opening a title shows its plot, genres, rating, backdrop and trailer. All of it comes from the source's own title page — the same page the panel already reads — so there is nothing to configure, no account anywhere, and no request beyond the one already being made.
TMDB was tried as a second provider and dropped. Measured on real titles it was not an upgrade: the site copies its synopses from TMDB, so the text was usually identical, while the round trip lost a trailer on one title, a logo on another and 1100 characters of plot on a third.
Artwork is proxied through the panel, so the browser never talks to anybody else. Metadata is fetched when you open a title, never for a whole page of search results.
The video is resolved through the source's embed page, which sits behind Cloudflare and occasionally refuses. When that happens the title's page now says so, instead of leaving you with a download button that looks fine and a job that fails minutes later.
A second route through another provider was built and then removed: the service it relied on no longer publishes anything usable without reverse-engineering its internals, which would break silently every time they deploy. The seam it plugged into is still there, so adding one later is a small change rather than a new feature.
Impostazioni → Hook can tell something else that a file has landed.
- Jellyfin: one switch, using the server already configured for login. The library updates immediately instead of on Jellyfin's own schedule.
- Webhook: a URL, a method and an optional body, where
{title},{path},{status},{type},{season},{episode},{year}and{error}are substituted. With no body a JSON object carrying all of them is sent.
There is no "run a command" hook, deliberately: on a panel running without login, settings are open to every visitor, and a command would hand them a shell. A webhook can point at your own network — that is how it reaches Jellyfin — so the panel reports only whether the call succeeded, never what came back.
The panel asks GitHub for newer releases shortly after it starts and every 6 hours after that. When there is one, a badge appears beside the version number in the sidebar, for users who can manage settings, and opens the release notes of every version you are behind. The check installs nothing.
Impostazioni → Aggiornamenti shows the last check, checks on demand and turns the periodic check off. It is the one call the panel makes that downloading does not need. It sends GitHub your address and the panel's version, as any request to it would, and needs no token.
By default the dialog shows the commands to run, docker compose pull and docker compose up -d.
For an Aggiorna ora button instead, add the updater service to your compose file: an existing
deployment has to edit it, because a running container cannot give itself a new service. The three
commented blocks are in docker-compose.template.yml:
services:
web:
volumes:
- updater_socket:/run/scpanel-updater:ro
updater:
image: ghcr.io/edoardofiore/streamingcommunity-downloader-updater:latest
network_mode: none
volumes:
- /var/run/docker.sock:/var/run/docker.sock
- ${PWD}:${PWD}:ro
- updater_socket:/run/scpanel-updater
restart: unless-stopped
volumes:
updater_socket:Run docker compose up -d once, from the folder holding the file.
This service mounts the Docker socket, which is root on the host. It has no network and does one thing: pull the image your file names for
web, and recreate that service. The panel never touches the socket; it talks to the service over a Unix socket in the shared volume, with no port and no parameters. On a panel running without login, every visitor can press the button, though only when a new release is out and no download is running.
What to expect:
- Downloads first. The update is refused while a download is running, queued or paused, because restarting would lose them. Scheduled downloads survive.
- A copy of the database is saved beside it as
panel.db.pre-update, overwritten each time. Migrations only go forward: going back to an older image needs this file. - No automatic rollback. If the new version does not start, the dialog says so after a while and
docker compose logs webhas the reason. - A pinned tag stays pinned. With
:2.6.0in the file the pull changes nothing and the dialog says so. The same happens for a few minutes after a release, while its image is being built. - It updates the panel, not itself. Update the
updaterservice with the usual commands. - One extra restart is possible. When the host's Compose is a different version from the
service's, the first manual
docker compose up -dafter an update can recreatewebonce, on the same image. Run it when no download is active. - Not for every setup. Stacks with no folder on the host (Portainer, for one) cannot use this
service, and neither can a file relying on variables exported in your shell instead of
.env.
Impostazioni → Nomi sets how files and folders are named, per type. Each field is left blank when it matches the default, and shows that default as its placeholder — so an untouched field reads as "nothing changed here" rather than as a value somebody chose. Saving a blank field keeps the default.
The defaults follow the structure Jellyfin's own documentation recommends, which is the layout below. Change them only if your library already follows a different convention: Jellyfin recognises this one with no configuration at all.
Placeholders: {title}, {year}, {season}, {season2}, {episode}, {episode2} — the 2
variants are zero-padded. Anything in square brackets appears only if the placeholders inside it
have a value, so [ ({year})] disappears entirely for a title with no year. Each field previews
itself as you type.
Changing a rule does not rename what is already there. Existing files keep being recognised, so nothing is downloaded twice; they simply keep their old names until you rename them in the file manager.
The panel can act as an MCP server, so an AI agent (Claude Code, Cursor, or any
client speaking Streamable HTTP) can search titles, start and watch downloads,
follow series and file or approve requests. It is served by the panel itself at
/mcp — no extra port, and the same reverse proxy and TLS as the web interface.
Off by default. Enable it under Impostazioni → MCP, then generate a token. The token is shown once (only its hash is stored), and the agent acts as the user who generated it, with that user's current permissions: an agent cannot download if its owner cannot, and the token stops working if the owner is disabled or removed. Requests it files are that user's requests.
Client configuration (the settings page shows it pre-filled):
{
"mcpServers": {
"streamingcommunity": {
"type": "http",
"url": "https://panel.example.com/mcp",
"headers": { "Authorization": "Bearer <TOKEN>" }
}
}
}With Claude Code: claude mcp add --transport http streamingcommunity https://panel.example.com/mcp --header "Authorization: Bearer <TOKEN>".
Tools: search_content, get_content_details, get_series_episodes,
get_anime_episodes, get_home_shelves, download_film, download_episode,
download_season, download_anime_episode, list_downloads,
get_download_progress, cancel_download, retry_download, follow_series,
list_followed_series, unfollow_series, check_series_now, submit_request,
list_requests, approve_request, get_system_status, list_libraries.
videos/
├── Movie (2020)/
│ ├── Movie (2020).mkv
│ └── Movie (2020).en.vtt
└── Series (2019)/
└── Season 01/
├── Series S01E01.mkv
└── Series S01E02.mkv
The container is yours to pick, in Settings -> Download -> Output format: .mkv (the default,
which holds any combination of tracks) or .mp4, for devices that cannot play Matroska — plenty of
older smart TVs, Chromecast and consoles. Nothing is re-encoded either way, so the choice costs no
download time: the source is already H.264 with AAC audio, which both containers take as they are.
Subtitles follow a second setting: muxed into the file, or written beside it as
{name}.{lang}.vtt, the layout Jellyfin expects. Inside an MP4 they have to be converted to
mov_text, which drops colours, bold and positioning — keeping them as separate files avoids that
entirely.
Changing either setting leaves what is already downloaded alone. Both extensions keep counting as present, so nothing is re-downloaded because of it.
MIT
This project is published for informational and educational purposes only. It exists to demonstrate how HLS streams are parsed, how AES-CBC segment decryption works, how a download queue and a permission model are built, and how the result is organised into a Jellyfin library.
It hosts, stores and distributes nothing. It contains no content, no catalogue and no index. It is a client: it talks to third-party websites that it neither operates nor controls, and it has no affiliation, sponsorship or endorsement from any of them — StreamingCommunity, AnimeUnity and Jellyfin included. Every trademark belongs to its owner. Whether those sites are lawful to use, and whether they remain reachable at all, is entirely outside this project's control.
Using it is your decision and your responsibility. You are the one who has to comply with the copyright law of your country and with the terms of service of any site you point it at, and you should only download content you hold the rights to or are otherwise entitled to access. Neither the authors nor the contributors take any responsibility for how the software is used, nor for any damage or legal consequence that follows from using it.
The software is provided "as is", without warranty of any kind, as set out in the LICENSE.
If you represent a rights holder and believe something here is a problem, please open an issue and it will be addressed.












