Gatus

Gatus is a self-hosted, developer-focused health monitoring and status page tool that actively probes your services rather than waiting for traffic to reveal problems. It supports HTTP, ICMP, TCP, DNS, gRPC, SSH, STARTTLS, TLS, WebSocket, SCTP, and UDP endpoints, evaluating responses against customizable conditions—status codes, response times, body content, certificate expiration, and more. When something goes wrong, Gatus notifies you through more than 40 alerting providers, including Slack, PagerDuty, Discord, Datadog, Opsgenie, Telegram, and custom webhooks.

Built in Go and deployable as a single binary or Docker container, Gatus is designed for low operational overhead. Configuration is YAML-driven and supports environment variable interpolation, dynamic reloading without restarts, and optional PostgreSQL or SQLite storage for persisting health history. The Vue 3 frontend delivers a clean real-time dashboard with dark mode, endpoint grouping, response time trends, and embeddable SVG status badges.

Gatus has evolved well beyond basic uptime monitoring. It now includes Suites for sequential workflow-style monitoring (chaining multi-step auth flows or API sequences), External Endpoints for pushing status from agents in private networks, Announcements for in-dashboard incident communications, Heartbeat monitoring for external agents, remote instance aggregation (experimental), SSH tunneling for monitoring unreachable services, and Helm/Terraform deployment support. Prometheus metrics and OIDC authentication round out the feature set for teams running it in production Kubernetes environments.

The project is actively maintained by its original author with contributions from a growing community, and a managed cloud offering at Gatus.io provides a zero-ops alternative for teams that want the same experience without running the infrastructure themselves.

What You Get

• Multi-protocol active health checks - Monitor HTTP, ICMP, TCP, DNS, gRPC, SSH, STARTTLS, TLS, WebSocket, SCTP, and UDP endpoints on configurable intervals, evaluating conditions on status codes, response times, body content, certificate expiry, and IP addresses.
• Customizable condition expressions - Write Go-like condition strings such as [STATUS] == 200, [BODY].status == UP, len([BODY].users) > 0, or [CERTIFICATE_EXPIRATION] > 48h to validate any aspect of a response beyond simple reachability.
• 40+ alerting integrations - Send failure and recovery notifications to Slack, PagerDuty, Discord, Datadog, Opsgenie, Telegram, Teams Workflow, Incident.io, Ntfy, Pushover, AWS SES, and custom webhooks, with configurable failure and success thresholds per endpoint.
• Suites for sequential workflow monitoring - Define ordered sequences of endpoints that share context, enabling multi-step scenario monitoring such as login flows, API resource lifecycles, or cross-service consistency checks.
• External Endpoints for push-based status - Accept status pushes from agents running in private networks or unsupported environments, extending Gatus’s dashboard to services it cannot reach directly.
• Real-time status dashboard with dark mode - Serve a Vue 3 frontend with live endpoint health, response time trend charts, endpoint grouping, customizable heading and subheading, and persistent UI preferences across sessions.
• Embeddable SVG status badges - Embed uptime and response time badges in READMEs, wikis, or dashboards via URLs like /api/v1/endpoints/{key}/uptimes/7d/badge.svg, with configurable color thresholds.
• Prometheus-compatible metrics - Expose endpoint health and response time data via /metrics with custom label support for direct integration with Grafana, Alertmanager, or any Prometheus-compatible pipeline.
• OIDC and Basic Authentication - Protect the dashboard with OpenID Connect (Auth0, Keycloak, Dex) or HTTP Basic Authentication without requiring an external reverse proxy.
• Dynamic configuration reloading - Reload YAML configuration files without restarting the service via SIGHUP or the /admin/reload endpoint, and use environment variables inside config files for secret injection.
• Announcements for incident communications - Publish system-wide messages on the status page with typed severity levels (outage, warning, information, operational) and archival support for historical incident records.
• Heartbeat monitoring - Detect silent failures in external agents by triggering alerts when an external endpoint stops reporting within its expected interval.

Common Use Cases

• Kubernetes microservice health monitoring - A platform team deploys Gatus alongside their workloads and configures HTTP health checks for every service, receiving Slack alerts before any user-facing degradation is detected.
• Multi-step API workflow validation - A backend team uses Suites to chain an authentication request, a protected resource fetch, and a logout call into a single monitored workflow, catching regressions in auth flows before they reach production.
• Private network service visibility - An infrastructure team runs lightweight push agents inside air-gapped VPCs that report status to a public-facing Gatus instance, making internal service health visible on the same dashboard as public endpoints.
• TLS certificate expiration alerting - A DevOps engineer configures Gatus to check certificate expiration on all customer-facing domains and receive PagerDuty alerts 30 days before any certificate expires.
• Open-source project status page - A developer self-hosts Gatus on a small VPS and embeds uptime badges in their GitHub README, providing transparent public availability data without a paid status page service.
• Incident communication during outages - An on-call engineer publishes a typed Announcement directly in the Gatus config during an incident, surfacing a banner on the public status page that keeps users informed without requiring a separate incident management tool.

Under The Hood

Architecture Gatus is structured as a well-layered Go application where each major concern lives in its own isolated package with minimal cross-package dependencies. The entry point wires together four independent subsystems—configuration loading, storage initialization, the HTTP controller, and the watchdog scheduler—each of which can be started and stopped independently to support graceful shutdown and live configuration reloading. The watchdog drives endpoint execution concurrently via goroutines with a configurable semaphore, while the storage layer abstracts over in-memory, SQLite, and PostgreSQL backends through a single interface. The API package exclusively serves the Vue frontend and Prometheus consumers through well-defined HTTP routes, keeping it decoupled from monitoring logic. Configuration reloading is implemented at the main package level by stopping all subsystems, reloading the YAML, and restarting—a deliberate architectural choice to keep config parsing free of storage dependencies.

Tech Stack The backend is written in Go and compiled to a statically linked binary deployed inside a scratch Docker image with bundled CA certificates, resulting in a minimal attack surface and sub-10MB container. The HTTP layer uses Gofiber (built on fasthttp) for high-throughput request handling. Storage backends include in-memory maps for zero-config deployments, SQLite via the standard database/sql driver, and PostgreSQL via lib/pq. Protocol-specific monitoring uses prometheus-community/pro-bing for ICMP, miekg/dns for DNS queries, google/go-github for GitHub alerting integration, coreos/go-oidc for OIDC authentication, and gorilla/websocket for WebSocket endpoint monitoring. The frontend is Vue 3 with Tailwind CSS and Lucide Vue Next icons, built separately and served as embedded static assets. Chart generation for response time visualizations uses wcharczuk/go-chart.

Code Quality The codebase contains extensive test coverage with more than 100 test files using Go’s table-driven testing pattern throughout. Tests cover condition evaluation edge cases, alerting provider payload validation, storage operations, API endpoint behavior, and badge generation. Error handling is explicit and typed, with named sentinel errors defined per package that callers can inspect and act on. Configuration validation uses a ValidateAndSetDefaults method pattern consistently across all config structs, centralizing invariant enforcement before any runtime use. Naming follows Go idioms with clear package boundaries, and the codebase compiles with no linter suppressions visible in the reviewed source. CI runs tests automatically on every pull request.

What Makes It Unique Gatus differentiates itself from passive observability tools through active probing with a condition language expressive enough to validate business logic—checking JSON body fields, comparing dynamic placeholders, or asserting certificate validity—not just reachability. The Suites feature enables sequential, context-sharing endpoint chains that turn the monitor into a lightweight integration test runner executing in production. External Endpoints invert the model entirely, letting agents in unreachable environments push status into Gatus rather than requiring Gatus to reach them. The built-in Announcements system provides typed incident communications natively on the status page without requiring a separate tool, and native SVG badge generation lets teams embed live uptime data anywhere without a third-party badge service.

Self-Hosting

Gatus is released under the Apache License 2.0, a permissive open source license that allows commercial use, modification, and distribution without imposing copyleft obligations on your own software. You can run it internally, embed it in commercial products, or offer it as part of a service without any licensing fees or restrictions, as long as you retain the original copyright and license notices.

Running Gatus yourself means you own the full stack: a single Docker container or binary, a YAML configuration file, and optionally a PostgreSQL or SQLite database for persisting check history. The container is lightweight enough to run on a small VPS or a Raspberry Pi for personal use, and scales comfortably to Kubernetes with the provided Helm chart and Terraform modules. You are responsible for availability, upgrades, database backups, and secret management for alerting credentials. Configuration reloading without restarts reduces maintenance interruptions, but you will need to handle zero-downtime deployments yourself if high availability is a requirement.

A managed cloud offering exists at Gatus.io for teams that want the same developer-oriented monitoring experience without operating the infrastructure. The self-hosted version has no artificial feature gates or license checks—everything in the repository is fully functional without contacting any external service. The trade-off compared to Gatus.io or commercial alternatives like Datadog or Better Uptime is the absence of managed SLAs, automatic failover, built-in on-call scheduling, and a support contract. Teams with strict uptime requirements for the monitor itself should plan for redundancy, as Gatus does not include native clustering or HA configuration in the open source release.