Best Jackett Setup for [Mention Target Application – e.g., Sonarr, Radarr]

By /

Okay, here’s a comprehensive article detailing the best Jackett setup for Sonarr and Radarr, covering installation, configuration, indexer selection, troubleshooting, and advanced techniques. Because the best setup is subjective and depends on user needs and preferences, this guide will focus on providing a flexible, robust, and generally optimal setup, with explanations and alternatives along the way.

Best Jackett Setup for Sonarr and Radarr: A Comprehensive Guide

This guide details the optimal configuration of Jackett to work seamlessly with Sonarr (for TV shows) and Radarr (for movies). We’ll cover everything from initial installation to advanced troubleshooting and optimization, allowing you to create a powerful, automated media acquisition system.

I. Introduction: Why Jackett?

Sonarr and Radarr are fantastic tools for managing and automating the downloading of TV shows and movies. They use “indexers” to search for content on various torrent and Usenet sites. However, natively, they only support a limited number of indexers. This is where Jackett comes in.

Jackett acts as a proxy server. It translates queries from Sonarr/Radarr into tracker-site-specific HTTP queries, parses the HTML or JSON responses, and then sends the results back to Sonarr/Radarr in a format they understand. Essentially, Jackett dramatically expands the number of trackers Sonarr and Radarr can use, increasing the chances of finding the content you want, especially for older or more obscure releases.

II. Installation

The installation process varies slightly depending on your operating system. We’ll cover the most common scenarios:

  • A. Windows:

    1. Download: Go to the official Jackett GitHub releases page (https://github.com/Jackett/Jackett/releases) and download the latest Jackett.Installer.Windows.exe file.
    2. Install: Run the installer. Follow the on-screen prompts. It’s generally recommended to install Jackett as a Windows service. This ensures it runs automatically in the background, even after a reboot. During the installation, you’ll be prompted to set an optional administrator password. Strongly consider setting a password to prevent unauthorized access to your Jackett configuration.
    3. Access: Once installed, Jackett should be accessible via your web browser at http://localhost:9117 (by default). If you set an administrator password, you’ll be prompted to enter it.

  • B. Linux (using Docker – Recommended):

    Docker provides a consistent and isolated environment for Jackett, making it the preferred method on Linux. This guide assumes you have Docker and Docker Compose installed. If not, consult your distribution’s documentation for installation instructions.

    1. Create a docker-compose.yml file: Create a new directory for your Jackett setup (e.g., mkdir jackett and cd jackett). Inside this directory, create a file named docker-compose.yml with the following content:

      yaml
      version: "3.7"
      services:
      jackett:
      image: lscr.io/linuxserver/jackett:latest
      container_name: jackett
      environment:
      - PUID=1000 # Replace with your user ID
      - PGID=1000 # Replace with your group ID
      - TZ=Etc/UTC # Replace with your timezone (e.g., America/Los_Angeles)
      - AUTO_UPDATE=true #optional
      volumes:
      - ./config:/config # Mounts a local config directory
      - /path/to/your/downloads:/downloads #optional, only if Jackett needs access
      ports:
      - 9117:9117
      restart: unless-stopped

      • PUID and PGID: Find your user and group ID by running id in your terminal. Replace 1000 with the appropriate values. This ensures Jackett runs with the correct permissions.
      • TZ: Set your timezone correctly. A list of valid timezones can be found here: https://en.wikipedia.org/wiki/List_of_tz_database_time_zones
      • ./config:/config: This mounts a local directory named config (which will be created automatically) inside the Docker container. This is where Jackett will store its configuration files, ensuring they persist even if the container is recreated.
      • /path/to/your/downloads:/downloads: Optional, only needed if some specific indexers that Jackett uses requires direct access to the downloads folder. Best practice is to not include this if it is not required.
      • restart: unless-stopped: This ensures Jackett automatically restarts if it crashes or the system reboots, unless you manually stop it.
      • AUTO_UPDATE=true: Optional, enable auto update of Jackett.

    2. Start Jackett: In the same directory as your docker-compose.yml file, run the following command:

      bash
      docker-compose up -d

      This will download the Jackett Docker image (if it’s not already present), create the container, and start it in detached mode (running in the background).

    3. Access: Jackett should now be accessible at http://localhost:9117.

  • C. macOS:

    The recommended method for macOS is also using Docker, following the same steps as the Linux Docker installation. Alternatively, you can download the Jackett.Installer.macOS.pkg file from the Jackett GitHub releases page and follow the installer prompts. However, the Docker method offers better consistency and easier management.

  • D. Other Operating Systems (NAS Devices, etc.):

    Many NAS devices (Synology, QNAP, etc.) support Docker. You can use the same Docker Compose method described above, adapting the volume paths as necessary for your specific NAS. Consult your NAS device’s documentation for details on installing and using Docker. If Docker is not supported, check if your NAS has a package manager that includes Jackett.

III. Initial Jackett Configuration

  1. Access the Web Interface: Open your web browser and navigate to http://localhost:9117 (or the appropriate address if you’ve changed the port).

  2. API Key: You’ll see a prominent “API Key” displayed on the Jackett dashboard. Copy this API key. You’ll need it later to connect Sonarr and Radarr.

  3. Blackhole Directory (Optional but Recommended):

    A blackhole directory is a folder where Jackett can place .torrent files. Your torrent client (e.g., qBittorrent, Transmission, Deluge) is configured to watch this directory and automatically start downloading any .torrent files that appear in it. This is generally more reliable than having Jackett directly interact with your torrent client’s API.

    • Setup:
      • Create a directory somewhere accessible to both Jackett and your torrent client (e.g., /home/user/torrents/blackhole).
      • In Jackett’s settings (click the wrench icon), go to the “General” tab.
      • Under “Blackhole Directory,” enter the full path to your blackhole directory.
      • Configure your torrent client to watch this directory for new .torrent files. The specific steps for this will vary depending on your torrent client. Consult your client’s documentation.

  4. Proxy Settings (If Necessary):

    If you use a proxy server for your internet connection, you’ll need to configure Jackett to use it.

    • In Jackett’s settings, go to the “Proxy” tab.
    • Enter your proxy server’s address, port, username, and password (if required).

IV. Adding Indexers

This is the core of Jackett’s functionality. Adding indexers allows Sonarr and Radarr to search a wide range of torrent sites.

  1. Click “+ Add Indexer”: On the Jackett dashboard, click the large green “+ Add indexer” button.

  2. Indexer Selection: You’ll be presented with a long list of supported indexers. Here’s a breakdown of how to choose:

    • Public vs. Private Trackers:

      • Public Trackers: These are open to anyone and generally don’t require registration. Examples include The Pirate Bay, 1337x, and YTS. They are convenient but often have lower quality control and may be subject to more frequent takedowns.
      • Private Trackers: These require registration and often have strict rules about seeding and ratio. They typically offer higher quality content, faster speeds, and a more reliable experience. Examples include IPTorrents, TorrentLeech, and many specialized trackers. You must have an account on any private tracker you add to Jackett.

    • Tracker Reputation: Research the reputation of any tracker before adding it. Some trackers are known for malware or low-quality content. Reddit’s /r/trackers and /r/torrents subreddits are good resources for information.

    • Indexer Capabilities: Some indexers are better for certain types of content (e.g., movies, TV shows, music, games). Read the descriptions in Jackett to understand what each indexer specializes in.

    • Geographic Restrictions: Some trackers may be blocked in certain countries. If you use a VPN, you may need to configure Jackett to use it for specific indexers.

  3. Configuration:

    • Public Trackers: For most public trackers, you usually don’t need to enter any configuration details. Just click the “Add” button.

    • Private Trackers: You’ll need to enter your login credentials (username, password, passkey, or API key, depending on the tracker). The specific fields required will be displayed in Jackett. Be very careful to enter this information correctly. Incorrect credentials can lead to your account being banned. Some private trackers require a “passkey” or “API key” instead of a password. You’ll find this key in your account settings on the tracker’s website.

    • Categories: Many trackers allow you to specify which categories you want to search. This can help improve search performance and reduce irrelevant results. For Sonarr, you’ll typically want to select categories related to TV shows (e.g., “TV/SD,” “TV/HD,” “TV/UHD”). For Radarr, you’ll want movie-related categories (e.g., “Movies/SD,” “Movies/HD,” “Movies/UHD”).

  4. Testing: After adding an indexer, always click the “Test” button (wrench icon next to the indexer). This verifies that Jackett can connect to the tracker and retrieve results. If the test fails, double-check your configuration details and ensure the tracker is online.

V. Recommended Indexers (Examples – Adapt to Your Needs)

This is a suggested starting point. Your ideal indexer selection will depend on your specific needs and preferences.

  • General Purpose (Public):

    • 1337x
    • YTS (for movies)
    • EZTV (for TV shows)
    • The Pirate Bay (use with caution, as it can be unreliable)

  • General Purpose (Private – Requires Membership):

    • IPTorrents (large, general-purpose tracker)
    • TorrentLeech (another large, general-purpose tracker)

  • Specialized (Private – Requires Membership):

    • BTN (BroadcastTheNet) – Excellent for TV shows
    • PTP (PassThePopcorn) – Excellent for movies
    • RED (Redacted) – Excellent for music

Important Considerations for Indexer Selection:

  • Redundancy: Don’t rely on a single indexer. Add multiple indexers to increase your chances of finding content, even if one tracker is down or has limited results.
  • Overlap: Avoid adding too many indexers that have significant overlap in content. This can lead to duplicate results and unnecessary strain on your system.
  • Maintenance: Regularly check your indexers to ensure they are still working. Remove any that are consistently failing or have been shut down.
  • Ratio Requirements (Private Trackers): Be mindful of the seeding requirements on private trackers. Ensure you have sufficient upload bandwidth and storage space to maintain a good ratio. Failing to do so can result in your account being banned.

VI. Connecting Jackett to Sonarr and Radarr

Once you’ve added your desired indexers to Jackett, you need to connect it to Sonarr and Radarr. The process is very similar for both applications.

  1. Sonarr/Radarr Settings:

    • In Sonarr, go to Settings -> Indexers.
    • In Radarr, go to Settings -> Indexers.

  2. Add Indexer: Click the “+” button to add a new indexer.

  3. Choose “Torznab”: From the list of indexer types, select “Torznab.” Torznab is the protocol that Jackett uses to communicate with Sonarr and Radarr.

  4. Configuration:

    • Name: Give the indexer a descriptive name (e.g., “Jackett – 1337x”).
    • Enable: Make sure this is checked.
    • URL: Enter the base URL of your Jackett installation, followed by /api/v2.0/indexers/[indexer_name]/results/torznab/. Replace [indexer_name] with the exact name of the indexer in Jackett (case-sensitive). Important: It is far better to use all instead of a specific indexer name. Using all tells Sonarr/Radarr to query all configured indexers in Jackett through a single Torznab connection. This is much more efficient and reduces the load on both Jackett and your trackers. The correct URL would be: http://localhost:9117/api/v2.0/indexers/all/results/torznab/
    • API Key: Paste the API key you copied from Jackett earlier.

    • Categories: This is crucial. Sonarr and Radarr need to know which categories to search for on each indexer. The category IDs are numeric and specific to each tracker.

      • Finding Category IDs: The easiest way to find the correct category IDs is to use Jackett’s “Copy Torznab Feed” feature. On the Jackett dashboard, next to the indexer you want to use, click the “Copy Torznab Feed” button. This will copy a URL to your clipboard. Paste this URL into a text editor. You’ll see something like this:
        http://localhost:9117/api/v2.0/indexers/1337x/results/torznab/?t=search&cat=2000,4000,5000&q=...
        The cat= parameter lists the category IDs. In this example, the categories are 2000, 4000, and 5000.

      • Sonarr Categories: For Sonarr, you’ll generally use categories related to TV shows. Common categories include:

        • 5000 (TV – often a general TV category)
        • 5030 (TV/SD)
        • 5040 (TV/HD)
        • 5045 (TV/UHD or TV/4K)
        • 5070 (TV/Web-DL)
        • 5080 (TV/Bluray)
        • It is important to consult your specific trackers documentation to ensure you are using the correct codes.

      • Radarr Categories: For Radarr, you’ll use categories related to movies. Common categories include:

        • 2000 (Movies – often a general Movies category)
        • 2030 (Movies/SD)
        • 2040 (Movies/HD)
        • 2045 (Movies/UHD or Movies/4K)
        • 2050 (Movies/Web-DL)
        • 2060 (Movies/Bluray)
        • It is important to consult your specific trackers documentation to ensure you are using the correct codes.
      • Using all with Categories: When using the all indexer, you can, and should, combine category IDs from all your trackers. Sonarr/Radarr will intelligently filter results based on the capabilities of each indexer. For example, in Sonarr, you might use: 5000,5030,5040,5045,5070,5080,5090,100053,100085,8000,8010 (these numbers are just examples, and you’ll need to adjust them based on your specific indexers).

    • Additional Parameters (Optional): You can usually leave these at their default values.

  5. Test: Click the “Test” button. If everything is configured correctly, you should see a success message.

  6. Save: Click “Save” to add the indexer.

  7. Repeat for all indexers (or just once for all – Recommended): Repeat steps 2-6 for each indexer you want to add. However, it is strongly recommended to add just one Torznab indexer in Sonarr/Radarr, using the all endpoint in the URL. This simplifies management and reduces overhead.

VII. Troubleshooting

  • Indexer Tests Fail in Jackett:

    • Double-check credentials: Make sure your username, password, passkey, or API key are correct.
    • Tracker is down: The tracker website might be temporarily offline or permanently shut down.
    • IP ban: Your IP address might be blocked by the tracker. Try using a VPN.
    • Firewall: Your firewall might be blocking Jackett’s connection to the tracker.
    • Incorrect Configuration: Some trackers require specific settings (e.g., selecting a specific “type” of tracker in Jackett). Consult the tracker’s documentation or forums for help.

  • Sonarr/Radarr Cannot Connect to Jackett:

    • Jackett is not running: Make sure Jackett is running and accessible via your web browser.
    • Incorrect URL: Double-check the URL you entered in Sonarr/Radarr. It should be the base URL of your Jackett installation, followed by /api/v2.0/indexers/all/results/torznab/.
    • Incorrect API Key: Make sure you’ve entered the correct API key from Jackett.
    • Firewall: Your firewall might be blocking Sonarr/Radarr’s connection to Jackett.
    • Network Issue: There might be a problem with your network configuration.

  • No Results Found in Sonarr/Radarr:

    • Incorrect Categories: Make sure you’ve entered the correct category IDs for each indexer in Sonarr/Radarr.
    • Indexer Issues: The indexers you’re using might not have the content you’re looking for, or they might be temporarily unavailable.
    • Search Terms: Try different search terms. Sonarr/Radarr’s search functionality is not always perfect.
    • Content Availability: The content you’re looking for might not be available on any of your indexers.

  • Jackett Crashing or Using Excessive Resources:

    • Too Many Indexers: Adding too many indexers can overload Jackett. Try reducing the number of indexers.
    • Problematic Indexer: A specific indexer might be causing problems. Try disabling indexers one by one to identify the culprit.
    • Outdated Version: Make sure you’re running the latest version of Jackett.
    • Hardware Limitations: If you are on a low power machine (like an older Raspberry Pi), it’s possible that Jackett is overwhelming your hardware.

  • “Torznab error” in Sonarr/Radarr: This is a general error that indicates a problem with the communication between Sonarr/Radarr and Jackett. Check the logs in both applications for more specific error messages.

  • Jackett Logs: Jackett keeps detailed logs that can help diagnose problems. The log location depends on your installation method:
    • Windows: Usually located in %ProgramData%\Jackett\log.txt.
    • Docker: Use docker logs jackett to view the logs.
    • Other: Consult the Jackett documentation.
  • Sonarr/Radarr Logs: Both applications also have logs, and they can provide useful clues to why a search failed.

VIII. Advanced Configuration and Optimization

  • A. Caching:

    Jackett can cache search results to improve performance and reduce the load on trackers.

    • Enable Caching: In Jackett’s settings, go to the “Caching” tab.
    • Cache TTL (Time To Live): This setting determines how long cached results are stored. A shorter TTL means more frequent updates but also more requests to trackers. A longer TTL reduces the load on trackers but may result in slightly outdated results. A good starting point is 30 minutes (1800 seconds). Adjust this based on your needs and the frequency with which your trackers update their content.

  • B. Query Manipulation:

    Jackett allows you to manipulate search queries before they are sent to trackers. This can be useful for:

    • Removing unwanted keywords: For example, you might want to exclude results that contain “CAM” or “TS” (low-quality recordings).
    • Adding required keywords: For example, you might want to force searches to include “1080p” or “720p”.

    • Regular Expressions: Jackett supports the use of regular expressions, which give fine control on how to modify search queries.

    • Configuration: In Jackett’s settings, go to the “Query Manipulation” tab. You can add rules to remove or add keywords.

  • C. Using a VPN:

    If you use a VPN, you may need to configure Jackett to use it, especially for trackers that block certain IP addresses or countries.

    • Option 1: VPN for the Entire System: The easiest approach is to configure your VPN at the system level (e.g., using your operating system’s network settings or a VPN client). This will ensure that all traffic, including Jackett’s, goes through the VPN.

    • Option 2: VPN for the Jackett Docker Container (Recommended for Docker): You can configure a separate Docker container to act as a VPN client and then route Jackett’s traffic through it. This provides better isolation and control. A popular solution is to use the gluetun Docker image (https://github.com/qdm12/gluetun). This requires modifying your docker-compose.yml file to include a gluetun service and configuring Jackett to use it as a network proxy. This is a more advanced setup, but provides the greatest control.

  • D. Limiting Connections:
    Some private trackers have limits on the number of simultaneous connections you can make. If you are getting errors related to too many connections, you might try reducing the Maximum Parallel Indexer Requests in the Jackett general settings.

  • E. Auto-Updating (Docker):
    The docker-compose file in section II B already includes the line AUTO_UPDATE=true. This enables the automatic update feature for Jackett within the Docker container. When a new version of the Jackett image is available on Docker Hub, the container will automatically download and apply the update the next time it restarts. This ensures you’re always running the latest version with bug fixes and new features. If you used a different installation method, consult the Jackett documentation for update instructions.

  • F. Scheduled Tasks (for non-Docker installations):

    If you’re not using Docker, it’s a good idea to set up a scheduled task to regularly restart Jackett. This can help prevent memory leaks and ensure Jackett remains responsive.

    • Windows: Use the “Task Scheduler” to create a task that runs JackettConsole.exe --restart (or the appropriate command for your installation) at a specified interval (e.g., daily or weekly).

    • Linux: Use cron to create a similar task.

  • G. Using Multiple Jackett Instances (Advanced):

    For very large setups or to isolate different types of trackers, you can run multiple instances of Jackett. Each instance would have its own configuration and API key. You would then add each instance as a separate indexer in Sonarr and Radarr. This is generally only necessary for advanced users with very specific needs.

  • H. Indexer-Specific Settings:

    Some indexers have unique settings or quirks. Always check the “Configuration” section for each indexer in Jackett to see if there are any specific options you need to adjust. Jackett’s built-in descriptions for each indexer often provide helpful hints.

IX. Best Practices

  • Start Small: Don’t add all the indexers at once. Start with a few well-known and reliable indexers, test them thoroughly, and then gradually add more as needed.

  • Regular Maintenance:

    • Check indexer tests regularly.
    • Remove dead or problematic indexers.
    • Update Jackett to the latest version.
    • Monitor resource usage (CPU, memory).
    • Review logs for errors.

  • Security:

    • Use a strong administrator password for Jackett.
    • Keep your system and software (including Jackett, Sonarr, Radarr, and your torrent client) up to date.
    • Be cautious about adding unknown or untrusted indexers.
    • Consider using a VPN to protect your privacy.

  • Respect Tracker Rules: If you use private trackers, carefully follow their rules and guidelines. Pay attention to seeding requirements, ratio limits, and any other specific regulations. Failure to do so could result in the loss of your account.

  • Understand the Risks: Downloading copyrighted material without permission is illegal in many countries. This guide is for informational purposes only, and you are solely responsible for your actions.

X. Conclusion

Jackett is an indispensable tool for maximizing the effectiveness of Sonarr and Radarr. By following this guide, you can create a robust and reliable setup that will significantly expand your access to media content. Remember to start with a basic configuration, test thoroughly, and gradually add more indexers and advanced features as needed. Regular maintenance and adherence to best practices will ensure your system remains efficient and trouble-free. The most important takeaways are using the /all endpoint for a single Torznab connection, carefully selecting and configuring categories, and performing regular testing and maintenance. By following these guidelines, you’ll be well on your way to building an automated media powerhouse.

Leave a Comment

Your email address will not be published. Required fields are marked *

Scroll to Top