---
title: "Deploy UptimeKit | (Just Updated) Uptime Monitoring and Status Page, Worker Pre-Registered, Admin Login Pre-Created"
description: "UptimeKit uptime monitoring and status page, self-hosted, with a worker"
category: "Other"
url: https://railway.com/deploy/uptimekit-or-just-updated-uptime-monitor
---

# 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

**[Deploy UptimeKit | (Just Updated) Uptime Monitoring and Status Page, Worker Pre-Registered, Admin Login Pre-Created on Railway](https://railway.com/template/uptimekit-or-just-updated-uptime-monitor)**

Machine-readable deploy manifest (JSON, validated by TemplateCI): https://railway.com/deploy/uptimekit-or-just-updated-uptime-monitor/manifest.json

- **Creator:** SuperSlowSloth
- **Category:** Other

## Template content

### database

- **Image:** timescale/timescaledb:2.27.1-pg18@sha256:639a43b70247489e618da0351ac7c9ffb139790dc672cd42c50cec60b2a33497

### uptimekit

- **Image:** ghcr.io/bon5co/uptimekit-railway:5.2.2@sha256:a4a53daf6654decb6b8b928cf084d7b08a434f42ae7404c3dc5a5fd158b64487
- **Health check:** /api/health
- **Public domain:** Yes

### worker

- **Image:** ghcr.io/uptimekit/worker@sha256:2b0d61f0cff86505a0467b04f139de269dcac9fcd70cc2c2c82cb51d7d223769

## Documentation

# 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 the `uptimekit` service)
- Private URL: `http://uptimekit.railway.internal:8080`
- Credentials: the variables `ADMIN_EMAIL` and `ADMIN_PASSWORD` on the `uptimekit` service (plain text); `WORKER_API_KEY` on the `uptimekit` and `worker` services is the worker's key
- Auth: `POST /api/auth/sign-in/email` with JSON `{"email","password"}` and an `origin` header 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/health` returns 200 without credentials

```bash
#!/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:

```text
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.2` was 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

- [UptimeKit repository](https://github.com/uptimekit/uptimekit)
- [Wrapper image source](https://github.com/bon5co/uptimekit-railway)


## Similar templates

- [Rocky Linux](https://railway.com/deploy/rocky-linux) — Hosted Rocky Linux 9 workspace with SSH and persistent storage. 🚀
- [Foundry Virtual Tabletop](https://railway.com/deploy/X5tR6G) — Self-hosted virtual tabletop for role-playing games (license required)
- [Double Commander in your browser](https://railway.com/deploy/double-commander-in-your-browser) — The Double Commander file manager in the cloud, from any device

Open this page in a browser: https://railway.com/deploy/uptimekit-or-just-updated-uptime-monitor
