Tautulli Beyond Plex Stats

Tautulli’s Charts Are Cute. Its Webhooks Are the Real Power.

You’ve probably seen Tautulli doing what it does best: showing you a leaderboard of which roommate watches the most anime, which movies got added last week, and how many times someone rewatched The Office. Pretty graphs, snappy UI, the kind of thing you screenshot and post on your home lab Discord. But here’s the thing — if that’s all you’re using Tautulli for, you’re running a Cadillac like it’s a golf cart.

Tautulli started as a Plex stats dashboard. Over the years, especially in the last couple of years, it’s quietly evolved into something closer to a Plex automation platform. Webhooks, custom notification scripts, transcode-spike alerts, library hooks, activity triggers, and the recently-added smart notifications for new devices and suspicious logins. It’s the difference between a dashboard that looks at your data and one that acts on it.

Let me walk you through the stuff that actually matters once you stop caring about “who watched Inception the most.”

What Most People Use Tautulli For (and Why They Miss the Rest)

If you’ve got Tautulli installed, you’re probably doing this:

1. Check the dashboard weekly to see who’s been watching.
2. Glance at the recently-added library section.
3. Maybe set up a basic notification when something starts playing.
4. That’s it.

The UI makes the statistics stuff obvious. The charts are front-and-center. The settings that unlock the real power — webhooks, custom notification scripts, Apprise integration, library triggers — are scattered across five different config pages and a JSON file you need to edit by hand. So people don’t find them. Or they find them and it looks too complicated and they move on.

Here’s what you’re sleeping on:

• Notification webhooks that fire when playback starts, stops, pauses, transcodes, or fails
• Custom notification channels via ntfy, Discord, Telegram, or your own HTTP endpoint
• Transcode-spike detection — when a client starts hammering your CPU because someone’s playing a 4K file on a Roku from 2018
• New device/account watch — alert when someone logs in from a new phone, or a new account appears
• Bandwidth throttling and inactive-user reapers — automatic cleanups
• The library-webhook integration — trigger a Home Assistant automation when anime gets added, or rebuild your media server’s search index
• Python-executable hooks — write a script that runs when someone starts playing, and do literally anything
• Database storage — Tautulli archives all this data; you can query it yourself for deeper analysis

Most of this is hidden behind non-obvious menu names and buried in Settings. It’s powerful stuff, but it requires you to know to look for it.

Notifications: From “What Played” to “What’s Happening Now”

Tautulli comes with basic built-in notifications. You can get an email when playback starts. You can send a Slack message. But the real notification power comes from two things: Apprise integration and webhooks.

Apprise: The Notification Relay Station

Apprise is a library that handles notifications across 80+ services. If Tautulli doesn’t have a native plugin for your notification channel, Apprise probably does. Tautulli integrated Apprise a while back, and it’s a game-changer.

Instead of configuring Slack, Discord, Pushbullet, email, and syslog separately, you configure one Apprise URL and point Tautulli at it. Apprise then handles the routing.

Set it up in Tautulli Settings > Notifications > Apprise:

apprise://discord://webhook_id/webhook_token
apprise://tgram://bot_token/chat_id
apprise://ntfy://your-instance.com/your-topic
apprise://gotify://your-gotify-server/token

You can stack multiple URLs separated by commas, and Apprise will send to all of them. This is how you get a playback alert on both Discord and ntfy with one notification rule.

Webhooks: The Callback Lever

Webhooks are where the magic happens. Every time something happens in Plex — playback starts, a file gets transcoded, a user logs in, a new library item is added — Tautulli can fire an HTTP POST to a URL of your choice.

You set these up under Settings > Notifications > Webhooks. You define what event triggers it (play, stop, pause, transcode, resume, error, new media, etc.) and provide an endpoint URL.

Tautulli sends a JSON payload with all the relevant data:

{
  "event": "playback_start",
  "user": "alice",
  "user_id": 1,
  "player": "Roku Living Room",
  "platform": "Roku",
  "ip_address": "192.168.1.50",
  "title": "Succession",
  "season": 4,
  "episode": 6,
  "duration": 3600,
  "progress": 0,
  "transcode": 0,
  "bandwidth": 10000
}

Now you can:

1. Send it to Home Assistant to trigger an automation — e.g., dim the lights when someone starts watching.
2. Log it to a custom database for deeper analysis.
3. Webhook to ntfy or a Discord bot for richer notifications (embeds, custom messages).
4. Trigger a script that does almost anything.

Recently Added: Webhooks for New Library Items

One of the newest features in Tautulli is the library webhook — fire a callback whenever something gets added to Plex.

This is perfect for automation. You can:

• Trigger a Home Assistant automation when a new show gets added (play a fun chime, add it to a shopping list, whatever).
• Kick off a script that automatically generates metadata or transcodes a file.
• Send a daily “what’s new” notification to Discord, formatted however you want.

In Settings > Notifications > Webhooks, look for “New Library Item” or “New Media” events. Point it at a webhook receiver, and every time a new movie or episode lands in your library, you’ll get a callback.

Transcode Spikes: The “Something’s Broken” Alert

Here’s a scenario: someone starts playing a 4K HEVC file on an old Fire Stick that doesn’t support the codec. Your Plex server suddenly spins up a transcode job, and your CPU goes from 10% to 95%. You didn’t know this was happening until you ssh’d in and saw ffmpeg eating all the cores.

Tautulli has a built-in transcode-spike alert. Set it up in Settings > Notifications > Notification Agents, under the threshold you care about. You can alert when:

• A transcode starts unexpectedly
• Bitrate drops below a threshold
• Multiple transcodes happen at once
• A single client requests a very high bitrate

This isn’t just statistics. This is early warning that a user experience is bad, or that someone’s trying to do something stupid (like play a 50 Mbps file on a 5 Mbps connection).

Configure it with a webhook or Apprise notification, and you’ve got a real-time alert system.

Custom Notification Scripts

Tautulli supports custom Python scripts that run when events happen. These are powerful because they run locally on your Tautulli instance — you can do anything Python can do.

Let’s say you want to log every playback to a custom database, then format a nice notification. You’d write a Python script:

#!/usr/bin/env python3
import json
import sys
import sqlite3
from datetime import datetime

# Read Tautulli's POST body
payload = json.loads(sys.stdin.read())

# Log to your custom database
conn = sqlite3.connect('/path/to/viewing_history.db')
cursor = conn.cursor()
cursor.execute('''
  INSERT INTO plays (user, title, timestamp, duration)
  VALUES (?, ?, ?, ?)
''', (payload['user'], payload['title'], datetime.now().isoformat(), payload['duration']))
conn.commit()

# Optionally, send a rich notification
if payload['event'] == 'playback_start':
    print(f"{payload['user']} started watching {payload['title']}")

Save this script and tell Tautulli to execute it on the playback_start event (Settings > Notifications > Scripts). Now every play gets logged locally, and you can query your own database for anything Tautulli’s charts don’t show.

Account Watch and New Device Alerts

If you’re sharing Plex with friends or family, new-device detection is paranoia insurance. Tautulli can alert you when:

• A new account is created
• A new device logs in
• An account logs in from a new IP

This isn’t buried — it’s in the Notification Agents. Set up an alert that fires on “New Account” or “New Device” events, and you’ll know if someone’s account got hacked or if a weird device is accessing your library.

Pair this with webhook + Home Assistant, and you could even auto-revoke a session if it looks suspicious.

The Newsletter Feature: Monthly Recap Automation

Tautulli has a “newsletter” feature that generates a monthly summary of viewing stats. You can email it or webhook it. It’s built-in, it’s automated, and it’s the kind of thing that delights people when they get a “Your 2025 Plex Summary” email.

Settings > Scheduled Tasks > Newsletter. Turn it on, set the frequency, and point it at an Apprise URL. Every month, your users get a stats card in their inbox. It’s the difference between a cold server and one that feels like it cares about the humans using it.

Database Queries: The Escape Hatch

Tautulli stores everything in SQLite. The schema is documented in the Tautulli wiki, and it’s not terrible.

You can query the database directly:

sqlite3 ~/.tautulli/tautulli.db "SELECT user, COUNT(*) as plays FROM user_stats GROUP BY user ORDER BY plays DESC;"

This gives you views that Tautulli’s dashboard doesn’t show. You could write scripts that:

• Generate a weekly “most-watched” leaderboard with a custom format
• Export viewing patterns to a CSV for analysis
• Identify inactive users and revoke their access automatically
• Correlate viewing times with household events (e.g., “weekends see 2x more activity”)

The database is your escape hatch. Tautulli’s charts are nice, but if you need custom analysis, query the database.

Tying It Together: A Real-World Example

Let’s say you want to:

1. Alert on Slack whenever someone starts watching something
2. Log the play to a custom database
3. Trigger a Home Assistant automation to dim lights and set mood
4. Get a daily recap email

Here’s how you’d wire it:

Step 1: Add Apprise URL (Settings > Notifications > Apprise)

apprise://slack://your_webhook_url
apprise://tgram://bot_token/chat_id

Step 2: Create a custom Python hook (/path/to/tautulli_hooks/log_play.py)

#!/usr/bin/env python3
import json
import sys
import sqlite3
from datetime import datetime

payload = json.loads(sys.stdin.read())

if payload.get('event') == 'playback_start':
    conn = sqlite3.connect('/mnt/media/tautulli/plays.db')
    cursor = conn.cursor()
    cursor.execute('''
      INSERT INTO plays (username, title, duration, timestamp)
      VALUES (?, ?, ?, ?)
    ''', (payload['user'], payload['title'], payload['duration'], datetime.now().isoformat()))
    conn.commit()
    conn.close()

Step 3: Add a webhook for Home Assistant (Settings > Notifications > Webhooks)

http://192.168.1.100:8123/api/webhook/tautulli_playback

Then in Home Assistant, create an automation that listens for that webhook and dims the lights.

Step 4: Set up the newsletter (Settings > Scheduled Tasks)

Enable daily/weekly/monthly recaps, point them at Slack via Apprise.

Now you’ve got a system that reacts to your Plex library, not just displays it.

The Underused Tautulli Features Worth Wiring Up

• Apprise integration — one config URL reaches 80+ notification channels
• Webhook endpoints — fire callbacks on playback, transcode, new media, account events
• Custom Python scripts — run arbitrary code on events
• Library hooks — trigger automation when new content appears
• Transcode alerts — catch performance issues before users complain
• Database queries — escape the dashboard and do your own analysis
• Newsletter automation — monthly recaps, zero manual work
• Account and device watch — security alerts for shared servers

Tautulli started as a pretty stats viewer. It’s evolved into a proper Plex automation platform. Most people never get past the pretty graphs. If you’re serious about your self-hosted Plex server, dig into the webhook settings. That’s where the real power lives.

Your 2 AM self — the one who’s troubleshooting why transcodes are eating the CPU — will appreciate the alerts.

Related Reading

• Overseerr vs Jellyseerr
• Plex Pass Hits $749. Time for Jellyfin.
• The *arr Stack Without 9000 Reddit Threads
• Navidrome vs Funkwhale: Self-Hosted Music
• Tdarr: Auto-Transcoding Your Media Library