Uptime Kuma

If you’ve ever relied on a third-party uptime service and felt uneasy about trusting your infrastructure visibility to someone else’s SaaS, Uptime Kuma was built for you. It’s a self-hosted monitoring tool that watches everything from HTTP endpoints and Docker containers to Redis, MQTT brokers, game servers, and SIP endpoints — giving you the same reactive dashboard experience as the paid services, running entirely on your own hardware.

What makes Uptime Kuma stand out isn’t any single feature but the combination: 23 monitor types and 95 notification providers in one install, with a real-time Vue 3 dashboard that updates via WebSocket instead of polling. You can publish branded status pages under your own domain, map them to specific monitors, and optionally password-protect them for internal teams. Certificate expiry monitoring, 2FA, multi-language support, and Globalping integration for geolocation-aware checks are all included and all free.

Deployment takes about 30 seconds with Docker Compose, or you can run it directly with Node.js 20+ and PM2 on Linux or Windows. The project has shipped continuously since 2021 with a 125+ release history, active community, and no commercial tier to worry about.

What You Get

• 23 Monitor Types — HTTP(S) with keyword and JSON query validation, TCP, DNS, Ping, Docker, MQTT, Redis, MongoDB, PostgreSQL, MySQL, MSSQL, OracleDB, RabbitMQ, gRPC, SNMP, SIP, SMTP, WebSocket, Steam game servers, Tailscale Ping, Real Browser, and System Service checks.
• 95 Notification Providers — Discord, Telegram, Slack, PagerDuty, OpsGenie, Ntfy, Pushover, Gotify, Matrix, SMTP, and 85+ others, each with configurable message templates and support for per-notification proxy settings.
• Live WebSocket Dashboard — Status, ping history, and heartbeat timelines push to the browser over Socket.IO the moment a check completes — no polling, no manual refresh needed.
• Public Status Pages — Branded pages mapped to custom domains, with per-component grouping and optional password protection for internal or customer-facing incident communication.
• Certificate Expiry Monitoring — Tracks TLS certificate lifetimes for HTTPS and TCP monitors and alerts before they lapse, with configurable lead times.
• Globalping Integration — Run checks from distributed nodes worldwide to detect region-specific outages and verify geographic availability without managing your own probe infrastructure.
• 2FA and Multi-User Support — Built-in TOTP two-factor authentication and per-user account management for teams sharing a single instance.

Common Use Cases

• Production API monitoring — A DevOps team tracks HTTP endpoints with JSON response validation across their microservices, routing PagerDuty alerts to on-call engineers and publishing a status page customers can check during incidents.
• Home lab observability — A self-hoster monitors their NAS, Plex, Pi-hole, Wireguard, and local services via TCP and ping checks, with Telegram alerts when anything drops off the network.
• SaaS incident communication — A startup publishes a status page at status.example.com grouped by service component, giving customers a place to self-serve during outages without filing support tickets.
• Database and message queue health — An infrastructure team monitors PostgreSQL, Redis, and RabbitMQ reachability alongside HTTP services so they catch connectivity failures before application errors surface.
• Game server uptime — A community server admin uses the GameDig monitor type to watch their Minecraft or CS2 instance and notify Discord when it goes offline or lags.

Under The Hood

Architecture Uptime Kuma runs as a single server process that handles scheduling, persistence, and real-time communication in one place. Each of the 23 monitor protocols is implemented as a self-contained module with a standard interface — adding a new check type means writing one file that plugs into the scheduler without touching anything else. Notification providers follow the same pattern, which is how the project supports 95 of them without the codebase becoming unmanageable. All communication between the server and the browser flows over a persistent WebSocket connection rather than a REST API, so the dashboard reflects live state the moment a check completes rather than on the next poll cycle.

Tech Stack Node.js powers the backend with Express for HTTP and Socket.IO for persistent browser connections. The frontend is Vue 3 compiled with Vite, using single-file components throughout. SQLite is the default database with automatic schema migrations built in; MySQL, MariaDB, and PostgreSQL are also supported for teams that prefer a managed database backend. Docker is the recommended deployment path — the project ships an official Compose file and the image runs with a single command.

Code Quality Testing covers both ends: browser-level end-to-end tests run against real service containers to verify monitor workflows, and a backend unit test suite covers core logic. The codebase mixes JavaScript and TypeScript — shared utilities are authored in TypeScript so both frontend and backend import the same logic, while the notification providers are plain JavaScript. ESLint covers both. It is a pragmatic setup for a project that grew quickly from a solo experiment into a 400-contributor codebase, and it shows: the code is readable and consistent even if not strictly typed throughout.

What Makes It Unique Most self-hosted monitors focus on HTTP and ping. Uptime Kuma adds SIP, SNMP, RADIUS, SMTP, MQTT, game server protocols, and gRPC to the same install with no extra configuration. The Globalping integration runs checks from distributed nodes worldwide so you can tell whether a service is down everywhere or just for you. The WebSocket-only dashboard means failures appear the moment they happen, not on your next page refresh. And PWA support gives the interface offline capability and a native-app feel that most monitoring tools skip entirely.

Self-Hosting

Uptime Kuma is MIT licensed with no paywalls, no feature tiers, and no license keys — every monitor type, every notification provider, and every feature in the repository is available to anyone running their own instance.

That said, self-hosting a monitoring tool comes with a specific irony: the server running Uptime Kuma needs to stay up for it to tell you anything else is down. If your monitoring host goes offline, you lose visibility into everything it watches. Most self-hosters address this by running it on a VPS separate from the services being monitored, setting up a second monitor elsewhere for the Uptime Kuma instance itself, or using the built-in push monitor type to let services phone home instead of being polled from a single point.

What you give up compared to a managed service is operational responsibility. Updates are manual — you pull a new Docker image or run git pull and restart. There is no official support channel; help comes from GitHub Issues and the r/UptimeKuma subreddit. There is no built-in high availability, no automatic database backup, and no SLA. For teams that need those things, a commercial uptime service makes more sense. For individuals and small teams comfortable managing a container or VPS, Uptime Kuma gives you more features than most paid alternatives at zero recurring cost.