Uptime monitoring, status pages and on-call. Open source, free to start. Live in 5 minutes.
Monitor HTTP, TCP, ICMP ping, cron-job heartbeats, DNS, TLS-certificate and
domain expiry, plus scripted browser login flows, from multiple regions — then
turn green and red into a polished
public status page your customers can subscribe to, and page whoever is on
call through rotations and escalation policies. Drive it by click, REST
API, or Terraform. Self-host the single binary or use the hosted service.
Uptime monitoring, public status pages and on-call in one. Checks as often as every 30 seconds from multiple regions, 8 check types including browser login flows and cron heartbeats, automatic incidents, escalation policies and 14+ alert channels. REST API, Terraform provider, MCP server. Hosted, with AGPL source you can self-host.
Monitoring with a built-in status page isn't new — the bet here is doing it
free, self-hostable, and fully as code:
Free hosted tier, no card — and AGPL if you'd rather run it yourself.
One self-contained binary — docker compose up and you're live, not a Kubernetes platform to operate.
Everything as code — REST API, scoped tokens, an official Terraform provider, and an MCP server your LLM can query.
Probes you own — run multi-region agents wherever your users are, on your own boxes.
Status page + incidents + on-call in one — components, subscribers, on-call rotations and escalation, and multi-channel paging that repeats until acknowledged, no second tool.
Core isn't paywalled — checks, status pages, subscribers, the API and every alert channel are in the free tier.
Who it's for
Founders / small SaaS — a professional status page in minutes, free, no self-host headache.
Platform / SRE leads — monitors as code, multi-region probes, incident paging to your on-call channels, without vendor sprawl.
Self-hosters — one binary plus two databases, no SaaS lock-in.
Live status
uptimepage monitors itself. These badges are served by the running app from a
public status page — no third-party service, no cron job updating a JSON file.
Surface
HTTP
DNS
TLS cert
Domain
uptimepage.dev (website)
app.uptimepage.dev (dashboard)
mcp.uptimepage.dev (MCP)
Embed your own with the snippet in Settings → Pages → your page → Badge.
Features
Checks
HTTP, TCP, ICMP ping, heartbeat (inbound dead-man's-switch), DNS, TLS-cert expiry, domain expiry, browser login flow with per-step timings, manual (state set by an operator); a circuit breaker per monitor, designed for ~50k concurrent in-flight
Slack, PagerDuty, Discord, Microsoft Teams, Google Chat, Mattermost, Telegram, WhatsApp, SMS, email, webhook, ntfy, Gotify, Pushover — per-org channels, sealed secrets, fire-once + recovery, repeat until acknowledged
Incidents
Internal incident state ⊥ public phase, acknowledge to silence paging, per-monitor reminder cadence
On-call
Layered rotations (daily, weekly, custom) with weekly hours, calendar overrides, your shifts as an iCalendar feed, escalation policies that page channels and schedules level by level
Multi-region
Regional probe agents, per-region views, run your own agent anywhere
Automation
REST API, scoped API tokens, Terraform provider, MCP server for LLM clients
Built on
Rust 1.95 / Tokio / Axum, Postgres + ClickHouse, one ~23 MB self-contained binary
your job pings a URL; a missing ping past period + grace opens an incident
60 s
max(plan_min, 60 s)
dns
resolve a record, optionally match a value
60 s
max(plan_min, 10 s)
tls_cert
open TLS, parse leaf cert, alert before notAfter
86 400 s (daily)
max(plan_min, 3600 s)
domain_expiry
query RDAP, alert before the domain's expiration event
86 400 s (daily)
max(plan_min, 43 200 s)
flow
drive a headless browser through login / transaction steps, assert the result
300 s
max(plan_min, 300 s)
manual
no probe; an operator sets up, degraded or down and it restates that state
60 s
exactly 60 s
tls_cert and domain_expiry use warn_days / critical_days thresholds and surface days_remaining plus registrar / cert subject in the result payload. Their floors are 1 hour for tls_cert and 12 hours for domain_expiry, regardless of plan — these probes track values that change on a scale of days, not minutes, and RDAP rate-limits by source address. flow runs a real browser, so it only executes where a browser engine is available (its regions clamp to the flow-capable set) and the number of flow monitors is capped per plan; put credentials in an org secret and reference them as {{name}}. Every flow run is kept with each step's outcome and duration, and the monitor page charts each step on its own scale, so a wait drifting from 200 ms to four seconds shows up long before the journey fails. A self-hosted install starts with that cap at 0; docs/monitor-types.md covers turning it on. See docs/api.md for the full payload shapes.
Public status page
A customer-facing /status page (HTML + JSON + RSS 2.0) is built into the binary. Per-target opt-in via public_status; the page's routes carry no auth extractor, so it is public wherever the binary runs, with a per-IP rate limit at the edge, caches for 10 s in-process, and degrades gracefully if ClickHouse is unreachable. Operators narrate incidents (PATCH /api/v1/incidents/{id}, POST /api/v1/incidents/{id}/updates) and schedule maintenance windows (POST /api/v1/maintenance). Visitors subscribe for email or webhook updates. See docs/public-status.md.
Alerting
Notification channels are per-org resources (Slack incoming webhook, generic
HTTP webhook, Telegram bot, SMS gateway, …) created via /api/v1/notification-channels.
Transport secrets are sealed at rest and never echoed back.
A target opts in by binding one or more channels in its alerts array:
Fire-once + recovery semantics. Channels are tenant-isolated — a target can
only bind a channel its own org owns. See docs/api.md for the
full contract.
Multi-region
Run probe agents in the regions your users live in; the control plane assigns
checks per region and the dashboard and status page can be viewed per-region.
Bring your own agent anywhere — a single binary with an org-scoped token. See
docs/multi-region.md.
terraform {
required_providers {
uptimepage = {
source = "uptimepage/uptimepage"
}
}
}
provider "uptimepage" {
token = var.uptimepage_token # or set UPTIMEPAGE_TOKEN
org = "your-org-slug" # required for managed resources; or UPTIMEPAGE_ORG
# endpoint defaults to https://app.uptimepage.dev; set it for a self-hosted instance
}
resource "uptimepage_target" "api" {
name = "api prod"
interval = 60
check = {
type = "http"
http = {
url = "https://example.com/healthz"
expected_status = { kind = "exact", exact = 200 }
}
}
}
MCP server
An MCP server lets an LLM client (the claude.ai connector, Claude Desktop, an IDE) answer questions about one org's monitors and take a few guarded actions, over Streamable HTTP at /mcp. Nineteen read-only tools plus nineteen write tools (each scope-gated and audited, and confirmed per action where the client can show a prompt). Auth is an org-bound scoped token — paste one by hand, or use the one-click OAuth 2.1 connector. Off by default; enable with UPTIMEPAGE_MCP_ENABLED=true (+ MCP_OAUTH_ENABLED for the connector). See docs/mcp.md.
Three steps. No Rust toolchain and no compile step.
1. Start it
docker compose up -d
Pulls ghcr.io/uptimepage/uptimepage:latest and starts Postgres 18, ClickHouse 26.3, and the monitor. Both databases run their own migrations at startup, so there is nothing to wire up.
Prints a one-time sign-in link, a full-access API token, and your org slug. These appear once, so copy them before closing the terminal.
3. Sign in and add a monitor
Open the link from step 2. That drops you into the dashboard at http://localhost:8080, where you can add your first monitor.
To stop: docker compose down, or docker compose down -v to delete the data too.
This stack has no TLS and no auth in front of it, and it publishes the database ports. Great for trying it out, not safe on the open internet. To run it for real, see Production deployment.
Options
Pin a version. Set UPTIMEPAGE_IMAGE=ghcr.io/uptimepage/uptimepage:1.5.0 to stay on a release instead of latest. Release tags carry no v prefix, though the git tag they are built from does.
On an ARM host? Release tags are linux/amd64 and linux/arm64. latest, which tracks the newest commit on main, is amd64 only, so pin a release on ARM.
ClickHouse system logs are off. Stock ClickHouse keeps two dozen system.*_log tables that grow without bound and use CPU at idle. Uptimepage reads none of them, so config/clickhouse-quiet.xml turns them all off; to get one back for debugging, delete its line there and run docker compose up -d --force-recreate clickhouse (a plain restart can keep reading the old file). A stack started before this setting existed keeps its old tables: run docker compose up -d first so ClickHouse restarts with the setting, then list them with SELECT name, formatReadableSize(total_bytes) FROM system.tables WHERE database = 'system' AND name LIKE '%\_log%' and remove each with DROP TABLE system.<name>.
Signing in later. The bootstrap link works once. For repeat sign-in, and to invite a team, set up OAuth with GitHub, GitLab, Google or Microsoft, or an email provider for magic links ([auth.github], [auth.gitlab], [auth.google], [auth.microsoft], [email] in config/default.toml, or the matching env vars). See docs/authentication.md.
Packaging this for an app store? Step 2 needs a terminal. Set UPTIMEPAGE_BOOTSTRAP__EMAIL instead and the first boot seeds that owner and logs a sign-in link, no shell required. See First-run owner.
Use the token and org slug from step 2. Create a monitor:
interval is in seconds and has to meet the plan minimum, which is 180 on the free plan the bootstrap-owner step above starts you on. Anything lower returns 422 MIN_CHECK_INTERVAL. Seeding the owner at first boot instead (see First-run owner) places that org on quotas.default_plan, which defaults to team and a 30-second floor. An org created later through signup lands on founding while that tier is open, where the floor is 60 seconds.
Anything reachable from the internet should run this stack, not the one above. It adds a Caddy edge with automatic TLS, internal-only Postgres and ClickHouse, per-IP rate limits, and blue/green restarts. The operator host is guarded by the app's own sign-in, not by an edge credential. It pulls the same published image. Setup runbook is in deployment/README.md, with the architecture in docs/deployment.md.
Bring your own Postgres 18 and ClickHouse; the chart ships neither. A second chart, uptimepage-agent, runs a probe on its own in another region or inside a private network, against this or the hosted service. Details in docs/kubernetes.md and charts/.
Build from source
Published images are linux/amd64. Build from this checkout when you are on an ARM host (Apple silicon, Ampere), or when you are changing the code:
docker compose -f docker-compose.yml -f compose.build.yml up -d --build
Same stack and the same three steps as Docker, only the image origin differs. Note that your local build then owns that image tag, so run docker compose pull when you want the published image back.
Run without Docker
cargo build --release
./target/release/uptimepage
Requires Postgres and ClickHouse reachable at the URLs in config/default.toml, plus a non-empty fingerprint salt (the app refuses to boot without one):
The single binary serves both the /api/v1/* JSON surface and a server-rendered HTML UI at / — askama compile-time templates, HTMX for partial swaps and JSON forms (no SPA framework), Tailwind CSS 4, and lazy-loaded ECharts. Every UI mutation hits an existing /api/v1/* endpoint, so the API stays the single source of truth. Stack, routes, the add-a-page recipe, and UI tests are in docs/development.md.
Legal
Policies belong to whoever runs the instance. Point the [legal] URLs at your
own terms, privacy policy and the rest: the app links each one you set, shows
terms and privacy at signup and records their versions on new accounts, and
links nothing you leave empty. See docs/configuration.md.
GDPR self-service (data export, account deletion, recovery) lives under
/settings/account.
License
uptimepage is licensed under AGPL-3.0. See LICENSING.md
for what this means in practice. The name and logo are trademarks; see TRADEMARKS.md before you run a public service or a fork.
Uptime monitoring, public status pages and on-call in one. Checks as often as every 30 seconds from multiple regions, 8 check types including browser login flows and cron heartbeats, automatic inciden
Uptime monitoring, public status pages and on-call in one. Checks as often as every 30 seconds from multiple regions, 8 check types including browser login flows and cron heartbeats, automatic incidents, escalation policies and 14+ alert channels. REST API, Terraform provider, MCP server. Hosted, with AGPL source you can self-host.
Ferramentas
Ferramentas
Ainda não há lista de ferramentas. Servidores remotos recebem uma após a primeira verificação de saúde.
Perguntas frequentes
Perguntas
Como instalo Uptimepage?
Copie nesta página a configuração http para Cursor, Claude Desktop, Claude Code ou VS Code. Ela usa a instalação do publicador, não um proxy do PlugMCP.
Este registro não lista nenhuma variável de ambiente obrigatória.
Qual transporte Uptimepage usa?
Uptimepage é acessado por HTTP.
Quando Uptimepage foi verificado pela última vez?
Última verificação: 2026-10-27. Uptime monitoring, public status pages and on-call in one. Checks as often as every 30 seconds from multiple regions, 8 check types including browser login flows and cron heartbeats, automatic incidents, escalation policies and 14+ alert channels. REST API, Terraform provider, MCP server. Hosted, with AGPL source you can self-host.