Know who's streaming. Catch account sharers. Take back control.

Tracearr is a streaming access manager for Plex, Jellyfin, and Emby that answers one question: Who's actually using my server, and are they sharing their login?

Unlike monitoring tools that just show you data, Tracearr is built to detect account abuse. See streams in real-time, flag suspicious activity automatically, and get notified the moment something looks off.

Session Tracking — Full history of who watched what, when, from where, on what device. Every stream logged with geolocation data.

Sharing Detection — Five rule types catch account sharers:

• 🚀 Impossible Travel — NYC then London 30 minutes later? That's not one person.
• 📍 Simultaneous Locations — Same account streaming from two cities at once.
• 🔀 Device Velocity — Too many unique IPs in a short window signals shared credentials.
• 📺 Concurrent Streams — Set limits per user. Simple but effective.
• 🌍 Geo Restrictions — Block streaming from specific countries entirely.

Real-Time Alerts — Discord webhooks and custom notifications fire instantly when rules trigger. No waiting for daily reports.

Stream Map — Visualize where your streams originate on an interactive world map. Filter by user, server, or time period to zero in on suspicious patterns.

Trust Scores — Users earn (or lose) trust based on their behavior. Violations drop scores automatically.

Multi-Server — Connect Plex, Jellyfin, and Emby instances to the same dashboard. Manage everything in one place.

Tautulli Import — Already using Tautulli? Import your watch history so you don't start from scratch.

Tracearr v1 is focused on detection and alerting. Automated enforcement—killing streams, suspending accounts—is coming in future versions. For now, you see the problems; you decide the action.

Tautulli and Jellystat are great monitoring tools. We use Highcharts for graphs too. But they show you what happened—they don't tell you when something's wrong.

Tautulli and Jellystat are platform-locked equivalents—Plex-only vs Jellyfin/Emby-only. If you just want stats, they work fine. If you're tired of your brother's roommate's cousin streaming on your dime, that's what Tracearr is for.

The supervised image bundles TimescaleDB, Redis, and Tracearr in a single container. No external database required. Secrets are auto-generated on first run.

docker compose -f docker/docker-compose.supervised.yml up -d

Open http://localhost:3000 and connect your Plex, Jellyfin, or Emby server.

If you already have TimescaleDB/PostgreSQL and Redis, or prefer managing services separately:

# Copy and configure environment
cp docker/.env.example docker/.env
# Edit docker/.env with your secrets (generate with: openssl rand -hex 32)

docker compose -f docker/docker-compose.yml up -d

# All-in-one (easiest)
docker pull ghcr.io/connorgallopo/tracearr:supervised

# Stable (requires external services)
docker pull ghcr.io/connorgallopo/tracearr:latest

# Living on the edge
docker pull ghcr.io/connorgallopo/tracearr:nightly

For one-click deployment via Portainer or Proxmox, see the ready-to-use compose files in docker/examples/. These use pre-built images only—no build context required.

# Install dependencies (requires pnpm 10+, Node.js 22+)
pnpm install

# Start database services
docker compose -f docker/docker-compose.dev.yml up -d

# Copy and configure environment
cp .env.example .env

# Run migrations
pnpm --filter @tracearr/server db:migrate

# Start dev servers
pnpm dev

Frontend runs at localhost:5173, API at localhost:3000.

TimescaleDB handles session history. Regular Postgres works fine until you have a year of watch data and your stats queries start taking forever. TimescaleDB is built for exactly this kind of time-series data—dashboard stats stay fast because they're pre-computed, not recalculated every page load.

Fastify over Express because it's measurably faster and the schema validation is nice.

Plex SSE — Plex servers stream session updates in real-time via Server-Sent Events. No polling delay, instant detection. Jellyfin and Emby still use polling (they don't support SSE), but Plex sessions appear the moment they start.

tracearr/
├── apps/
│   ├── web/          # React frontend
│   ├── server/       # Fastify backend
│   └── mobile/       # React Native app (coming soon)
├── packages/
│   └── shared/       # Types, schemas, constants
├── docker/           # Compose files
└── docs/             # Documentation

Tracearr uses environment variables for configuration. Key settings:

# Database
DATABASE_URL=postgresql://user:pass@localhost:5432/tracearr

# Redis
REDIS_URL=redis://localhost:6379

# Security
JWT_SECRET=your-secret-here
COOKIE_SECRET=your-cookie-secret-here

# GeoIP (optional, for location detection)
MAXMIND_LICENSE_KEY=your-maxmind-key

See .env.example for all options.

Got questions? Found a bug? Want to contribute?

Or open an issue on GitHub.

Contributions welcome. Please:

1. Fork the repo
2. Create a feature branch (git checkout -b feature/thing)
3. Make your changes
4. Run tests and linting (pnpm test && pnpm lint)
5. Open a PR

Check the issues for things to work on.

Alpha (current — v0.1.x)

• Multi-server Plex, Jellyfin, and Emby support
• Session tracking with full history
• 5 sharing detection rules
• Real-time WebSocket updates
• Plex SSE for instant session detection
• Discord + webhook notifications
• Interactive stream map
• Trust scores
• Tautulli history import

v1.5 (next milestone)

• Mobile app (iOS & Android) — in development
• Stream termination (kill suspicious streams)
• Account suspension automation
• Email notifications
• Telegram notifier

v2.0 (future)

• Tiered access controls
• Arr integration (Radarr/Sonarr)
• Multi-admin support

AGPL-3.0 — Open source with copyleft protection. If you modify Tracearr and offer it as a service, you share your changes.

_{Built because sharing is caring, but not when it's your server bill.}