Self-Host Uptime Kuma on an Anonymous No-KYC VPS

Run the status watcher yourself on rented root: one Compose file, one data volume, nothing published. Entry tier $6/mo list, $4.80/mo prepaid yearly.
Run the status watcher yourself on rented root: one Compose file, one data volume, nothing published. Entry tier $6/mo list, $4.80/mo prepaid yearly.
The watcher files you, too
Hosted monitoring inverts its own promise: the service guarding your infrastructure assembles a thicker dossier on you than on anything it watches. Every URL observed, incident note, on-call name and latency trace sits in somebody else's database, usually beneath an account carrying your card. Relocating the checker onto anonymously rented root flips custody — observations remain on your disk, behind your key, inside a jurisdiction you chose.
Uptime Kuma suits the job: a light Node dashboard doing HTTP, TCP and ping checks, keeping heartbeat history and notification hooks, with a shareable incident page available but not required. All state concentrates in one directory — /app/data inside the container, a SQLite file named kuma.db — so the entire application reduces to one process, one folder, one backup target. The upstream repository documents the layout.
The provider's part ends at the invoice: what is rented is a root KVM slice, and the watcher plus its database plus its alert list are entirely yours to operate or break. One clause of the rulebook still reaches in — attack traffic and worse are banned outright, so watch only what you are entitled to watch. A monitor should read as a polite, predictable visitor.
The break precedes any install: fleeing a surveillance-priced SaaS, then registering for the replacement under a main mailbox with a debit card — rebuilding the very dossier just escaped. Account setup belongs to the project: a string-only credential or at minimum a dedicated address, as the inbox-free signup guide details. A watcher's discretion is settled at checkout, never in its settings.
Size before the first check lands, since the decision is dull today and irritating later. The next section runs the actual arithmetic: what a checker consumes while young, where growth accumulates, and where the honest floor sits for a dashboard meant to survive years. The numbers are friendlier than most people fear.
VPS from $4.80* — Core on the annual term (list $6/mo), one invoice for 12 months, no auto-charges. Dedicated with IPMI from $39.20/mo. Crypto invoice, no KYC.
Launch nowQuiet at birth, hungry at middle age
Newborn, the application idles in tens of megabytes, writing once per heartbeat — a 60-second cadence per monitor by default. Growth arrives along two axes at once. Retention: every monitor accumulates history until pruned. Rendering: the dashboard draws latency charts and preview cards per row, and past a screenful of monitors those drawings start competing with the checks themselves for memory.
The floor that absorbs both stages: the entry tier — 2 vCPU on a Ryzen 9 9950X, 4 GB DDR5 ECC, 80 GB NVMe, unmetered 1 Gbps, one IPv4 plus a /64. Dozens of monitors and a fronting proxy settle in comfortably; scale when charts fight checks for RAM, not before. Nested guests are permitted on the range, so containers need no special pleading.
Take the Core plan at $6/mo list — $4.80/mo on the 12-month prepay — and let the checker doze there; yearly billing means a single invoice per 12 months, nothing automatic, which suits a machine meant to be forgotten. Note what the included DDoS shield is not: an application firewall for the dashboard. It guards the pipe; the panel's exposure remains your department.
Sizing for the demo rather than the year is the standard miss: three monitors run anywhere, so the smallest slice feels infinite until forty monitors, a shareable page and two years of history arrive and memory quietly vanishes. The companion error is reading the packet shield as an application firewall — it stops floods, not password guessing. Budget for growth; keep the panel unpublished anyway.
Plan chosen, installation is five minutes containing exactly one decision that matters for the coming year: where the data will live. The next section builds the stack and locks that decision in properly. Everything else is rebuildable in an afternoon; the history is not.
One volume is the whole religion
Exactly one thing must outlive container recreation: /app/data. Erase it and every monitor, heartbeat and alert rule dies simultaneously. Compose turns its protection into a two-line declaration — a named volume mounted at that path. The container itself, its image and its log policy are all disposable by intent; rebuild them whenever, the folder persists beneath.
Install Docker from the distribution's own repositories — skip convenience scripts — then move your existing Kuma tree over via rsync and build locally: no marketplace images, no registry roulette, nothing pinned to a stranger's week. The fitting Compose file: context ./uptime-kuma, restart: unless-stopped, port published as 127.0.0.1:3001:3001, mount kuma-data:/app/data, logging capped by max-size: 10m and max-file: 3. The Compose reference explains each key.
Raise it with docker compose up -d; the first visit behaves like any debut — the interface creates the administrator account on arrival, which you will reach through a tunnel per the next section, and checks get added one at a time. Those log caps earn their lines: an uncapped json-file stream on a talky container devours flash silently, month after month, for nothing.
Both classic failures are mount-shaped. No mount: recreation wipes history invisibly — the app keeps running, so the loss surfaces weeks later as a blank availability graph. Wrong permission context on a host directory: the stack starts, the database cannot write, heartbeats evaporate on sight. The named mount sidesteps both, which is why it is non-negotiable here.
One process, one mount, one port on the loopback interface — the footprint is three facts, and they frame the next problem precisely: the dashboard answers only on the machine itself, so entry must exist without publication. Tunnels, next — one command, zero new surface. Three facts also suggest three verifications after any rebuild: the mount survived, the port stayed loopback-only, the log caps still apply.
Enter without publishing
The quickest identity gift to an anonymous machine is a public admin panel: certificate transparency logs, scanners and archives record the hostname within hours. Hold 3001 on the loopback interface until TLS plus genuine authentication stand in front — and consider whether that day should arrive at all, since the tunnel available today costs one command and adds zero surface.
That tunnel is a local forward: ssh -L 8400:127.0.0.1:3001 root@203.0.113.7, then browse http://localhost:8400 as though the panel lived on your desk — the example address comes from documentation space, so substitute your own. Everything rides the channel your terminal already uses; nothing new listens; the ssh manual details the flag.
For residence longer than a check-in, WireGuard pays rent: raise wg0 via wg-quick up wg0, listen on 51820/udp, and the panel appears over tunnel space whenever the laptop wakes. It shrugs off roaming, reconnects and hotel networks better than any forwarded port, and the upstream quick start runs ten minutes end to end.
Temporary exposures calcify: publish the port "for this afternoon only" and by evening three scanner indexes hold it. Screenshot hygiene fails second: a captured panel with a live session cookie in frame — rotate the session, crop the image, or shoot before logging in at all. Remote consoles leak through convenience, never through mathematics. The same discipline covers pasted error text and attached captures: crop to the object, since an image routinely carries more than its author notices.
Transport solved, the remaining question is what the machine says when speaking for itself — because each check departs carrying its return address, and every destination writes it down. That is the footprint no tunnel removes; the next section belongs entirely to it. Write the address down once, then treat it as public knowledge from that minute on — privacy lives in the account, never on the wire.
The return address problem
Payment method does not touch physics: each check departs from the box's IPv4, and every destination logs that address into its own records, limits and alerting. The crypto invoice purchased an ownerless account; it bought the checks no new origin. Location therefore deserves the same deliberation as size — the city is the return address the internet will see.
Pricing keeps the choice clean: identical base cost across all twelve cities, leaving latency and law as the only variables. Iceland (+20%) and Switzerland (+35%) are the sole listed surcharges — payment for jurisdiction, not hardware. Prefer Reykjavik or Zurich when governing law carries weight; prefer proximity to targets when alert speed outranks paperwork.
The usage line bites monitors specifically: the AUP prohibits attack traffic without exception, so a "watcher" that pounds endpoints, guesses logins or mirrors content it has no claim to is not a watcher but an incident. Observe targets you are entitled to observe, at intervals a human would call courteous, and the tool stays boring — which is high praise. HTTP checks are standardized requests under RFC 9110, nothing more exotic.
Identity never leaks from the check engine; it leaks from the plumbing around it. A shareable page on a WHOIS-bearing domain publishes the pairing of discreet watcher and known operator in one line. Alert webhooks keyed to your personal messenger sign every notification with the same hand. Both cures live one settings screen away; both stay invisible until examined, and examination eventually comes.
Model the machine as a small embassy: address known by design, interior entirely yours, courier bags — the alerts — dispatched through a side entrance carrying no return label. Those bags get the next section, because notification plumbing is where self-hosted watchers most often betray their owners.
Alerts: the loud half
The checker itself nearly whispers: heartbeats into SQLite, charts for whoever tunnels in. Identity accumulates in the notification chain instead, where every webhook URL, bot token and SMTP credential signatures its creator. In practice, self-hosted watchers expose their operators through this plumbing, essentially never through packet inspection.
The cure is minting per-box credentials, exactly as any other tenant would. A fresh messenger bot owns its token and chat; a new webhook addresses its own channel; a dedicated mailbox exists for SMTP alerts alone. Kuma binds notifications per monitor from Settings → Notifications, and each entry ships a Test button — press it for every channel before trusting the chain in anger.
Mail alerts carry one extra trap: headers. A message sent from your everyday mailbox reads like a biography — name, provider, transport history — because mail governed by RFC 5321 is honest about its envelope. The identity leaks through the envelope you chose, not through the protocol. An address on a domain held for this purpose keeps alerts useful and biography absent.
Reusing a personal bot token because it exists is the archetype: every alert then testifies that one human runs both the watcher and whatever else that bot touches. Close behind: the shareable page flipped on accidentally during setup — one checkbox publishing every monitor name typed, internal hostnames included. Audit both after week one; assume neither stayed off by itself.
Checks courteous, plumbing silent, one duty remains: the database you have fed for months needs an exit path, and the machine needs a plan for outgrowing the floor tier. Minutes when planned; hours when improvised. That is the final section before the runbook. Budget one evening per quarter for the same upkeep: rotate the minted bot tokens, re-press each channel's Test button, and walk one archived copy back into a fresh stack.
Exit paths: backups, images, bigger iron
Nobody here promises to safeguard your disk — managed backups do not exist on this catalog, and snapshots are a checkout extra: rollback tooling, not archiving. The watcher's true asset is modest: one SQLite file inside a named mount, months in the making. Small data plus slow accumulation is precisely the profile that deserves plain file-level copies on a schedule — or residence inside a sealed container, as the LUKS guide shows.
The job is three lines: docker compose stop to quiet the database, tar czf across the mount directory — locate it via docker volume inspect; named mounts dwell under /var/lib/docker/volumes/ as _kuma-data/_data — then start again. Ship the archive off-box that same night. The Docker storage guide maps the paths; the stop is not optional, since a halted container cannot corrupt its own copy.
Rehearse restoration inside a scratch project once: new directory, identical Compose file, mount restored from archive, stack raised, log in, count monitors. Five minutes converts the archive from hypothesis to plan. Updates travel the same road: pull your own tree, rebuild, raise — the named mount ferries history across the rebuild untouched.
When the checker matures into infrastructure — fronting proxy, alert routing, a year of charts — lease Forge at $49/mo list, $39.20/mo prepaid yearly, and carry the identical Compose file across; the previous section's archive tars over in one copy, and the mount lands exactly as it lived. Count the move in evenings, not minutes: stop, archive, copy, raise, verify, re-test alerts — the checklist the nightly ritual already drills.
The backup that betrays is the live one: SQLite mid-write beneath a running container yields an archive restoring into half a database — discovered during the outage, not before. Stop, copy, start, verify elsewhere: thirty seconds of nightly downtime purchasing a rehearsed restore. Data, access and identity settled, only the running order remains.
The Uptime Kuma box, in the order to run it
Begin with the account, not the machine: string-only or a dedicated mailbox, existing before any infrastructure — the account's discretion is fixed at signup and never after. For the account-and-wallet side in full, the anonymous VPS guide holds the longer playbook. Size in the same motion: the entry tier's two cores, four gigs of ECC memory and eighty gigs of flash carry most watching jobs. Pick the city for latency toward targets, since base cost never moves between flags.
Fund from the wallet already reasoned through; about a minute after confirmation, the shell answers. Harden before anything else boards: locally minted key with an empty comment, public half installed, password logins disabled, configuration validated, second session proven. A watcher lives for years — ten minutes of hardening is the cheapest per-year spend on this page.
Docker from the distro, your Kuma tree copied across, and a Compose file holding the one non-negotiable line — the named mount at the data path — plus loopback-only publishing and the log caps. Raise the stack, tunnel in, create the administrator on arrival. Add checks at human intervals; press Test on every alert channel before depending on it.
Settle the public surface once, on purpose: shareable page off, webhooks from identities minted for this machine, SMTP from the dedicated address. Then install the two rituals — the nightly stop-copy-start that never archives a writing database, and the quarterly restore rehearsal keeping archives honest. Snapshots complement file copies as instant rollback; neither replaces the other.
Grow along the same rails: more checks on the same slice until charts and retention quarrel, then the identical Compose file and mount onto larger iron, the archive serving as the moving van. The system fits a paragraph because it was designed to: one discreet account, one sealed machine, one mount that matters, one copy elsewhere. Run the steps in order and the watcher stays exactly as dull as a watcher should be.
Will the entry tier cope?
Comfortably. Two cores, four gigabytes of ECC memory and eighty gigabytes of flash at $6/mo list — $4.80/mo prepaid yearly — absorb dozens of checks plus a fronting proxy. Scale only when retention and rendering start competing for memory.
Does the provider run it for me?
No. What is sold is a root KVM slice, and involvement ends at the invoice: you operate Compose, own the mount, keep the history. Nothing host-side touches the checker once payment credits.
Is the shareable page a good idea?
Only with two exposures accepted: the page is public, and every visitor learns the watcher's origin. Keep the panel loopback-only, tunnel in for private views, and publish status pages solely from domains that do not name you.
Where should the watcher sit?
Between you and whatever it watches: choose by alert latency, because base cost is identical across all twelve cities. Iceland and Switzerland alone carry listed surcharges, so law and latency are the genuine decision variables.
What actually saves the history?
The nightly stop-copy-start over the named mount, shipped off-box the same evening. A halted database cannot corrupt its own archive, and a quarterly rehearsal turns that archive from a hypothesis into a plan.
Primary sources
More ways to pay
Pay with Bitcoin · Pay with Monero · Pay with USDT (TRC-20/ERC-20/SPL) · Pay with Litecoin · Pay with Ethereum · Pay with Solana · Pay with x402 · Pay with Dogecoin · Pay with XRP · Pay with TRX · Monero on bare metal · Dedicated servers with crypto · Pick the jurisdiction first.
Ready to launch?
Build the box — VPS or bare metal — create the password, pay the invoice that follows.