Beszel is the tool I would put beside Uptime Kuma in a small homelab, not because it does the same job, but because it answers the next question.
Uptime Kuma tells you whether a service is reachable. Beszel tells you how the machine and containers behind that service are behaving over time: CPU, memory, disk, network, Docker/Podman stats, sensors, SMART, ZFS, alerts, and agent-side network checks.
That makes it one of the cleaner “what is my server doing?” dashboards in the current monitoring pile.
Beszel = Go hub + PocketBase storage + React dashboard + lightweight agents
What is Beszel?
The repository I checked was:
Repository: https://github.com/henrygd/beszel
Checked commit: 13bdd05934a7363016aa9a92c0d5bef13c0e81a4
Commit date: 2026-10-09
Latest checked tag: v0.21.0
License: MIT
Container image tested: docker.io/henrygd/beszel:0.21.0
Backend: Go, PocketBase
Frontend: React, Vite, TypeScript, Recharts, Radix UI
Beszel has two moving parts:
| Component | What It Does |
|---|---|
| Hub | Web UI, API, auth, storage, alerts, system management |
| Agent | Runs on each monitored host and reports host/container metrics |
The hub embeds the web UI and stores its data in a PocketBase data directory. The agent runs close to the machine being monitored, which is why Beszel can show host-level and container-level metrics without asking you to assemble a Prometheus stack.
Why It Is Interesting
Most homelab monitoring conversations eventually split into different questions:
| Question | Common Tool |
|---|---|
| Is the service reachable? | Uptime Kuma, Kuvasz, Uptime Kotlin |
| What changed on the server? | Beszel, Netdata, Glances |
| What is wrong with my containers? | Maintenant, Dozzle, Portainer |
| What do users need to know? | Statup, Uptime Kuma status pages |
| What does my public website expose? | Web-Check, LinkChecker |
| Are my domains/DNS/certs healthy? | Domain Locker |
Beszel is focused on the second question.
It is not trying to be a full observability platform. It is trying to give you a useful server and container dashboard with less wiring.
What Beszel Monitors
From the README and source, Beszel can track:
- CPU usage, load average, memory, swap, and ZFS ARC;
- disk usage and disk I/O;
- network throughput;
- Docker/Podman container status, CPU, memory, and network usage;
- temperature and fan sensors;
- connected Wi-Fi signal strength where the agent platform supports it;
- Nvidia, AMD, and Intel GPU metrics where supported;
- battery charge;
- SMART health, eMMC wear, and mdraid health;
- ZFS pool and dataset health, usage, I/O, and scrub status;
- agent-side network monitors for ICMP, TCP, HTTP, and DNS;
- alerts through email and webhook-style notification services.
It also supports multi-user setups, OAuth/OIDC, API access, and automatic backups to disk or S3-compatible storage.
Self-Hosting Beszel with Docker
I updated the Home-Lab compose here:
Home-Lab Beszel composeThe hub is exposed on port 3813 because port 8090 is already in use on this machine:
services:
beszel:
image: docker.io/henrygd/beszel:${BESZEL_VERSION:-0.21.0}
container_name: beszel
restart: unless-stopped
environment:
APP_URL: ${BESZEL_APP_URL:-http://192.168.1.2:3813}
ports:
- ${BESZEL_BIND:-0.0.0.0}:${BESZEL_PORT:-3813}:8090
volumes:
- ./beszel_data:/beszel_data
healthcheck:
test: ["CMD", "/beszel", "health", "--url", "http://localhost:8090"]
interval: 120s
start_period: 10s
timeout: 5s
retries: 3
networks:
- beszel
networks:
beszel:
ipam:
config:
- subnet: ${BESZEL_SUBNET:-10.89.13.0/24}
Start it with:
cd /home/jalcocert/Desktop/Home-Lab/beszel
cp .env.sample .env
docker compose up -d
Then open:
http://192.168.1.2:3813
There is no admin/admin default login in the current setup. On a fresh beszel_data directory, create the first user in the web UI.
Adding the Agent
The agent needs values generated by the hub. That is why I kept it in a separate compose file instead of shipping a fake public key in the main compose.
After creating the first user:
- Open Beszel.
- Go to
Systems. - Add a system.
- Copy the generated
HUB_URL,TOKEN, andKEY. - Put them in
.env. - Start the agent compose:
docker compose -f docker-compose.yml -f agent.compose.yml up -d
The local agent uses network_mode: host and mounts /var/run/docker.sock:ro, so treat it as infrastructure-level access even though the socket is read-only.
Field Note: Local Test
I ran the hub locally with the Home-Lab compose.
The first attempt hit a Docker host issue:
all predefined address pools have been fully subnetted
That is the same network-pool exhaustion we saw in a few recent compose tests, so the reusable compose now defines an explicit subnet:
10.89.13.0/24
After that, the hub started cleanly:
curl -I http://127.0.0.1:3813
curl http://127.0.0.1:3813/api/health
Result:
HTTP/1.1 200 OK
{"message":"API is healthy.","code":200,"data":{}}
The container healthcheck also became healthy with output ok.
How Beszel Compares with the Monitoring Tools We Covered
| Tool | Best Fit | Notes |
|---|---|---|
| Uptime Kuma | Simple uptime checks, push monitors, notifications, status pages | Keep it for “is it up?” |
| Kuvasz | Config/API-oriented uptime monitoring | Better when you want monitoring as code |
| Uptime Kotlin | Broad protocol checks with PostgreSQL and workers | Heavier, but checks more infrastructure protocols |
| Statup | Status page, incidents, maintenance, announcements | Better for human communication |
| Maintenant | Docker/Kubernetes operations, logs, certs, updates, status pages | Broader operations cockpit |
| Web-Check | One-off website reconnaissance | Not continuous server monitoring |
| Domain Locker | Domain inventory, DNS, expiry, cert awareness | Watches domain assets, not host resources |
| Prometheus + Grafana | Deep metrics platform | More flexible, much more setup |
| Netdata | Deep per-host live telemetry | Richer per-host detail, less calm fleet dashboard |
My practical pairing would be:
Uptime Kuma or Kuvasz = public service availability
Beszel = host/container resource behavior
Statup = public/internal incident communication
Maintenant = container/Kubernetes operations view
FAQ
Is Beszel an Uptime Kuma replacement?
Not directly.
Beszel can run network monitors from agents, including ICMP, TCP, HTTP, and DNS checks. But its real strength is host and container monitoring: CPU, memory, disks, Docker stats, sensors, SMART, ZFS, and alerts.
Uptime Kuma is still the easier fit for lots of external uptime checks, push monitors, and status pages. Beszel is the better fit when you want to understand what your machines are doing.
How does Beszel compare with Maintenant?
Maintenant is broader as an operations console. It includes Docker/Kubernetes visibility, endpoints, TLS certificates, heartbeats, logs, image updates, security insights, status pages, and MCP.
Beszel is narrower and calmer. It focuses on host and container metrics history, disk health, sensors, network monitors, and alerts.
Use Beszel when you want a lightweight resource dashboard. Use Maintenant when you want more container/runtime operations in one UI.
How does Beszel compare with Uptime Kotlin and Kuvasz?
Uptime Kotlin and Kuvasz are uptime-monitoring applications first.
Uptime Kotlin is stronger for broad protocol checks: HTTP, TCP, DNS, ping, databases, SMTP, Kafka, RabbitMQ, and public status pages. Kuvasz is interesting when you want configuration-driven uptime monitoring with an API-oriented posture.
Beszel is not trying to check every application protocol. It is trying to show what your hosts and containers are doing over time.
Does Beszel monitor Wi-Fi signal strength?
Yes, starting with the checked 0.21.0 release notes, Beszel includes Wi-Fi signal strength monitoring.
The important detail is that this is an agent-side host metric, not a Wi-Fi scanner. The source describes it as connected station monitoring: it records currently associated Wi-Fi interfaces, the SSID when available, and RSSI signal strength in dBm when the operating system exposes it.
Platform notes from the agent code:
| Platform | Behavior |
|---|---|
| Linux | Uses nl80211 through mdlayher/wifi; Docker needs network_mode: host; skipped when no wireless device is listed under /sys/class/ieee80211 |
| macOS | Uses CoreWLAN via osascript; SSID may be redacted by privacy settings |
| Windows | Uses the native WLAN API and keys readings by adapter alias such as Wi-Fi |
| Other platforms | Unsupported |
You can disable it on the agent with:
SKIP_WIFI=true
For a homelab, this is useful for mini PCs, laptops, travel routers, Wi-Fi-connected edge boxes, and small nodes where “server is slow” might actually mean “RSSI is bad.” It is not a replacement for a full Wi-Fi analyzer, controller dashboard, or spectrum tool.
Does Beszel need PostgreSQL, Redis, Prometheus, or Grafana?
No.
The hub is built on PocketBase and stores data under beszel_data. The simple Docker setup does not require PostgreSQL, Redis, Prometheus, Grafana, Loki, or external exporters.
That is the appeal: you get enough monitoring for many homelabs without building a whole observability platform.
Does Beszel have a web UI?
Yes. The hub serves a React/Vite dashboard.
In the Home-Lab setup from this post, the UI is available at:
http://192.168.1.2:3813
On this test, curl -I http://127.0.0.1:3813 returned HTTP/1.1 200 OK, and /api/health returned a healthy JSON response.
Is there a default username and password?
No default admin/admin login should be assumed.
With a fresh data directory, open the hub and create the first user. Beszel also has optional bootstrap variables such as USER_EMAIL and USER_PASSWORD, but I did not put those in the public compose because credentials should not be published as defaults.
Why is the agent compose separate?
The agent needs hub-generated values:
HUB_URLTOKENKEY
Those are created when you add a system in the hub UI. Publishing placeholders in the main compose would make the agent fail and might encourage people to commit real tokens.
So the Home-Lab setup starts the hub first, then lets you add the agent with:
docker compose -f docker-compose.yml -f agent.compose.yml up -d
Can I expose Beszel through Cloudflare Tunnel or a reverse proxy?
Yes, but expose only the hub UI/API, and protect it properly.
Use HTTPS, a real domain, and preferably OAuth/OIDC or another strong access layer. The agent connection should use the generated key/token values from the hub. If you use a self-signed certificate for the hub, newer agents may require CA_CERT_FILE so they trust that certificate.
Do not expose the Docker socket or host-only agent internals directly.
Is Beszel a PWA?
The served HTML includes a web manifest and touch icon, so it has some installable web-app affordances.
I would not frame it as an offline-first PWA, though. Monitoring dashboards depend on live hub and agent data. If the hub is unreachable, the useful monitoring experience is unreachable too.
What should I back up?
Back up the hub data directory:
beszel_data/
If you run the optional local agent compose, also back up or recreate:
beszel_agent_data/
The hub data is the important part because it contains users, systems, settings, history, alert configuration, and application state.
Conclusion
Beszel is a good fit when you want useful server monitoring without building an observability stack.
I would not use it as the only monitoring tool for every scenario. I would pair it with Uptime Kuma or Kuvasz for external uptime checks, and use Statup when the goal is clean incident communication.
But for a homelab where the day-to-day question is “which host or container is eating resources?”, Beszel is one of the least cluttered answers.
Comments