Lightweight self-hosted uptime monitor for HTTP and TCP endpoints

Beacon is a lightweight uptime monitoring tool for HTTP and TCP services.

It runs as a single Go binary, periodically checks your targets, sends alerts on failures and recovery, and provides a simple web dashboard with recent uptime history.

No agents, no Prometheus stack, no external dependencies. Point it at a URL or host:port and it works.

Beacon is designed for:

• small VPS setups
• self-hosted services
• side projects
• homelabs
• lightweight production monitoring
• simple uptime alerting without a full observability stack

If you need metrics storage, distributed tracing, or deep infrastructure analytics, use a full observability platform instead.

• HTTP and TCP checks with interval, timeout, and retry threshold
• Down and recovery notifications via Telegram and Discord
• Global notification settings with per-monitor overrides
• Real-time dashboard updates and uptime history
• Basic authentication for web UI and API
• CLI for managing monitors and inspecting state
• REST API for automation and integration

Requirements: Go 1.24+ (see go.mod)

git clone https://github.com/keshon/beacon.git
cd beacon
go run ./cmd/beacon

Open http://localhost:8080. Default login is admin / admin. Change credentials before exposing Beacon to a network.

Data is stored under ./data/. On first run, if config.json is missing, default configuration is written automatically.

go run ./cmd/beacon /path/to/config.json

go build -o beacon ./cmd/beacon
./beacon

Settings can be managed via the web UI or config.json.

Legacy configuration formats are automatically migrated.

Example minimal config.json:

{
  "listen": ":8080",
  "workers": 10,
  "default_interval": 30,
  "auth": {
    "username": "admin",
    "password": "change-me"
  },
  "telegram": {
    "enabled": true,
    "targets": [
      { "token": "YOUR_BOT_TOKEN", "chat_id": "YOUR_CHAT_ID" }
    ]
  },
  "discord": {
    "enabled": false,
    "webhooks": []
  },
  "network": {
    "enabled": false
  }
}

Configure Telegram and Discord receivers in Settings (up to 5 per channel).

Each receiver can be tested individually before saving configuration.

Each monitor can override notification routing for a specific channel.

If a channel override is set, it replaces global receivers for that channel only.

If left empty, global settings are used.

Example:

• Global Telegram receivers notify multiple chats
• One critical monitor overrides Telegram to only notify a single on-call chat

Alerts include:

• monitor name
• status (down or recovered)
• message
• timestamp

Test notifications are clearly marked as test messages.

Beacon supports optional synchronization between multiple instances.

When enabled, instances exchange monitor definitions and state.

This is useful for running multiple Beacon nodes in parallel environments.

Configuration:

• self URL
• peer list
• sync interval
• timeout settings

Export endpoint:

GET /api/sync/export

Requires sync to be enabled.

# Monitors
beacon monitor list
beacon monitor add -name "API" -type http -target https://api.example.com
beacon monitor delete <id>
beacon monitor update <id>

# State
beacon state
beacon events -limit 100

CLI uses the same datastore as the server.

All endpoints require basic authentication unless otherwise noted.

Docker support is provided via a multi-stage build in docker/.

Build example:

docker build -f docker/Dockerfile -t beacon .

Docker Compose example is available in docker/docker-compose.yml.

• Templates: templates/
• Styles: uikit/scss/
• Static assets: static/

Run tests:

go test ./...

cmd/beacon/          Entry point
internal/
  checks/            HTTP and TCP probes
  config/            Configuration handling
  monitor/           Core monitor logic
  notify/            Notifications
  scheduler/         Job scheduling
  store/             Persistence layer
  sync/              Multi-instance sync
  web/               HTTP server and API
templates/           Web UI templates
static/              CSS and JS

MIT License

Copyright (c) 2026 Innokentiy Sokolov