Deploy UptimeKit | (Just Updated) Uptime Monitoring and Status Page, Worker Pre-Registered, Admin Login Pre-Created
UptimeKit uptime monitoring and status page, self-hosted, with a worker
Just deployed
/var/lib/postgresql
uptimekit
Just deployed
worker
Just deployed
Deploy and Host UptimeKit on Railway
Built for an LLM agent to deploy and use. The deploy form has no fields to fill: the administrator login, the database credentials and the worker key are generated, the administrator account is created at boot with a password you can sign in with, a worker that runs the checks is already registered and connected, and public sign-up is closed from the first request. UptimeKit is an open-source uptime monitoring platform: HTTP, keyword, JSON, TCP, ping and DNS monitors, incidents and public status pages, a self-hosted alternative to UptimeRobot and Better Stack.
About Hosting UptimeKit
This template runs three services: uptimekit, the official ghcr.io/uptimekit/dash image (release 5.2.2) pinned by digest through a thin wrapper, which serves the dashboard, the API and the status pages; worker, the official ghcr.io/uptimekit/worker image (5.2.2) pinned by digest, which runs the monitor checks and reports to the dashboard over Railway's private network; and database, a PostgreSQL 18 instance with the TimescaleDB extension and a volume at /var/lib/postgresql that holds every account, monitor, incident and check result. One public domain serves UptimeKit; the dashboard answers on port 8080 with an HTTP healthcheck at /api/health that turns green only after the administrator and the worker exist.
What the wrapper fixes. The stock image lets the first visitor create the instance administrator, and ships no worker: monitors run only after someone creates a worker in the admin panel and copies its one-time key into a second service. The wrapper starts the app on a loopback port, creates the administrator from ADMIN_EMAIL and ADMIN_PASSWORD, registers a worker whose key is WORKER_API_KEY (stored as a SHA-256 hash, as the app stores keys it generates), and only then opens the public port. Nothing outside the container can reach a sign-up form while the instance has no administrator, and every later sign-up is refused (the proxy reports it as 403). A redeploy keeps the administrator and rewrites only the worker key hash, so rotating WORKER_API_KEY on both services rotates the key.
Using it. Open your domain and sign in with the administrator email and password, then add monitors in the dashboard or through the API below. The worker is registered in the location us. Email, Slack and other notification channels, and the optional Apprise sidecar, are not configured.
Agent contract
- Public URL:
https://RAILWAY_PUBLIC_DOMAIN(the generated domain of theuptimekitservice) - Private URL:
http://uptimekit.railway.internal:8080 - Credentials: the variables
ADMIN_EMAILandADMIN_PASSWORDon theuptimekitservice (plain text);WORKER_API_KEYon theuptimekitandworkerservices is the worker's key - Auth:
POST /api/auth/sign-in/emailwith JSON{"email","password"}and anoriginheader equal to the public URL sets a session cookie; send the cookie on every/api/rpc/...call, which answers 401 without it - Health:
GET /api/healthreturns 200 without credentials
#!/bin/sh
# needs: RAILWAY_PUBLIC_DOMAIN, ADMIN_EMAIL, ADMIN_PASSWORD (variables of the uptimekit service); also curl, jq.
R="https://$RAILWAY_PUBLIC_DOMAIN"; H="content-type: application/json"; O="origin: $R"; JAR=$(mktemp)
n=0; until [ "$(curl -s -o /dev/null -w '%{http_code}' "$R/api/health")" = 200 ]; do n=$((n+1)); [ "$n" -le 90 ] || break; sleep 5; done
curl -s -o /dev/null -w "health: %{http_code}\n" "$R/api/health"
curl -s -o /dev/null -w "public signup: %{http_code}\n" -H "$H" -H "$O" -d '{"email":"stranger@example.com","password":"stranger-twelve-chars","name":"x"}' "$R/api/auth/sign-up/email"
# sign in with the generated login: the session cookie kept in $JAR authenticates every call after this
curl -s -c "$JAR" -o /dev/null -w "login: %{http_code}\n" -H "$H" -H "$O" -d "$(jq -nc --arg e "$ADMIN_EMAIL" --arg p "$ADMIN_PASSWORD" '{email:$e,password:$p}')" "$R/api/auth/sign-in/email"
curl -s -o /dev/null -w "wrong login: %{http_code}\n" -H "$H" -H "$O" -d "$(jq -nc --arg e "$ADMIN_EMAIL" '{email:$e,password:"wrong-wrong-wrong"}')" "$R/api/auth/sign-in/email"
# the worker that runs the checks is pre-registered; its first heartbeat arrives within about a minute of boot
n=0; until [ -n "$(curl -s -b "$JAR" "$R/api/rpc/workers" | jq -r '.items[] | select(.id=="railway-worker") | .lastHeartbeat // empty')" ]; do n=$((n+1)); [ "$n" -le 30 ] || break; sleep 5; done
echo "worker online: $(curl -s -b "$JAR" "$R/api/rpc/workers" | jq -r '.items[] | select(.id=="railway-worker") | (.lastHeartbeat != null)')"
echo "read without session: $(curl -s -H "$H" "$R/api/rpc/monitors" | jq -r '.code')"
# write-auth: POST /api/rpc/monitors creates a monitor and needs the session cookie; without it the answer is 401
BODY='{"name":"example.com","type":"http","interval":60,"timeout":30,"retries":0,"retryInterval":60,"config":{"url":"https://example.com","method":"GET"},"workerIds":["railway-worker"]}'
curl -s -b "$JAR" -o /dev/null -w "write with session: %{http_code}\n" -H "$H" -H "$O" -d "$BODY" "$R/api/rpc/monitors"
curl -s -o /dev/null -w "write without key: %{http_code}\n" -H "$H" -H "$O" -d "$BODY" "$R/api/rpc/monitors"
Expected output against a fresh deploy:
health: 200
public signup: 403
login: 200
wrong login: 401
worker online: true
read without session: UNAUTHORIZED
write with session: 200
write without key: 401
The refusals are the contract: a request without a session is refused (write without key: 401), a stranger cannot register (public signup: 403) and a wrong password is refused (wrong login: 401).
Why Deploy UptimeKit on Railway?
Railway is a singular platform to deploy your infrastructure stack. Railway will host your infrastructure so you don't have to deal with configuration, while allowing you to vertically and horizontally scale it.
By deploying UptimeKit on Railway, you are one step closer to supporting a complete full-stack application with minimal burden. Host your servers, databases, AI agents, and more on Railway.
- Agent-ready - no deployer fields, a contract block, and one script that proves the dashboard is healthy, strangers cannot register, the worker is online and the generated login can create a monitor.
- Worker included - the checks run from the first minute, with no admin-panel step to copy a key.
- Locked from the first request - the public port opens only after the administrator exists.
- Data survives redeploys - accounts, monitors and check history live in PostgreSQL with TimescaleDB on a volume.
- Pinned - the upstream images are pinned by digest (the registry tag
5.2.2was later moved to a canary build, so the digest of the real release is used) and the wrapper by tag and digest.
Common Use Cases
- Uptime monitoring - watch websites and APIs from your own server instead of a monitoring subscription.
- Public status page - publish incidents and component status for your product.
- Monitoring for AI agents - give an agent a generated login and an API to add the monitors for whatever it deploys.
Dependencies for UptimeKit Hosting
- The uptimekit service, the worker service and a PostgreSQL service with TimescaleDB and its volume, created by the template.
Deployment Dependencies
Template Content
