Tauticord

A Discord bot for Tautulli, honestly reviewed. For Plex homelab owners who want server stats without opening another tab.

TL;DR

• What it is: A self-hosted Discord bot that pulls live stream data from Tautulli and posts it to a Discord channel — who’s watching what, bandwidth, transcoding status, library counts [README].
• Who it’s for: Plex server owners who also run a Discord server (for family, friends, or a small community) and want real-time visibility into their media server without leaving Discord.
• Cost savings: Tauticord itself is free (GPL-3.0). The only ongoing cost is hosting — a $5/mo VPS covers both Tautulli and Tauticord. The alternative (manual checking Tautulli’s web UI) doesn’t cost money, but does cost time [README].
• Key strength: Does one thing and does it well. Detailed per-stream cards in Discord with state, title, user, bandwidth, transcode status, and ETA. 102 releases signals active, long-running maintenance [README].
• Key weakness: 141 GitHub stars and minimal third-party coverage — this is a niche tool with a small community. Dependent on both Tautulli and Plex, so it only works in one very specific stack. No cloud fallback, no SaaS tier.

---

What is Tauticord

Tauticord is a Discord bot that connects to your Tautulli instance and pushes live Plex activity into a Discord channel. It does not replace Tautulli’s web UI. It does not monitor your server health or alert on disk usage. What it does is take the data Tautulli already has — active streams, library sizes, bandwidth — and surface it in Discord automatically, without requiring anyone to open a browser.

The practical use case: you’re the admin of a shared Plex server. Your users are already in a Discord. Instead of telling them to check Tautulli (which they can’t access) or fielding questions like “is the server down?” and “why is my stream buffering?”, you point them to a channel that auto-updates with what’s currently playing. You can see who’s using the server, what quality profile they’re on, whether it’s transcoding, and how much bandwidth it’s consuming — all in one embed [README].

The project lives on GitHub under nwithan8/tauticord, maintained by Nate Harris. It’s GPL-3.0 licensed, written in Python (99.4% Python by file weight), has 322 commits, 102 releases, and sits at 141 stars with 23 forks. The most recent release — v5.15.1 — was tagged January 2, 2026, which means it’s actively maintained [README].

The scope is deliberately narrow. Tauticord is not a general media server bot. It is not Overseerr. It is not a request system. It reads from Tautulli via the Tautulli API and writes to Discord. That’s the full loop.

---

Why people choose it

The third-party review coverage for Tauticord is essentially nonexistent — with 141 stars and a tightly defined use case, it hasn’t attracted the kind of in-depth writeup that broader tools like Activepieces or Nextcloud have accumulated. What’s available is the GitHub README, the 102-release changelog, and the project’s presence in homelab communities.

The choice to run Tauticord typically comes from a specific frustration: you manage a Plex server for other people, those people are on Discord, and the gap between “something feels wrong” and “I need to log into Tautulli to verify” is friction you want to eliminate. Tauticord removes that friction by making the current server state always-visible in Discord, passively, without anyone asking.

The alternative to Tauticord isn’t a competing bot — it’s either leaving people without visibility, or manually checking Tautulli yourself whenever someone complains. Neither is satisfying at scale.

One concrete capability that distinguishes it from “just look at Tautulli”: the bot owner (Discord admin) can react to a Tauticord message to terminate an active stream directly from Discord, without opening Tautulli. This requires Plex Pass. For server owners who moderate a shared instance, this is a meaningful shortcut — a misbehaving stream can be killed in seconds from wherever you already are [README].

The 102 releases over the project’s lifetime also matter. A bot with two releases and a stale commit history is a support liability. Tauticord’s release cadence (averaging roughly 1-2 releases per month based on the v5.15.1 tag as of early 2026) suggests it tracks Tautulli API changes and Discord bot API changes actively [README].

---

Features

Based on the README and project repository:

Server overview (updates automatically):

• Current number of active streams [README]
• Number of transcoding streams [README]
• Total bandwidth, LAN bandwidth, remote bandwidth split [README]
• Library item counts per library [README]

Per-stream detail cards:

• Stream state: playing, paused, stopped, loading [README]
• Media type: TV show, movie, song, photo [README]
• Username of the viewer [README]
• Full media title [README]
• Player and product (e.g., “Plex Web — Chrome”) [README]
• Quality profile [README]
• Per-stream bandwidth [README]
• Transcode vs. direct play flag [README]
• Progress percentage and estimated completion time [README]

Admin controls:

• React to a bot message to terminate a specific stream (requires Plex Pass) [README]

Library monitoring:

• Users can configure which libraries to monitor [README]
• Tauticord creates or updates a Discord voice channel per library with item counts, refreshed hourly [README]

Deployment:

• Docker and docker-compose support [README]
• YAML configuration file (tauticord.yaml) [README]
• PM2 process management support for non-Docker installs [README]

What it does not do: request management, push notifications for specific events, media recommendations, user account management, or anything beyond reading stream state from Tautulli. If you need request handling, you want Overseerr or Jellyseerr. If you need alerting on server health, you want something like Uptime Kuma or Prometheus. Tauticord is a read-only display layer.

---

Pricing: SaaS vs self-hosted math

There is no SaaS tier. Tauticord is pure self-hosted, GPL-3.0, no cloud option.

The cost structure is:

Tauticord itself: Free. GPL-3.0 license [README].

Dependencies you need anyway:

• Plex Media Server: free (or Plex Pass at $6.99/mo / $79.99/yr for hardware transcoding and the stream termination feature)
• Tautulli: free, self-hosted
• Discord: free

Hosting:

• If you’re already running Tautulli on a VPS or home server, Tauticord adds negligible overhead — it’s a Python process consuming minimal RAM
• Running both Tautulli and Tauticord on a $5–6/mo Hetzner or Contabo VPS is realistic
• Docker Compose makes them straightforward to co-locate

The realistic cost for a Plex homelab operator:

Scenario	Monthly cost
Home server (already owned hardware)	$0 for Tauticord; power cost you’re already paying
VPS (Tautulli + Tauticord)	$5–6/mo all-in
Plex Pass (for stream termination)	+$6.99/mo if you don’t already have it

There is no “what you’d pay on SaaS” comparison here because there is no SaaS equivalent. Tautulli itself has a web dashboard that surfaces the same data; Tauticord’s value is purely about convenience — Discord instead of browser tab. The dollar question is whether that convenience is worth the setup time.

---

Deployment reality check

The install surface is Docker Compose plus a YAML config file, which is the standard homelab setup pattern. Anyone already running Tautulli in Docker will find the addition of Tauticord familiar.

What you need:

• A running Tautulli instance with API access enabled [README]
• A Discord server where you have admin rights
• A Discord bot application (created at discord.com/developers) with appropriate permissions
• Docker and docker-compose (or Python 3 + PM2 for non-Docker setups) [README]

Configuration:

• Rename tauticord.yaml.example to tauticord.yaml
• Fill in your Tautulli API key and URL, Discord bot token, channel IDs, and library preferences
• Run via docker-compose up -d

What can go wrong:

• Discord bot permission scoping is the most common friction point for first-time Discord bot deployers — getting the right intents and channel permissions requires reading Discord’s developer docs
• Tautulli API key and URL need to be reachable from wherever Tauticord is running (network configuration matters if Tautulli is on a LAN and Tauticord is on a VPS)
• The stream termination feature requires Plex Pass — the README is explicit about this, so don’t configure for it if you’re on free Plex [README]

Realistic time estimate: 30–60 minutes for someone comfortable with Docker Compose and Discord bot setup. For a homelab newcomer, budget 2–3 hours including reading Discord’s bot creation documentation.

The 322 commits and 102 releases also mean the configuration schema has evolved. If you find older setup guides, verify against the current tauticord.yaml.example in the repository — stale guides may reference deprecated config keys.

---

Pros and Cons

Pros

• Does exactly one thing well. Real-time Plex stream data in Discord, no scope creep, no feature bloat. The README is honest about what it is [README].
• Actively maintained. 102 releases, latest in January 2026. This is not an abandoned side project [README].
• Detailed per-stream cards. The embed includes state, title, user, player, quality, bandwidth, transcode flag, progress, and ETA — more detail than most homelab Discord bots surface [README].
• Stream termination from Discord. React to kill a stream without opening Tautulli (requires Plex Pass). Useful for shared server admins [README].
• Library voice channels. Automatic hourly update of library item counts as Discord voice channel names is an elegant use of Discord’s UI — visible at a glance without opening a channel [README].
• Docker-native. Standard docker-compose deployment, co-locates cleanly with Tautulli [README].
• GPL-3.0. Permissive enough for self-hosting and modification.

Cons

• Extremely narrow use case. Only useful if you: run Plex, run Tautulli, have a Discord server with users who care about stream status. Outside this specific intersection, it’s irrelevant.
• Zero SaaS fallback. No cloud tier, no managed option. If you don’t want to manage infrastructure, this doesn’t help you.
• 141 stars, small community. Bugs you hit may not have a Stack Overflow answer. You’re relying on the maintainer’s responsiveness and your own debugging ability.
• Third-party review coverage is nearly nonexistent. There are no independent in-depth reviews to cross-reference feature claims or validate stability reports.
• Discord API changes are a maintenance risk. Discord periodically updates its bot API and permission models. A small project like this is more exposed to breaking changes than well-staffed open-source tools.
• Plex Pass dependency for the best feature. Stream termination — arguably the most admin-useful capability — is gated behind Plex’s paid tier [README].
• Read-only outside of termination. You can see stream data and kill streams. You cannot manage users, set quality limits, approve requests, or do anything else. Heavily complementary to other tools, not a standalone solution.

---

Who should use this / who shouldn’t

Use Tauticord if:

• You run a shared Plex server for family or a small community, and everyone’s already in a Discord.
• You want passive visibility into your server without manually checking Tautulli.
• You’ve had the experience of getting a “something’s wrong” message and wanting a faster way to diagnose it.
• You’re comfortable with Docker Compose and basic Discord bot setup.
• You have Plex Pass and want to kill streams from Discord without opening a browser.

Skip it if:

• You don’t run Discord, or your users aren’t there.
• You run Jellyfin or Emby instead of Plex. Tauticord is Plex-via-Tautulli only [README].
• You want media request management, user invites, or content recommendations — look at Overseerr.
• You want server health monitoring (CPU, disk, RAM) — look at Netdata, Grafana, or Uptime Kuma.
• You want alerting on specific events (new media added, user account creation) — Tautulli’s built-in notifications handle this without a Discord bot.
• You’re a non-technical founder looking to eliminate a SaaS bill. This tool doesn’t map to that use case.

---

Alternatives worth considering

Tautulli built-in notifications: Tautulli already has a Discord notification agent that can post on stream start, stop, pause, and other events. It’s event-based rather than live-updating, but requires zero extra tooling. If you want basic Discord alerts without a persistent bot, start here.

PlexBot / similar general Plex bots: Various Discord bots expose broader Plex functionality — media browsing, requests, user management. They’re less focused on live stream monitoring but more capable overall.

Overseerr: Request management for Plex/Jellyfin with Discord integration for notifications. Different scope — manages what gets added to your library, not who’s currently watching.

Varken: A now-unmaintained tool that pulled Tautulli data into InfluxDB/Grafana for graphing. More powerful for trend analysis, but requires more infrastructure and is less actively maintained.

Tautulli web UI directly: The honest baseline. If only you (the admin) needs visibility and you’re comfortable with a browser tab, Tautulli’s own interface surfaces all of this data without any bot setup. Tauticord’s value is specifically about making it accessible to non-admins inside Discord.

---

Bottom line

Tauticord is a well-maintained, tightly scoped Discord bot that solves a specific homelab quality-of-life problem: shared Plex server admins and their communities want stream status visible in Discord without requiring access to Tautulli. It does this job well, with detailed per-stream cards, hourly library count channels, and Discord-native stream termination for Plex Pass holders. The 102-release history and January 2026 latest release suggest it’s not going anywhere.

The limitations are real and worth being direct about: 141 stars means minimal community support, third-party review coverage is essentially zero, and the use case is narrow enough that most self-hosters won’t need it. It only works if you’re running the specific combination of Plex, Tautulli, and Discord — a common homelab setup, but not a universal one.

If that’s your stack and you manage a server for other people, Tauticord is worth the 30–60 minutes of setup time. If you’re evaluating it for a broader use case, it’s the wrong tool.

---

Sources

1. GitHub — nwithan8/tauticord README (GPL-3.0, 141 stars, 23 forks, v5.15.1). https://github.com/nwithan8/tauticord
2. selfh.st — This Week in Self-Hosted (14 June 2024) — weekly newsletter covering self-hosted software updates and news. https://selfh.st/weekly/2024-06-14/

Primary sources:

• GitHub repository and README: https://github.com/nwithan8/tauticord (141 stars, GPL-3.0 license, 102 releases)
• Docker Hub: https://hub.docker.com/r/nwithan8/tauticord