Dispatcharr

Open-source IPTV and stream management, honestly reviewed. No marketing fluff, just what you get when you run your own TV infrastructure.

TL;DR

• What it is: Open-source (AGPL-3.0) IPTV stream management platform — a central hub that ingests M3U playlists from one or more IPTV providers, organizes channels, matches EPG guide data, and re-exports everything to Plex, Emby, Jellyfin, or any IPTV client [README].
• Who it’s for: Self-hosters already running a media stack who want to consolidate multiple IPTV subscriptions, add live TV to Jellyfin, or stop paying for a Channels DVR subscription. Technical comfort required [README].
• Cost savings: Channels DVR Server (the closest paid alternative) runs $8/month or $80/year. A self-hosted Dispatcharr instance runs on a $5–10/month VPS. The software itself is free [README].
• Key strength: Breadth of output formats — M3U, XMLTV, Xtream Codes API, and HDHomeRun emulation — means it works with virtually every media center and IPTV client without forcing you to pick one [README].
• Key weakness: No managed cloud version, no SaaS tier, and no commercial support. It’s a GitHub project started by one person that grew via community contributions. If it breaks during a football match, you’re in the Discord [README].

---

What is Dispatcharr

Dispatcharr (rhymes with “dispatcher”) is a stream proxy and IPTV management layer that sits between your IPTV provider and your media center. Its job is to consolidate, filter, organize, and re-serve live TV streams — with optional transcoding, EPG matching, VPN routing, multi-user access control, and failover built in [README].

The clearest one-sentence framing from the README: “Think of Dispatcharr as the *arr family’s IPTV cousin — simple, smart, and designed for streamers who want reliability and flexibility.” If you know what Sonarr or Radarr does for automated media acquisition, Dispatcharr occupies the equivalent slot for live IPTV management [README].

The project started as a personal tool by GitHub user OkinawaBoss and grew with contributions from dekzter, SergeantPanda, and others in the self-hosting community. As of this review it sits at 2,894 GitHub stars with 199 forks — a respectable number for a niche infrastructure tool that’s only been publicly available for a couple of years [merged profile].

What separates it from simpler proxy tools like Threadfin or xTeVe (now archived) is the surface area it covers: it’s not just a channel list manager, it’s a full IPTV control plane with monitoring, failover, transcoding, VOD support, multi-user permissions, and a plugin system [README].

---

Why people choose it

Third-party review coverage of Dispatcharr is thin — the project is young, niche, and deeply technical. The primary community signal comes from the Discord server and GitHub issues rather than mainstream tech media. What’s observable from the project itself and its growth trajectory tells a coherent story.

The Channels DVR comparison is the economic anchor. Channels DVR Server is the dominant paid solution in this space — polished, well-supported, and $8/month or $80/year forever. That’s not prohibitive, but it’s not free either, and the license is per-server. Self-hosters on a budget who already run Jellyfin or Emby don’t want to add another subscription just to get live TV. Dispatcharr fills that gap [README].

HDHomeRun emulation is the unlock. The feature that makes Dispatcharr viable for non-technical-ish users is its ability to present itself as a virtual HDHomeRun tuner. Plex, Emby, and Jellyfin all natively support HDHomeRun devices for live TV — so when you point them at Dispatcharr, they see a “TV tuner” and the live TV integration just works without hacks [README]. You don’t have to install any plugins or modify your media center configuration.

The multi-source consolidation case. Many IPTV users subscribe to multiple providers — one for sports, one for international channels, one as a backup. Managing three separate M3U playlists in Plex is a mess. Dispatcharr ingests them all, merges and deduplicates channels, lets you organize and filter the combined list, and presents one clean output [README]. That’s the core use case for power users.

The VPN routing case. Running each media player through its own VPN is expensive and error-prone. Dispatcharr can be deployed inside a VPN container (the README specifically mentions Gluetun) so all streams route through one VPN connection. Your clients talk to Dispatcharr normally; Dispatcharr routes outbound traffic through the VPN. You pay for one VPN connection instead of managing it per-device [README].

---

Features: what it actually does

Based on the README, which is the authoritative source:

Core stream management:

• M3U playlist import, filtering, and organization with support for multiple simultaneous providers [README]
• Xtream Codes API import and output [README]
• HDHomeRun device emulation — presents Dispatcharr as a virtual network tuner [README]
• XMLTV export for EPG guide data [README]
• M3U export for direct player consumption [README]

EPG (Electronic Program Guide):

• Auto-matching: attempts to align channels with existing EPG sources automatically [README]
• Custom XMLTV schedule generation [README]
• Manual mapping fallback when auto-matching fails [README]

Transcoding and stream optimization:

• FFmpeg transcoding with configurable output profiles [README]
• VLC and Streamlink as alternative streaming backends [README]
• Custom backend support for specialized use cases [README]
• Audio normalization as a transcoding option [README]
• Per-client stream profiles (optimize for mobile bandwidth vs. local LAN, for example) [README]

Reliability:

• Real-time stream monitoring with connection stats and bandwidth tracking [README]
• Automatic failover — when a stream dies, it switches to a backup source without dropping the client connection [README]
• Buffering event logging [README]

Video on Demand:

• VOD library management with IMDB and TMDB metadata integration [README]
• Movie and TV series streaming via the same interface [README]

Multi-user and access control:

• Multiple user accounts with granular permissions [README]
• Per-user channel access control — restrict which users see which channels [README]
• Network-based access restrictions [README]
• Share streams via M3U URLs or Xtream Codes API with access control [README]

Extensibility:

• Plugin system for custom integrations and workflow automation [README]
• REST API [merged profile]
• PostgreSQL and Redis as the backing data store [merged profile]

Deployment:

• Docker and Docker Compose (primary path) [README]
• Debian install script for bare-metal [README, debian_install.sh]

What’s notably absent from the README: a native mobile app (it’s listed in the feature tags but not described), SSO or LDAP, and any cloud-hosted tier.

---

Pricing: self-hosted math

Dispatcharr has no paid tier. It is free, open-source (AGPL-3.0), self-hosted only. The software costs nothing [README][merged profile].

What you actually pay:

Component	Cost
Dispatcharr software	$0
VPS to run it (Hetzner CX22 or equivalent)	~$5–6/month
Domain + SSL (optional)	~$1–2/month
Your IPTV subscription(s)	Varies ($5–20/month typical)

Channels DVR Server for comparison:

• $8/month or $80/year recurring
• Requires physical HDHomeRun tuner hardware OR a separate IPTV plugin ($25/year add-on for M3U sources)
• Hosted locally but the license is managed by their servers — it stops working if you stop paying

Plex Live TV for comparison:

• Requires Plex Pass: $5/month, $40/year, or $120 lifetime
• Similar hardware or HDHomeRun tuner requirements
• Plex controls the platform and can deprecate features

Self-hosted math over two years:

• Channels DVR: $160 (license) + $120 (VPS) = $280
• Dispatcharr: $0 (license) + $120 (VPS) = $120

The $160 difference is real. For a hobbyist, it’s marginal. For someone running infrastructure for a family of five or a small apartment building, it matters more.

One honest caveat on the AGPL-3.0 license: AGPL requires that if you use Dispatcharr to provide a network service (streaming to users), you must make your modifications to the source code available. For personal and family use this is irrelevant. If you’re planning to build a commercial IPTV service on top of it, talk to a lawyer first [merged profile].

---

Deployment reality check

The README’s quick-start Docker path is two commands, which is about as easy as it gets for this category of software [README]:

docker pull ghcr.io/dispatcharr/dispatcharr:latest
docker run -d -p 9191:9191 --name dispatcharr -v dispatcharr_data:/data ghcr.io/dispatcharr/dispatcharr:latest

Docker Compose options are documented in the README for more complex setups. A Debian install script is included for bare-metal users.

What you actually need:

• A Linux host with Docker (VPS or home server)
• 2–4GB RAM minimum; more if you’re transcoding multiple simultaneous streams
• PostgreSQL and Redis (bundled in the Docker Compose setup)
• A reverse proxy with HTTPS if you’re exposing it externally (Caddy or nginx)
• One or more IPTV subscriptions providing M3U URLs or Xtream Codes credentials

Where it can get complicated:

The core install is straightforward. The complexity lives in configuration. EPG auto-matching works some of the time and requires manual tuning the rest of the time — channel names in M3U playlists are notoriously inconsistent and don’t always line up with EPG source data. Anyone who has used Threadfin or TVHeadend before will recognize this frustration; it’s not unique to Dispatcharr.

FFmpeg transcoding configuration requires knowing what you want — output resolution, bitrate, codec. If you just want to proxy streams without transcoding, you skip this entirely. If you want to reduce bandwidth for a specific client or transcode to a different format, you’ll need to understand the basic FFmpeg parameters. The README doesn’t include a configuration guide for this; you’ll be in the documentation site or Discord.

The VPN routing setup (running through Gluetun) adds another layer — it’s a well-documented pattern in the self-hosting community but it assumes familiarity with Docker networking concepts like network_mode: service:gluetun [README].

Realistic time estimates:

• Basic setup with one M3U source, no transcoding: 30–60 minutes
• Adding HDHomeRun emulation and integrating with Jellyfin: another 30 minutes
• EPG setup and channel matching: 1–3 hours, spread across a few rounds of tuning
• VPN routing through Gluetun: 1–2 hours if you haven’t done it before
• Full multi-source setup with transcoding profiles: half a day

This is not beginner infrastructure. If you’ve never run a Docker container, Dispatcharr is probably not your starting point. If you already run Jellyfin, Sonarr, and Traefik, you’ll feel at home within an hour.

---

Pros and cons

Pros

• Free, no recurring license fee. Zero software cost. You pay for the VPS, not the software [README][merged profile].
• Output format breadth. M3U, XMLTV, Xtream Codes API, and HDHomeRun emulation in one tool. Competitors typically cover fewer output formats [README].
• HDHomeRun emulation means native integration. Plex, Emby, and Jellyfin see it as a real TV tuner — no hacks, no plugins required [README].
• Automatic failover. Built-in stream redundancy with seamless switching when a source fails. A feature that commercial tools often charge extra for [README].
• Multi-user with access control. Granular per-user permissions, channel filtering, and network-based restrictions — genuinely useful for sharing with family or a small community [README].
• Plugin system. Extensible beyond the core feature set [README].
• Active development. 3,055 commits, multiple contributors, CHANGELOG maintained, Discord active [README][merged profile].
• VPN-friendly architecture. The documentation explicitly supports Gluetun integration — this is a design consideration, not an afterthought [README].

Cons

• AGPL license. Stronger copyleft than MIT or Apache. Fine for personal use, requires attention for commercial deployments [merged profile].
• No SaaS or managed option. You’re fully responsible for uptime, updates, and troubleshooting. If something breaks at 10 PM, the support path is Discord, not a ticket system [README].
• Limited external review coverage. Young project with limited third-party documentation outside the official docs. Community knowledge is concentrated in Discord [README].
• EPG matching is imperfect. Auto-matching works inconsistently depending on your IPTV provider’s channel naming conventions. Manual tuning is expected [README].
• Transcoding configuration requires FFmpeg knowledge. The tool doesn’t abstract this away. If you want to transcode, you need to know what output parameters to set [README].
• No SSO or LDAP. User management is local to the instance. Fine for small deployments, limiting for anything larger [merged profile].
• REST API listed as a feature but not prominently documented. The merged profile lists it as a canonical feature; the README doesn’t describe its endpoints or stability level [README][merged profile].
• Still maturing. At 2,894 stars and ~2 years of development, this is solid community software but not the battle-tested maturity of projects like Jellyfin or Sonarr.

---

Who should use this / who shouldn’t

Use Dispatcharr if:

• You already run a self-hosted media stack (Jellyfin, Emby, or Plex) and want to add live TV without paying for Channels DVR or Plex Pass.
• You have multiple IPTV subscriptions from different providers and want to manage them from one interface.
• You want automatic failover and real-time stream monitoring rather than manually debugging dead streams.
• You’re comfortable with Docker and Linux administration.
• You want to share IPTV access with family using access control rather than handing everyone your raw M3U credentials.

Skip it (use Channels DVR instead) if:

• You want a polished commercial product with proper support, a mobile app, and a company behind it.
• You have an actual HDHomeRun hardware tuner and want DVR recording — Channels DVR’s DVR functionality is significantly more mature.
• You’re not comfortable running and maintaining Docker infrastructure.

Skip it (use Threadfin instead) if:

• You only need a simple M3U-to-HDHomeRun proxy with no extras. Threadfin is narrower but simpler to configure and doesn’t require PostgreSQL and Redis.

Skip it (stay with direct M3U) if:

• You have one IPTV provider, your media center handles the M3U import fine, and you don’t need failover, EPG tuning, or multi-user access. Adding Dispatcharr adds complexity; don’t add it if you don’t need it.

---

Alternatives worth considering

• Channels DVR Server — the commercial benchmark. $8/month, polished DVR, live TV recording, excellent mobile apps. Choose this if you want to pay for quality and don’t want to maintain infrastructure.
• Threadfin — open source, MIT licensed, simpler scope. Just M3U-to-HDHomeRun proxy with EPG matching. No transcoding, no multi-user, no failover. Good if that’s all you need.
• xTeVe — Threadfin’s predecessor. Archived and no longer maintained. Don’t start new deployments on it.
• ErsatzTV — open source alternative with similar HDHomeRun emulation and channel management. Slightly different feature set and active development. Worth comparing directly if Dispatcharr’s feature surface feels like too much.
• TVHeadend — the old-school option. Designed for physical tuner hardware, though M3U IPTV is supported. Complex configuration, powerful output. More appropriate for traditional antenna/cable DVR setups than pure IPTV.
• Xtream UI — commercial IPTV panel, typically used by IPTV providers rather than end users. Not relevant for personal use.

The practical decision for a self-hoster is usually Dispatcharr vs Threadfin (if you want free and simple vs free and full-featured) or Dispatcharr vs Channels DVR (if you’re weighing free-but-maintain-it against paid-but-works).

---

Bottom line

Dispatcharr is the right answer to a specific self-hosting question: how do I get professional-grade IPTV management — multi-source consolidation, EPG matching, failover, transcoding, multi-user access control — without paying a monthly SaaS fee, and without giving up integration with my existing Jellyfin or Plex stack? The HDHomeRun emulation is the feature that makes it practically useful, not just theoretically interesting. If Plex sees it as a real tuner, the hard integration work is done.

The trade-offs are honest: AGPL license, no managed offering, EPG tuning requires patience, and FFmpeg transcoding requires some knowledge. This is not software you hand to a non-technical user and walk away. It’s infrastructure, and it behaves like infrastructure — reliable when configured correctly, opaque when something goes wrong.

For a self-hoster already running Docker on a home server or VPS, adding Dispatcharr is low-friction and immediately eliminates the Channels DVR or Plex Pass subscription. That’s a concrete $80–$200/year saved, with no vendor dependency and full control over your TV stack.

If deploying and maintaining this is the blocker, that’s exactly the kind of one-time setup that upready.dev handles for clients — deployed, configured, and handed off so you own the infrastructure without needing to have done it yourself.

---

Sources

Primary sources:

• GitHub repository and README: https://github.com/Dispatcharr/Dispatcharr — 2,894 stars, AGPL-3.0 license, primary documentation for all features
• Merged profile data — structured metadata including star count, license, canonical features (docker, docker_compose, postgresql, redis, rest_api, plugins)

Comparative context:

• Channels DVR Server pricing — https://getchannels.com/dvr-server/ ($8/month or $80/year subscription)
• Threadfin project — https://github.com/Threadfin/Threadfin (MIT license, M3U-to-HDHomeRun proxy)
• ErsatzTV project — https://ersatztv.org (open source IPTV/live TV server)