Open Source Pingdom Alternatives

Uptime Kuma is a self-hosted monitoring tool with a reactive interface and a short path from install to first check. It watches the endpoints you care about and notifies you when one stops answering, without sending your monitoring data to a third party.

Checks can run as often as every 20 seconds, and the whole thing serves on a single port. It is a Node application, so it runs either as a container with a mounted volume or as a plain process kept alive by pm2.

What you can watch, and how you hear about it, covers most of a small fleet.

• Monitor types: web endpoints with keyword or JSON query checks, TCP, ping, DNS records, websockets, push, Docker containers and Steam game servers.
• Notifications: Telegram, Discord, Slack, Gotify, Pushover, email over SMTP, and more than ninety other services.
• Status pages: several of them, each mappable to its own domain.
• Certificates and proxies: certificate details and proxy support alongside a ping chart.
• Accounts: two-factor authentication, plus translations into many languages.

Docker Compose is the quickest install, though the container must not be backed by NFS storage. A non-Docker setup needs Node 20.4 or newer, Git and pm2, and runs on the major Linux distributions or on Windows 10 and Windows Server 2012 R2 upward. The BSDs, Replit and Heroku are not supported.

Checkmate checks whether your servers and sites are reachable and performing, records what it finds, and tells you when that changes. Frontend and backend live in the same repository, and the project has been stress-tested past a thousand active monitors without hitting a bottleneck.

The lifecycle is deliberately dull. A check runs, its result is stored with a response time, and recent results are weighed against the monitor's status change threshold. Only when that threshold is crossed does state flip, an incident open or close, and notifications go out, which is what stops one flaky response from waking anyone.

The monitor types and outputs cover most of a small fleet.

• Check types: uptime, Docker, ping, SSL, port, game server, page speed and JSON query monitoring.
• Hardware metrics: memory, disk, CPU and network, through the separate Capture agent, with per-mountpoint disk selection.
• Status pages: public pages in four themes, built from the monitors you already have.
• Notifications: email, webhooks, Discord, Slack, PagerDuty, Matrix, Rocket.Chat, Microsoft Teams, Telegram, Pushover and Twilio SMS.
• Maintenance windows: scheduled work that does not raise incidents while it runs.

Deployment is a Docker Compose file starting the application image next to MongoDB, which is required and deliberately not embedded in it. It is light enough for a Raspberry Pi 4 or 5, expects a reverse proxy in front of it for TLS, and the interface is translated into sixteen languages.

Gatus is a health dashboard aimed at developers, and its README opens with the objection you would raise anyway. Why not use Alertmanager, CloudWatch or Splunk. The answer is that those rely on existing traffic, so if nobody is calling a broken endpoint, nothing fires and your clients find the outage before you do.

Gatus calls the endpoints itself on a schedule using HTTP, ICMP, TCP or DNS queries, then evaluates the result against conditions you write. A condition can test the status code, the response time, the body, the certificate expiration or the resolved IP address, which makes the same mechanism usable for automated user acceptance tests.

The design choices show up in daily use.

• Readable configuration: adding an endpoint to monitor is a short block of YAML, not a project.
• Alerting breadth: Slack, Teams, PagerDuty, Discord, Twilio, Telegram, Opsgenie and dozens more, plus custom providers.
• Low resource use: a Go binary small enough to sit in a cluster without anyone noticing it.
• Badges: uptime and response time badges served from the API for embedding elsewhere.
• Security options: basic authentication, OIDC, TLS encryption and exported metrics are all configurable.

Storage, maintenance windows, announcements, client behavior, tunneling and custom labels are configurable too, alongside experimental support for remote instances and an alpha suites feature for grouping related checks.

A single docker run command starts it on port 8080, which is enough to have real endpoints monitored within a minute. Its author runs it in a Kubernetes cluster watching his own core applications.

OpenStatus puts status pages and uptime monitoring in the same tool, so the checks that detect an outage and the page that tells your users about it share one system. There is nothing to wire between a monitoring service and a separate status host.

Checks run from 28 regions in parallel across three cloud providers. The dashboard is a Next.js application, the API server runs on Hono, the checker is written in Go, and data lands in Turso through Drizzle with Tinybird handling analytics.

Everything the dashboard does is also reachable outside it.

• Status pages: custom domains, password protection, maintenance windows and subscriber notification by email and RSS.
• Monitoring: servers, websites and APIs watched from every region, with alerts through Slack, Discord, PagerDuty and email.
• Monitoring as code: YAML configuration driven from the CLI, GitHub Actions or Terraform.
• API: typed JSON over HTTP with a Node SDK, sharing a single key with the CLI.
• MCP server: connects an assistant such as Claude, ChatGPT or Cursor to your workspace.

Docker Compose is the fastest way to run it, and pre-built images cover the server, dashboard, status pages, workflows, checker and private locations, the last of these fitting in an 8.5MB image. Guides exist for one click deployment to Coolify and Railway, and the managed service charges a flat price with unlimited members.

Peekaping watches your websites, APIs, containers and databases from infrastructure you run, and tells you the moment something stops answering. It was written by people who used Uptime Kuma and wanted the same idea with an API underneath it and a typed, extensible codebase behind that.

The server is Golang, the frontend React and TypeScript, and storage is your choice of SQLite, PostgreSQL or MongoDB. The quickest start is a single Docker command with a SQLite volume, and a community Terraform provider exists for teams that manage monitors as code.

Coverage spans the checks and channels a mixed stack needs.

• Network monitors: HTTP and HTTPS, TCP, ping, DNS, push webhooks, Docker containers, gRPC and SNMP.
• Data layer monitors: PostgreSQL, Microsoft SQL Server, MongoDB, Redis, MySQL and MariaDB, plus MQTT, RabbitMQ and Kafka producers.
• Alert channels: email, webhooks, Telegram, Slack, Discord, Matrix, PagerDuty, Opsgenie, ntfy, Gotify, Pushover, Twilio and a dozen more.
• Status pages: public pages and SVG status badges for readers outside the team.
• Access control: multi-factor authentication, brute-force login protection, and API keys with rights management.
• SSL checks: certificate expiration is watched alongside availability.

Every function is reachable through the REST API, which is what makes it fit CI/CD pipelines and infrastructure as code tooling. The project is in beta and under active development, so the maintainer asks you to try it outside production first. Incidents, monitor groups and an Uptime Kuma migration tool are on the roadmap.

Running a small product usually means paying for a deployment platform, an error tracker, an analytics service, an uptime monitor, an email sender, and a sandbox provider, then stitching six dashboards together. Temps collapses that into one self-hosted install deployed with a single shell command.

Git push builds and deploys any language it auto-detects, or your own Dockerfile, with preview links and zero-downtime rollouts, and it provisions Postgres, Redis, MinIO, and MongoDB alongside your apps. The proxy runs on Cloudflare's Pingora engine with automatic TLS from Let's Encrypt. If you already run Coolify, Dokploy, CapRover, or Portainer, an import wizard carries over apps, databases with their data, domains, and variables.

Observability and the AI surfaces are built in rather than bolted on.

• Error tracking: point the official Sentry SDK at a Temps DSN for error groups, stack traces, and alerts without per-event pricing.
• Analytics: visitor tracking, funnels, and rrweb session replay, with nothing leaving your servers.
• OpenTelemetry: any OTLP exporter feeds traces, metrics, and structured logs into one place, with no Grafana, Prometheus, Jaeger, or Loki to run.
• AI gateway: bring your own keys for OpenAI, Anthropic, Google, and xAI behind one OpenAI-compatible endpoint with per-request cost attribution.
• Sandboxes: Firecracker microVMs or Docker isolate agent-generated code, with password-protected preview links.
• Agent control: more than 440 CLI operations across 69 groups, plus skills that teach Claude Code, Codex, or OpenCode to drive them.

Uptime monitors and alerting round it out, and the built-in chat answers from your own telemetry, read-only unless you opt into writes.

EasyMonitor watches websites and APIs from hardware you control. Add a URL, pick an interval between thirty seconds and an hour, and get alerted when it breaks. Probes run in several regions so one flaky network path does not become a false alarm at three in the morning.

The application is Laravel with Livewire, and check results land in PostgreSQL with TimescaleDB as a hypertable. A scheduler pushes jobs onto Redis Streams, small Go probe binaries pull them, and a consumer writes results back, with Laravel Horizon giving ops a view of the queue.

The monitoring surface goes well past a plain up or down check.

• Check types: HTTP, ICMP and TCP port checks cover most of what a service exposes.
• Certificate expiry: SSL expiry is captured during HTTPS checks, with alerts thirty, fourteen and seven days out.
• Failure thresholds: a configurable run of consecutive failures is required before anyone is paged.
• Alert channels: email, Slack, Discord, Telegram, ntfy, Pushover and signed webhooks fire on both failure and recovery.
• Status pages: public, unlisted or private pages carry incidents, maintenance windows, custom themes and customer domains with automatic HTTPS.

Installation is a clone and an interactive script that asks about mode, domain, database, registration policy, mail driver and object storage before building the containers. Two gigabytes of RAM is enough to try it and four is comfortable in production, and remote probes reach the server over Tailscale or a tunnel rather than an exposed Redis port.