Peekaping

Last reviewed Sep 13, 2026 · 760 words

Do not migrate a working Uptime Kuma install to Peekaping today. Start new installs with Peekaping if the things that annoy you about Uptime Kuma are its single Node process, its SQLite-only history that gets sluggish past a few hundred monitors, and the long wait for a 2.0. Peekaping is a from-scratch rebuild of the same idea in Go with a React front end, a choice of SQLite, PostgreSQL or MongoDB behind it, and a UI that a Kuma user will find familiar within a minute. It is also 2024-vintage, with 1,192 stars against Uptime Kuma's more than 50 times that, and the gaps show at the edges.

Same shape, different bones

The feature list reads like Kuma's: HTTP, keyword and JSON-query checks, TCP, ping, DNS, push monitors for cron jobs, Docker container checks, gRPC and more; notification channels covering Telegram, Slack, Discord, email, webhooks and a long list of others; public status pages; maintenance windows; proxies; 2FA on the admin login. The difference is underneath. The Go backend is a single static binary, the database is pluggable, and history is stored with aggregation in mind rather than as raw rows, which is what makes Kuma's dashboard crawl after a year of 20-second checks on 300 monitors.

Deploying: pick your bundle

The project publishes all-in-one images per database, and the repository's compose files are the source of truth for the current tags. The SQLite bundle is the one to start with:

services:
  peekaping:
    image: 0xfurai/peekaping-bundle-sqlite:latest
    ports:
      - "8383:8383"
    volumes:
      - ./peekaping-data:/app/data
    restart: unless-stopped

That is the whole install for a homelab: open the port, create the admin account on first visit, and add monitors. Put it behind your reverse proxy with a hostname before enabling notifications, since the status page and the alert links are built from the URL you configure. The Postgres bundle is for anyone monitoring hundreds of targets or who wants to point Grafana at the data. The repository also shows the split layout (separate API, web and database containers) if you prefer it. Memory at idle sits comfortably inside the 128 MB listing, which on my boxes is roughly half of what Kuma uses with the same monitor count.

Where a young project shows

Three places, none fatal. The notification provider list is long but not as long as Kuma's, and a couple of the niche ones are missing; check yours before committing. The status page is functional and clean but has fewer customisation knobs. And community answers are thin: a Kuma error message pasted into a search engine returns a GitHub issue; a Peekaping one often does not yet. None of these is a reason to avoid it for a new homelab; all of them are reasons to leave a working Kuma alone until you have a concrete complaint.

Where it sits in the monitoring stack

Peekaping, like Kuma, is a black-box uptime checker with a status page attached. It is not Gatus, which is configuration-as-code and better suited to a git-managed set of checks with alerting rules, and it is not Prometheus, which is metrics. The Gatus vs Uptime Kuma comparison explains that split; Peekaping sits squarely on the Kuma side of it. For the public status page specifically, the self-hosted status pages piece covers the dedicated options if you want something more designed than any checker's built-in page.

Backups and the migration question

Everything lives in the database, so back up the SQLite file (with the container stopped, or through SQLite's .backup command) or run pg_dump for Postgres. Moving from Uptime Kuma means recreating monitors: at last check there was no import path I would trust with a large install, and the notification channels need re-entering regardless. For under 30 monitors that is an hour; for more, it is the reason not to switch yet.

What I'd do

New homelab, fewer than 100 monitors: Peekaping on the SQLite bundle, behind the reverse proxy, with a push monitor for the backup job and a status page for the household. Existing Uptime Kuma that works: keep it, and revisit in a year. Hundreds of monitors, or a team: Peekaping on Postgres is the better long-term bet than Kuma, but pilot it beside Kuma for a month first and compare the alerts before you turn the old one off.