Hello everyone! In this article, we will explore Jackett, a useful and straightforward solution for finding torrents, as well as its alternatives for both user interfaces and API (Application Programming Interface).
Overview
Previously, I shared insights about my small project that allows for managing torrent clients and provides access to the Kinozal tracker interface (with integration to the TMDB database) via a Telegram bot. Although this discussion will focus on different aspects, I want to emphasize that such a solution serves as a commendable alternative to the servarr stack. Based on the feedback received, many users found the bot’s setup to be even simpler. The primary goal of this setup is to consolidate all interfaces into one, enabling users to search for and manage content downloads remotely from their phones. One notable limitation of the bot is its support for only one tracker for media content searches, which, however, is often sufficient.
Recently, I added the capability and instructions for running the bot in a Docker container.
Returning to servarr, it’s worth noting that this solution adopts a fundamentally different architectural approach. For instance, Sonarr automates the process of searching for and downloading series by tracking new episode releases and automatically downloading based on specified criteria. However, users still need to interact with the interface periodically. A significant challenge I encountered was the lack of content search with Russian localization, a problem that Jackett addresses effectively (like other services mentioned in this article, it is open-source on GitHub).
Jackett
Jackett serves as an API (essentially a remote management interface for utilizing its functions in other applications) for a vast number of providers, facilitating centralized and simultaneous (parallel) searches across multiple trackers. Beyond its API, the user interface is particularly beneficial, allowing users to search for torrents without needing to navigate various websites. After familiarizing yourself with this interface, you might find yourself deleting all your tracker bookmarks from your browser. It’s impressive that everything is available out of the box, without requiring additional plugins or modules (unlike plugins for qBittorrent, which I will discuss shortly). You can launch it either through an executable file or as a service on Windows (available for download in the GitHub repository) or, more conveniently, in a Docker container. Here’s an example of launching the container with a single command:
# Create a directory for Jackett data
sudo mkdir /jackett
# Run the Jackett container
sudo docker run -d
--name=jackett
-e PUID=1000
-e PGID=1000
-e TZ=Etc/UTC
-e AUTO_UPDATE=true `#optional`
-e RUN_OPTS= `#optional`
-p 9117:9117
-v /jackett/data:/config
-v /jackett/blackhole:/downloads
--restart unless-stopped
lscr.io/linuxserver/jackett:latestSettings for all trackers (also known as indexers) are stored in the directory /jackett/data/Jackett/Indexers/ (on Windows: C:ProgramDataJackettIndexers), while the server configuration can be found at /jackett/data/Jackett/ServerConfig.json (on Windows: C:ProgramDataJackettServerConfig.json). Transitioning from Windows to Linux (directly to the container, as I did) is seamless, requiring only the replacement of files in the specified directories.
The interface is designed to be maximally simple yet convenient. All settings are located on the main and only page in the browser, and adding trackers for indexing requests is done through a modal window in the interface.
There are 63 Russian-speaking trackers available for search, of which 26 are public (meaning they do not require authentication for searching and downloading files). The total number amounts to a remarkable 612. You may discover new valuable sources from this list, but it’s generally more convenient to add and use multiple indexers simultaneously.
All that is required from the user is to select the appropriate providers (which is easily done using the built-in filters) and click ➕ to add them. If it’s a private tracker, you’ll need to click the settings button and fill in the authentication details before you can start searching and downloading torrent files by invoking the interface with the Manual search button:
In addition to searching, Jackett provides an RSS feed with category support (filtering by content type, genre, region, etc.). This is particularly useful if you want to monitor torrents on a specific topic. For example, I’m interested in ROMs for Nintendo Switch, so I open the tracker settings and find the necessary category identifier (using the Ctrl+F shortcut in the browser) by name:
In the list of indexers, I click copy RSS Feed and append the required identifier to the end of the copied URL. The result looks something like this: http://127.0.0.1:9117/api/v2.0/indexers/tracker/results/torznab/api?apikey=&t=search&cat=101605 (where 101605 is the identifier number), which can be added to any RSS client for monitoring. For reading feeds, I recommend the desktop application Fluent Reader (available on all platforms, featuring a pleasant and modern interface) or the browser extension Feedbro.
That covers the interface; from here, you can link Jackett to Sonarr, Radarr, or other applications in their interface settings (instructions for this are provided on the interface page) through the API (the access token can be found in the upper right corner of the interface) to utilize torrent searches via Jackett. Here’s an example of adding it in the Sonarr settings:
qBittorrent Search Plugins
If you are more interested in the search interface, there is one minor drawback with Jackett: it requires the server component to be installed on a device (and access to the local network if you’re using a dedicated computer for such purposes). Alternatives exist, such as plugins for the qBittorrent torrent client (which can also function as an RSS client in a separate tab), where the search appears as follows:
The convenience of this solution lies in the ability to immediately view the contents of any torrent and download content directly within the client. The interface is quite similar to Jackett, though I find it less visually appealing; each new query opens a new window (which can sometimes be more convenient), and connecting a large number of trackers requires significantly more configuration.
To enable this functionality, you need to install the corresponding tracker plugins. An unofficial (created by third-party developers) list of plugins can be found in the Wiki on GitHub. For instance, the repository for the most popular Russian-speaking quartet is available here, and support for these is ongoing. Installation instructions can typically be found in the plugin repository description, although the process is generally consistent (except for filling in authentication details through configuration), which can be reviewed here. To simplify the installation of plugins, a PowerShell script can be utilized (which is also convenient for debugging when writing your own plugins using Python).
A Bit About the API
While the search functionality in the Jackett interface is incredibly convenient, it primarily serves as a demonstration of its capabilities, which are accessible to external applications via the API. Here’s an example of a request to the API using Windows PowerShell:
# Example with the API token
$API_KEY = "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
# Request RSS from the Russian tracker (RuTor)
Invoke-RestMethod "http://127.0.0.1:9117/api/v2.0/indexers/rutor/results/torznab/api?apikey=$API_KEY"
# Filter categories for the latest releases
Invoke-RestMethod "http://192.168.3.101:9117/api/v2.0/indexers/rutor/results/torznab/api?apikey=$API_KEY&cat=8000"
# Search query
$query = "The+Rookie"
Invoke-RestMethod "http://127.0.0.1:9117/api/v2.0/indexers/rutor/results/torznab/api?apikey=$API_KEY&t=search&cat=&q=$query"By default, the output is generated in XML format:
The output includes a structured set of properties, with key parameters being Title for the torrent title, size for the torrent size, and guid and link (magnet link with info hash) for downloading. However, this information often lacks sufficient detail about the content (such as translation and dubbing information).
While developing the Kinozal bot (mentioned at the beginning of this article), I searched extensively for an API that would provide more detailed information for analyzing torrents and convenient usage within the bot without needing to scrape data directly from the tracker’s page. Although I didn’t find a suitable solution, I did discover another interesting project—Torrent-Api. Essentially, this is an alternative to the Jackett API, supporting 16 trackers but lacking a user interface. Initially written in JavaScript using Express, it was later rewritten in Python with FastAPI, and for ease of use, Swagger documentation is automatically generated by this framework. This project, along with the absence of similar solutions for Russian-speaking providers, motivated me to create my own API server—TorAPI, which not only supports searching but also provides additional information for each torrent based on its identifier.
For detailed information about the TorAPI project, you can visit the GitHub repository. The goal of this API is not only to facilitate searches but also to retrieve comprehensive information about any torrent on the specified tracker. The descriptions of published torrents often contain valuable information sourced from various origins and can also be supplemented by the author, making them unique. When searching by identifier, you can obtain detailed descriptions of movies, series, or other content, as well as the contents of the torrent (file lists), links to posters, ratings in film databases, translation information, dubbing, etc. This is a public and accessible API, hosted on Vercel, and it can also be run locally in a Docker container. The OpenAPI specification is available on the official Swagger Hub website.
Chrome Extension
The API serves as the backend (essentially information in text form), which is why a simple interface was developed to demonstrate the functionality of TorAPI. This interface operates in a modal window (overlaying the current browser tab) and visually resembles Jackett. It is accessible via the LibreKinopoisk extension for Google Chrome, which does not require you to install the server component or any other settings for it to function, aside from installing the extension itself. The search interface appears as follows:
Initially inspired by another project—YoK—this extension was rewritten and expanded with additional buttons for quicker content searches from external sources due to the original extension’s non-functioning players. Detailed information about the extension’s capabilities and installation instructions can be found on GitHub.
