Comet: a Stremio search add-on that aggregates seventeen scrapers and nine debrid services

One add-on in front of many indexers

Comet is a Stremio add-on for searching torrents, debrid links and usenet, and the design is that it is one add-on rather than one per source. The list of supported scrapers is long: Jackett, Prowlarr, Torrentio, Zilean, MediaFusion, Debridio, StremThru, AIOStreams, Comet itself, Jackettio, TorBox, Nyaa, BitMagnet, TorrentsDB, Peerflix, DMM and SeaDex.

The name of the project is a comment on its ambition. The repository description calls it Stremio's fastest torrent, debrid and usenet search add-on, and the release history shows that ambition being pursued hard, with v2.58.0 on 2026-07-27, v2.57.0 on 2026-07-26 and v2.56.0 on 2026-07-25. The last push to the repository was on 2026-08-26.

The service layer is FastAPI with uvicorn and gunicorn, so it is a normal HTTP API that the Stremio and Kodi clients talk to. The relationship with the wider *arr ecosystem is through Torznab, with official Prowlarr, Sonarr, Radarr and Jackett integration documented separately, which means a user who already runs Jackett can expose it as a Torznab indexer and have Comet query it as one of its sources.

There is also a dedicated Kodi add-on with automatic updates, shipped as a separate directory in the same repository with its own documentation, so the same backend serves both clients.

Because this software points at content sources and integrates with paid link-resolution services, the responsibility for what you do with it sits with you. The debrid providers listed are Real-Debrid, All-Debrid, Premiumize, TorBox, Debrid-Link, Debrider, EasyDebrid, OffCloud and PikPak, and Direct Torrent is also supported, so whether a given arrangement is permitted depends on the terms of the service you configure and on the content itself.

Debrid resolution, proxying, and the connection limit

The debrid integration is the reason the tool is more than a search box. Instead of returning a magnet link, a debrid service takes the magnet, resolves it to a cached file, and gives back a direct link. The add-on can then proxy that stream, and one of the listed features is proxying debrid streams to allow simultaneous use on multiple IPs, which is aimed at the situation where a debrid provider restricts an account to a limited number of concurrent streams.

There is also proxy support to bypass debrid restrictions, and an IP-based max connection limit, which is the mirror image of that: the add-on can cap how many simultaneous connections it will make from one address.

The Debrid Account Scraper is a different feature from the resolution itself. It scrapes torrents directly from your debrid account library, so the add-on can search what you already have as well as what is available. And there is a DMM Ingester that automatically downloads and indexes Debrid Media Manager hashlists, which is how a large curated hash list becomes searchable.

The ranking of results is a separate concern again, described as smart torrent ranking powered by TPR, the torrent-parse-rank project. The dependency is pinned in the manifest as a git source rather than a release, so it tracks the tip of that repository.

There are content and protocol features worth noting as well: an adult content filter, ChillLink protocol support, and Kitsu support for anime. The adult content filter is one of the more practical settings for anyone deploying this for other people, and it is a reminder that a self-hosted instance is a service you expose to whoever can reach it.

Caching, ranking, and a background scraper

The feature list includes a caching system backed by SQLite or PostgreSQL, a background scraper described as fast, and a production-ready Prometheus and Grafana observability stack with its own documentation page.

The caching layer matters more than it sounds for this kind of service. Every search fans out to a dozen or more indexers, each of which is a network request to a third party with its own rate limits and its own habit of returning garbage sometimes. Caching the results means the same query does not cost the same set of upstream calls every time, and it means the add-on can answer quickly even when a particular indexer is slow or down. The manifest carries both aiosqlite and asyncpg, along with the databases library that abstracts the two, so the same code runs against either backend.

The two databases are the same choice with different reasons. SQLite is a single file, needs no separate service, and is the right default for a single-user instance on a small box. PostgreSQL is the choice when the cache is large enough that file locking becomes the bottleneck, or when you want to query the cache from elsewhere.

The administration dashboard is where the operational features live, with a bandwidth manager and metrics among them, which suggests the project treats this as something you run for months rather than a weekend. The observability documentation is described as production-ready, and the dependency list includes prometheus-client alongside the FastAPI stack, so the metrics are exported in the format Prometheus scrapes rather than being a bespoke endpoint.

The other elements of the stack reflect the work: curl-cffi for HTTP with browser-like TLS fingerprints, bencode-py and demagnetize for handling torrent metadata, xxhash for fast hashing, and miniupnpc for UPnP port mapping.

CometNet shares metadata, never files

CometNet is the feature that distinguishes this from an ordinary aggregator, and the description is precise about what it does and does not do.

It transforms a Comet instance from an isolated scraper into a participant in a collaborative network. Instead of each instance independently discovering the same torrents, CometNet allows instances to share their discovered metadata, hashes, titles and so on, in a decentralized way. The emphasis is that no actual files are shared.

That distinction is the whole safety argument for the feature, and it is worth sitting with. The metadata is the magnet hash and the title and the size, which is enough to find content but not the content itself. So a node running CometNet gets better coverage, because it receives metadata discovered by other nodes, and it does less redundant scraping, because the network has already looked. Files still come from the debrid service or the torrent client in the usual way.

The third element is trust pools, described as optional closed groups for trusted metadata sharing. That is the mechanism for a user who does not want their instance talking to arbitrary nodes, and it is the setting to reach for in a shared or multi-user deployment. The implementation uses websockets and msgpack from the dependency list, and it runs inside the same FastAPI service.

The CometNet documentation is in a separate directory under docs, and it is worth reading before enabling the feature, because the network topology you are joining is the thing you are actually deciding about.

Running it, and the shape of a production container

The self-hosted path from source is four steps. Clone the repository, install the dependencies with uv, and start the service:

git clone https://github.com/g0ldyy/comet
cd comet

pip install uv
uv sync

uv run python -m comet.main

The project uses uv as its package manager, and the repository carries a uv.lock alongside the pyproject.toml, so the dependency set is reproducible. The manifest requires Python 3.13 or newer, and the.python-version file in the repository pins it.

The configuration is entirely through environment variables, and the instruction is to look at the.env-sample file first to customise the experience. That file is the actual configuration reference, and it is where the debrid credentials, the scraper toggles, the cache settings, the admin dashboard settings and the CometNet options live.

The Docker path has dedicated documentation, with a beginner step-by-step guide under docs/beginner and a full documentation index under docs/README.md.

The Dockerfile is a careful multi-stage build. It starts from the uv image at version 0.11.32 and a rust 1.97.1 slim trixie base for the toolchain, then builds on python:3.13-slim-trixie with gcc, git, libc6-dev and make available. The dependency layer is cached with a uv cache mount keyed on the target platform. The runtime stage is a much leaner image with only libgcc-s1, libmimalloc3, libstdc++6 and tzdata installed, and it sets LD_PRELOAD to libmimalloc.so.3, which is how the memory allocator is swapped in. Build metadata is baked in as environment variables for the commit hash, the build date and the branch, and there is a HEALTHCHECK that runs python -m comet.healthcheck every 30 seconds with a 5 second timeout and 3 retries, which means orchestrators will restart an unhealthy container.

Where this kind of add-on stops being the right answer

The first limitation is that this is a self-hosted service with a large configuration surface, not an install-and-go add-on. The whole feature set is behind environment variables, and the documentation asks you to read the .env-sample file before doing anything else. A user who wants a single tap in Stremio is not the audience here.

The second limitation is that the value depends entirely on the upstream services. Comet aggregates indexers, and the quality of the results is the quality of those indexers, which are third-party services that change, rate limit and disappear. A configuration that produces good results today can degrade without any change on your side, and the troubleshooting path runs through the individual scraper integrations rather than through anything in the add-on itself.

The third limitation is that the caching and background scraper are heavy for a single user. The features that justify running it as a service, the dashboard, the bandwidth manager, the observability stack, the network participation, all make sense if you have a media server setup with real traffic. On a laptop with one user and a debrid account, most of that machinery is overhead.

On maintenance, the repository is not archived and the last push was on 2026-08-26, and the release cadence through 2026 is measured in days, so the project is being worked on continuously. The licence is GPL-3.0, which for a service you run yourself has no distribution implications unless you redistribute it, and the project is community-driven with funding through GitHub Sponsors and Ko-fi.

Editorial conclusion

Comet fits a Stremio or Kodi user who already pays for a debrid service and wants one add-on that queries every indexer at once instead of installing a separate add-on per tracker, and who is comfortable configuring it through environment variables and running it as a service. It is a poor fit if you want a plug-and-play experience, since the self-hosted path is a deliberate configuration exercise, and a poor fit for a shared or public deployment, because the proxy and connection limit settings are aimed at personal use. Before adopting, read the .env-sample file end to end, decide whether you want the SQLite or the PostgreSQL cache, and understand that you remain responsible for the content you access and for the terms of the services you configure.

Frequently asked questions

Official sources

1. g0ldyy/comet on GitHub
2. Issues
3. License: GPL-3.0
4. README
5. Releases