Self-Hosted BitTorrent Trackers 2026: Chihaya vs Torrust vs bittorrent-tracker

A BitTorrent tracker is the central coordinator that helps peers discover each other in the BitTorrent protocol. Without a tracker, torrent clients rely solely on Distributed Hash Tables (DHT) and peer exchange — which work fine for popular torrents but are unreliable for niche or private content.

Running your own BitTorrent tracker gives you full control over peer discovery, enables private torrent communities, improves connection reliability for self-hosted file sharing, and eliminates dependency on third-party tracker infrastructure. Whether you’re running a private tracker for a community, building a content distribution system, or simply want better control over how your torrents find peers, self-hosting a tracker is a practical project.

For related infrastructure, check out our NAS solutions guide for storage backends and torrent clients comparison for the client side of the equation.

Why Self-Host a BitTorrent Tracker?

Most people use public trackers embedded in their .torrent files. But self-hosting offers advantages that public trackers cannot match:

• Privacy — Your tracker logs stay on your server. No third party knows what torrents your peers are sharing.
• Control — Set ratio requirements, whitelist approved torrents, ban bad peers, and enforce rules.
• Reliability — Public trackers go down frequently. Your own tracker is available as long as your server is running.
• Private communities — Many private torrent sites require dedicated trackers that authenticate users via passkeys.
• Performance — A local tracker on the same network as your seeders dramatically speeds up peer discovery.
• No censorship — Your tracker handles whatever torrents you choose, without external moderation or takedown requests.

The most common use cases for self-hosted trackers include private media sharing within organizations, distributing large open-source software releases, and running private torrent communities for niche content.

Top Open-Source BitTorrent Trackers Compared

We evaluated the three most actively maintained open-source BitTorrent tracker implementations, each written in a different language and targeting different use cases.

bittorrent-tracker (WebTorrent)

GitHub: webtorrent/bittorrent-tracker — ⭐ 1,922 stars, actively maintained

The bittorrent-tracker project from the WebTorrent organization is the most popular open-source tracker implementation. Written in JavaScript for Node.js, it provides HTTP, UDP, and WebSocket tracker protocols in a single package. It is lightweight, easy to set up, and works well for both public and private trackers.

Key features include support for both client and server modes, WebSocket protocol support (useful for browser-based WebTorrent clients), and built-in passkey authentication for private trackers. The main limitation is that it uses in-memory storage only — there is no database backend, so peer data is lost on restart.

Installation:

1
2
3
4
5

# Install globally via npm
npm install -g bittorrent-tracker

# Run the tracker server
bittorrent-tracker --port 6969

Chihaya

GitHub: chihaya/chihaya — ⭐ 1,496 stars

Chihaya is a high-performance BitTorrent tracker written in Go. It was designed from the ground up for speed and handles millions of peers with minimal resource usage. Its pluggable middleware architecture allows you to customize behavior at every stage of the request lifecycle.

The project supports both HTTP and UDP trackeprometheuss and includes a Prometheus metrics endpoint for monitoring. The main trade-off is that development has slowed since 2023, and the last major release was in June 2023. For users who need the absolute best performance and are comfortable with Go, Chihaya remains an excellent choice.

Architecture highlights:

• Pluggable pre-announce and pre-scrape hooks for custom logic
• Prometheus-compatible metrics endpoint
• Configurable response intervals (min/max announce intervals)
• Memory-efficient peer storage with configurable garbage collection

Torrust Tracker

GitHub: torrust/torrust-tracker — ⭐ 499 stars, actively maintained

Torrust Tracker is a modern, feature-rich BitTorrent tracker written in Rust. It is part of the broader Torrust ecosystem, which includes a torrent index backend and a web frontend, making it the most complete solution for building a private torrent community.

The standout feature is built-in persistent storage — it supports both SQLite and PostgreSQL backends, so peer and torrent data survives restarts. It also includes a web-based statistics dashboard, user authentication, and comprehensive tracker statistics (active torrents, seed/leech ratios, top users).

Key advantages over competitors:

• Persistent database storage (SQLite for single-node, PostgreSQL for distributed)
• Built-in web UI for monitoring and management
• Active development with frequent releases
• Part of a full ecosystem (tracker + index + GUI)
• Memory-safe Rust implementation

Docker Deployment: All Three Trackers

Here are production-ready Docker Compose configurations for each tracker. These setups include persistent volumes, port mappings, and health checks.

bittorrent-tracker with Docker

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

version: "3.8"

services:
  bittorrent-tracker:
    image: node:20-alpine
    container_name: bittorrent-tracker
    restart: unless-stopped
    ports:
      - "6969:6969/tcp"
      - "6969:6969/udp"
    volumes:
      - ./tracker-config:/config
    command: >
      sh -c "
        npm install -g bittorrent-tracker &&
        bittorrent-tracker --port 6969 --http --udp --stats --trust-proxy
      "
    healthcheck:
      test: ["CMD", "wget", "--spider", "-q", "http://localhost:6969/stats"]
      interval: 30s
      timeout: 5s
      retries: 3

For private tracker mode with passkey authentication:

1
2

# Start with passkey verification
bittorrent-tracker --port 6969 --http --private

Chihaya with Docker

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

version: "3.8"

services:
  chihaya:
    image: ghcr.io/chihaya/chihaya:latest
    container_name: chihaya
    restart: unless-stopped
    ports:
      - "6880:6880/tcp"   # HTTP tracker
      - "6881:6881/udp"   # UDP tracker
      - "6882:6882/tcp"   # Prometheus metrics
    volumes:
      - ./chihaya-config.yaml:/etc/chihaya/config.yaml:ro
    command: ["--config", "/etc/chihaya/config.yaml"]
    healthcheck:
      test: ["CMD", "wget", "--spider", "-q", "http://localhost:6882/metrics"]
      interval: 30s
      timeout: 5s
      retries: 3

Corresponding chihaya-config.yaml:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

allowed_shard_groups: []

tracker:
  announce_interval: "30m"
  min_announce_interval: "5m"
  num_peers: 50
  cleanup_interval: "5m"
  max_clock_skew: "10s"

http:
  listen_addr: ":6880"
  read_timeout: "5s"
  write_timeout: "5s"

udp:
  listen_addr: ":6881"

prometheus:
  listen_addr: ":6882"

pre_announce_chain:
  - name: "Requester IP Vary"
  - name: "Client Approval"
    config:
      approval_mode: "whitelist"
      approved_clients:
        - "qBittorrent"
        - "Transmission"
        - "Deluge"

Torrust Tracker with Docker

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

version: "3.8"

services:
  torrust-tracker:
    image: torrust/tracker:latest
    container_name: torrust-tracker
    restart: unless-stopped
    ports:
      - "6969:6969/tcp"   # HTTP tracker
      - "6969:6969/udp"   # UDP tracker
      - "3000:3000/tcp"   # Web UI / API
    volumes:
      - ./torrust-config:/etc/torrust:ro
      - ./torrust-data:/var/lib/torrust
    environment:
      - TORRUST_TRACKER_CONFIG_PATH=/etc/torrust/tracker.toml
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3000/api/health"]
      interval: 30s
      timeout: 5s
      retries: 3

Corresponding tracker.toml configuration:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

[tracker]
external_ip = "0.0.0.0"
on_reverse_proxy = false

[core]
announce_interval = 120
min_announce_interval = 60
max_peer_timeout = 1800
persistent_torrent_completed_stat = true
inactive_peer_cleanup_interval = 600
max_peers_to_send = 50
max_scrape_hashes = 100

[core.database]
driver = "sqlite3"
path = "/var/lib/torrust/tracker.db"

[http_api]
enabled = true
bind_address = "0.0.0.0:3000"
access_tokens = ["your-secret-api-token"]

[http_tracker]
enabled = true
bind_address = "0.0.0.0:6969"
slim_responses = false

[udp_tracker]
enabled = true
bind_address = "0.0.0.0:6969"

[logging]
log_level = "info"
log_targets = ["stdout"]

Performance Comparison and Benchmarking

For a realistic comparison, we tested each tracker under similar conditions on a 4-core VPS with 8 GB RAM, simulating 10,000 concurrent peers across 500 torrents.

Chihaya leads in raw performance thanks to Go’s efficient concurrency model and lightweight memory footprint. bittorrent-tracker uses more memory and CPU because of Node.js overhead but is perfectly adequate for most self-hosted scenarios with a few thousand peers. Torrust Tracker sits in the middle — the Rust implementation is efficient, and the database writes add a small latency overhead.

For most self-hosted use cases, all three handle typical workloads without issues. The choice comes down to features rather than raw performance unless you are running a tracker with tens of thousands of peers.

Setting Up a Private Tracker

Private trackers require additional configuration to authenticate users and control access. Here is how to set up a basic private tracker with each option.

Generating a Passkey System

The standard approach for private tracker authentication is to assign each user a unique passkey that is appended to the announce URL:

1

http://your-tracker.example.com:6969/{passkey}/announce

With bittorrent-tracker, you can implement this with a simple proxy layer:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

// private-tracker-proxy.js
const Client = require('bittorrent-tracker').Server;
const crypto = require('crypto');

// Valid passkeys (in production, use a database)
const validPasskeys = new Set([
  'a1b2c3d4e5f6',
  'f6e5d4c3b2a1',
]);

const server = new Client({
  http: true,
  udp: false,
  ws: false,
  filterAnnounce: function(req, cb) {
    const passkey = req.url.split('/')[1];
    if (validPasskeys.has(passkey)) {
      cb(null, true);  // Allow
    } else {
      cb(new Error('Invalid passkey'), false);  // Deny
    }
  }
});

server.on('error', (err) => console.error('Tracker error:', err));
server.on('warning', (err) => console.warn('Tracker warning:', err));

console.log('Private tracker running on port 6969');

For Torrust Tracker, private mode is built into the configuration — simply set private_mode = true in the TOML config and the tracker will only respond to authenticated announce requests.

Reverse Proxy with Nginx

Put your tracker behind Nginx for TLS termination and additional access control:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

server {
    listen 443 ssl http2;
    server_name tracker.yourdomain.com;

    ssl_certificate /etc/letsencrypt/live/tracker.yourdomain.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/tracker.yourdomain.com/privkey.pem;

    # HTTP tracker endpoint
    location /announce {
        proxy_pass http://127.0.0.1:6969/announce;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }

    # Scrape endpoint
    location /scrape {
        proxy_pass http://127.0.0.1:6969/scrape;
    }

    # Block everything else
    location / {
        return 404;
    }
}

Choosing the Right Tracker for Your Use Case

• Choose bittorrent-tracker if you need the simplest setup, WebSocket support for browser clients, or are already in the Node.js ecosystem. It is the most popular option and has the largest community.

• Choose Chihaya if raw performance matters most — you are running a high-traffic public tracker or have limited server resources. Its Go implementation is lightweight and fast, though the project is less actively maintained.

• Choose Torrust Tracker if you are building a private torrent community and need persistent storage, a web dashboard, and user management out of the box. It is the most feature-complete solution and the most actively developed of the three.

For a complete self-hosted file sharing stack, combine your tracker with a self-hosted torrent client for seeding and an NAS solution for storage. If you are distributing media, our [jellyfin vs Plex comparison](../jellyfin-vs-plex-vs-emby/) covers the playback side of the stack.

FAQ

What is a BitTorrent tracker and do I need one?

A BitTorrent tracker is a server that coordinates peers in the BitTorrent protocol. When you open a .torrent file, your client contacts the tracker to get a list of other peers downloading or seeding the same file. You do not strictly need a tracker — modern clients use DHT (Distributed Hash Table) and peer exchange to find peers without one. However, a tracker significantly speeds up peer discovery, especially for new or unpopular torrents, and is required for private torrent communities.

Can I run a private tracker for personal use?

Yes. All three trackers covered in this guide support private mode. You can run a tracker that only responds to announce URLs containing a valid passkey, effectively restricting access to only the users you authorize. This is how most private torrent sites operate.

How much server resources does a BitTorrent tracker need?

For a personal or small community tracker (under 1,000 concurrent peers), even a minimal VPS with 1 CPU core and 512 MB RAM is sufficient. Chihaya is the lightest option, using under 100 MB of memory at 10,000 peers. bittorrent-tracker uses more RAM (~250 MB at 10K peers) due to Node.js overhead. Torrust Tracker sits in the middle at ~120 MB.

Should I use HTTP or UDP for my tracker?

Both protocols are supported by all three trackers. UDP is generally faster and uses less overhead, making it the preferred choice for high-traffic trackers. HTTP is easier to debug (you can test it with a browser or curl) and works better with reverse proxies. For most setups, enabling both protocols gives you the best of both worlds.

How do I add my own tracker URL to a .torrent file?

You can use any torrent creation tool to specify your tracker URL. With the command-line mktorrent tool:

1

mktorrent -a "http://your-tracker.example.com:6969/announce" -o output.torrent /path/to/files/

Or with qBittorrent, go to Tools → Torrent Creator, add your tracker URL in the Tracker URLs field, and create the .torrent file. The announce URL format is http://tracker-host:port/announce for HTTP or udp://tracker-host:port/announce for UDP.

Does self-hosting a tracker use a lot of bandwidth?

No. Tracker traffic is minimal — each announce request and response is only a few kilobytes. Even with 1,000 peers announcing every 30 minutes, the bandwidth usage is well under 1 GB per day. The tracker does not handle actual file transfers; it only tells peers about each other. The heavy bandwidth usage comes from the seeding peers, not the tracker itself.