Tutorial

Self-Host Uptime Kuma: Free Website Monitoring with Alerts

May 04, 2026

Tutorial May 04, 2026

Why Self-Host Your Own Monitoring?

Every website owner has experienced that sinking feeling: a customer emails you saying your site is down, and you had no idea. Maybe it crashed at 2 AM, maybe it was down for hours before anyone noticed. This is where monitoring tools become essential, but most of the popular options come with a catch: monthly fees, limited monitors on free tiers, and your data living on someone else's servers.

Enter Uptime Kuma, a free, open-source, self-hosted monitoring solution that rivals paid alternatives like UptimeRobot, Pingdom, and StatusCake. Written in Node.js with a beautiful, modern UI, Uptime Kuma gives you complete control over your monitoring infrastructure without spending a dime on subscriptions.

What is Uptime Kuma? Created by Louis Lam, Uptime Kuma is an open-source uptime monitoring tool with over 60,000 GitHub stars. It supports HTTP, TCP, DNS, ping, keyword monitoring, and dozens of notification channels. It runs on a single Docker container using approximately 150MB of RAM, making it incredibly lightweight.

Uptime Kuma vs Paid Alternatives

Before diving into the setup, let's see how Uptime Kuma stacks up against paid monitoring services. This comparison will help you understand why thousands of teams are switching to self-hosted monitoring.

Feature	Uptime Kuma	UptimeRobot (Free)	Pingdom	StatusCake (Free)
Price	Free forever	Limited free	$15+/month	Limited free
Monitor Limit	Unlimited	50 monitors	10 synthetics	10 monitors
Check Interval	20 seconds	5 minutes	1 minute	5 minutes
Status Pages	Unlimited	1 page	Add-on	1 page
Notification Channels	90+ services	6 channels	11 channels	12 channels
Data Privacy	Your server	Third party	Third party	Third party
Multi-User	Yes	Team plans paid	Team plans paid	Team plans paid
Open Source	MIT License	No	No	No

The bottom line: Uptime Kuma offers more features on its free tier than most paid services provide on their premium plans. With unlimited monitors, 20-second check intervals, and 90+ notification channels, it's hard to justify paying for monitoring when this exists.

Deploying Uptime Kuma with Docker

The fastest and most reliable way to deploy Uptime Kuma is through Docker. A single container handles everything: the web interface, the monitoring engine, the database (SQLite), and the notification system. No external databases required, no complex multi-service setup.

Prerequisites

A Linux server with Docker installed (Ubuntu 22.04 or 24.04 recommended)
At least 256MB of free RAM (Uptime Kuma uses ~150MB)
A domain name (optional but recommended for SSL)
Port 3001 available (or any port you choose to map)

Quick Docker Deployment

$ docker volume create uptime-kuma
# Create a named volume for persistent data

$ docker run -d \
  --name uptime-kuma \
  --restart=unless-stopped \
  -p 3001:3001 \
  -v uptime-kuma:/app/data \
  louislam/uptime-kuma:1

a3b7c9d2e4f6...
# Uptime Kuma is now running on port 3001

That's it. Two commands and you have a fully functional monitoring platform. Navigate to http://your-server-ip:3001 to access the web interface and create your admin account.

Docker Compose Setup (Recommended)

For production deployments, Docker Compose provides better management and reproducibility. Create a docker-compose.yml file:

$ mkdir -p /opt/uptime-kuma && cd /opt/uptime-kuma
$ cat docker-compose.yml

version: "3.8"
services:
  uptime-kuma:
    image: louislam/uptime-kuma:1
    container_name: uptime-kuma
    restart: unless-stopped
    ports:
      - "3001:3001"
    volumes:
      - ./data:/app/data
    environment:
      - TZ=UTC

$ docker compose up -d
[+] Running 1/1
Container uptime-kuma Started

Configuring Monitors

Uptime Kuma supports multiple monitor types, each designed for different use cases. Once you log in to the dashboard, click "Add New Monitor" to get started.

HTTP(s) Monitoring

The most common monitor type. It sends an HTTP request to your website and checks the response status code, response time, and optionally the response body for a keyword.

Basic HTTP Monitor

URL: https://your-site.com

Interval: 60 seconds

Retries: 3

Accepted Codes: 200-299

Perfect for checking if your website returns a successful HTTP status. Uptime Kuma will mark the site as down if it receives a 4xx or 5xx status code.

Keyword Monitor

URL: https://your-site.com

Keyword: "Welcome"

Interval: 60 seconds

Goes beyond status codes by checking that a specific keyword exists in the response body. This catches cases where a page returns 200 OK but shows an error message instead of your actual content.

TCP Port Monitoring

TCP monitors check if a specific port is open and accepting connections. This is perfect for monitoring services that don't speak HTTP, such as databases, mail servers, or custom applications.

# Example TCP monitors you might create:
MySQL Server → Host: db.example.com, Port: 3306
SSH Service → Host: server.example.com, Port: 22
SMTP Server → Host: mail.example.com, Port: 587
Custom App → Host: app.example.com, Port: 8080

Ping (ICMP) Monitoring

Ping monitors send ICMP echo requests to check if a host is reachable at the network level. This is the most basic form of monitoring and tells you whether the server itself is online, regardless of what services are running on it.

DNS Monitoring

DNS monitors query a DNS server and verify that the response matches your expected value. This is crucial for detecting DNS hijacking, propagation issues, or DNS server failures.

Pro tip: Combine multiple monitor types for comprehensive coverage. Use an HTTP monitor to check your website, a TCP monitor to verify your database port, a ping monitor to confirm the server is reachable, and a DNS monitor to ensure your domain resolves correctly. If only the HTTP monitor goes down, you know it's an application issue, not a network or server problem.

Setting Up Notification Channels

A monitoring tool is only as good as its alerts. Uptime Kuma supports over 90 notification channels, ensuring you get notified wherever you are. Here are the most popular options:

Email Notifications

Go to Settings → Notifications → Setup Notification

Select SMTP as the notification type

Configure your SMTP settings: hostname, port, username, password, from/to addresses. You can use Gmail SMTP, your own mail server, or any SMTP relay service like Mailgun or SendGrid.

Click Test to verify the configuration, then Save

Telegram Bot

Telegram is one of the most popular notification channels for Uptime Kuma, offering instant push notifications to your phone.

# Step 1: Create a Telegram bot
Open Telegram → Search @BotFather → /newbot
Give your bot a name: "My Server Monitor"
Save the API token: 1234567890:ABCdefGHIjklMNOpqrsTUVwxyz

# Step 2: Get your Chat ID
Send a message to your bot
Visit: https://api.telegram.org/bot{TOKEN}/getUpdates
Find "chat":{"id": YOUR_CHAT_ID}

# Step 3: Configure in Uptime Kuma
Bot Token: 1234567890:ABCdefGHIjklMNOpqrsTUVwxyz
Chat ID: YOUR_CHAT_ID

Slack and Discord Webhooks

Both Slack and Discord use webhook URLs for integration. The setup is similar for both platforms:

Slack

Go to your Slack workspace settings, create an Incoming Webhook, select a channel, and copy the webhook URL. Paste it into Uptime Kuma's Slack notification settings. Notifications will appear as rich messages with status indicators.

Discord

In your Discord server, go to Channel Settings → Integrations → Webhooks. Create a new webhook, copy the URL, and paste it into Uptime Kuma. Discord notifications include embeds with color-coded status indicators (green for up, red for down).

Custom Webhooks

For maximum flexibility, you can use generic webhooks to integrate with any service. Uptime Kuma sends a JSON payload with monitor details, status, and response time. This lets you integrate with your own scripts, APIs, or automation platforms like n8n and Home Assistant.

Creating Public Status Pages

Status pages let your users check the current status of your services without contacting support. Uptime Kuma's built-in status page feature is completely free and highly customizable.

Create Status Page

→

Add Monitor Groups

→

Assign Monitors

→

Customize Branding

→

Share URL

You can create multiple status pages for different audiences. For example, one page for customers showing your web services, and another internal page for your team showing all infrastructure monitors. Each page gets its own URL and can be customized with your logo, description, and color scheme.

Maintenance Windows

Scheduled maintenance is a reality of server management. Uptime Kuma lets you define maintenance windows so that expected downtime doesn't trigger false alerts or affect your uptime statistics.

Maintenance window features: You can set one-time or recurring maintenance windows, apply them to specific monitors or monitor groups, add a title and description, and they automatically appear on your status pages so users know the downtime is planned.

Setting Up a Reverse Proxy with SSL

Running Uptime Kuma directly on port 3001 works for testing, but for production, you should put it behind a reverse proxy with SSL. Here's a sample Nginx configuration:

# /etc/nginx/sites-available/uptime-kuma
server {
  listen 443 ssl http2;
  server_name status.example.com;

  ssl_certificate /etc/letsencrypt/live/status.example.com/fullchain.pem;
  ssl_certificate_key /etc/letsencrypt/live/status.example.com/privkey.pem;

  location / {
    proxy_pass http://127.0.0.1:3001;
    proxy_http_version 1.1;
    proxy_set_header Upgrade $http_upgrade;
    proxy_set_header Connection "upgrade";
    proxy_set_header Host $host;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header X-Forwarded-Proto $scheme;
  }
}

Important: The proxy_set_header Upgrade and Connection "upgrade" lines are critical. Uptime Kuma uses WebSockets for real-time updates. Without these headers, the dashboard will appear to load but monitors won't update in real-time.

Multi-User Support and Security

Uptime Kuma supports multiple user accounts with different permissions. This is useful when you want your team members to view monitor status without being able to modify configurations.

Create separate accounts for team members with view-only or admin access
Enable two-factor authentication (2FA/TOTP) for all admin accounts
API keys for programmatic access to monitors and status pages
Session management with configurable timeout periods

Performance and Resource Usage

One of the standout qualities of Uptime Kuma is its incredibly low resource footprint. Here's what to expect:

~150MB

RAM Usage (50 monitors)

<1%

CPU Usage (idle)

~100MB

Disk Space (initial)

20sec

Minimum Check Interval

Even with 200+ monitors running at 60-second intervals, Uptime Kuma typically uses less than 300MB of RAM and barely touches the CPU. The SQLite database grows slowly over time as historical data accumulates, but you can configure data retention to keep disk usage in check.

Advanced Configuration Tips

Monitor Groups and Tags

Organize your monitors into logical groups: "Production Sites", "Staging Environments", "APIs", "Infrastructure". Use tags to add metadata like team ownership, priority level, or technology stack. Groups and tags make it easy to filter and manage monitors at scale.

Certificate Expiry Monitoring

Uptime Kuma automatically tracks SSL certificate expiry for all HTTPS monitors. You can configure alerts at custom thresholds, such as 30 days, 14 days, and 7 days before expiration. No more surprise certificate expirations.

Docker Socket Integration

If you run Docker containers, Uptime Kuma can monitor container status directly through the Docker socket. Map the Docker socket into the container:

$ docker run -d \
  --name uptime-kuma \
  --restart=unless-stopped \
  -p 3001:3001 \
  -v uptime-kuma:/app/data \
  -v /var/run/docker.sock:/var/run/docker.sock:ro \
  louislam/uptime-kuma:1

Then create a "Docker Container" monitor type and select which containers to watch. You'll be alerted if any container stops, restarts unexpectedly, or enters an unhealthy state.

Backup and Restore

Uptime Kuma stores all data in a SQLite database at /app/data/kuma.db. To back up your monitoring configuration, simply copy this file. You can automate backups with a cron job:

$ crontab -e
# Daily backup at 3 AM
0 3 * * * docker cp uptime-kuma:/app/data/kuma.db /backups/kuma-$(date +\%Y\%m\%d).db

Deploying on Panelica

If you're running a Panelica server, deploying Uptime Kuma is even easier. Panelica's built-in Docker management lets you deploy containers directly from the panel GUI.

Open your Panelica panel and navigate to Docker → Containers

Create a new container using the louislam/uptime-kuma:1 image with port mapping 3001:3001 and a persistent volume for /app/data

Set up a domain in Panelica (e.g., status.yourdomain.com) with a reverse proxy pointing to port 3001. Panelica automatically generates the optimized Nginx configuration

Enable SSL through Panelica's one-click Let's Encrypt integration for automatic certificate issuance and renewal

Bonus: Panelica also provides its own built-in monitoring dashboard for server resources like CPU, memory, disk, and network traffic. Combine Panelica's server monitoring with Uptime Kuma's service monitoring for complete infrastructure visibility.

Common Use Cases

Web Agency

Monitor all client websites from a single dashboard. Create separate status pages for each client. Alert the right team member based on which site goes down using targeted notification channels.

SaaS Company

Monitor your API endpoints, background job processors, database connections, and third-party service dependencies. Publish a public status page at status.yourapp.com to build trust with customers.

Home Lab

Keep tabs on your self-hosted services: Nextcloud, Jellyfin, Home Assistant, Pi-hole, and more. Get Telegram alerts on your phone when any service goes offline.

DevOps Team

Monitor staging and production environments, CI/CD pipelines, container orchestration health, and DNS resolution. Integrate with Slack for team-wide visibility into infrastructure status.

Troubleshooting Common Issues

WebSocket connection failed: If the dashboard loads but monitors don't update in real-time, your reverse proxy is not forwarding WebSocket connections. Ensure you have proxy_set_header Upgrade $http_upgrade and proxy_set_header Connection "upgrade" in your Nginx configuration.

High memory usage with many monitors: If you're running 500+ monitors, consider increasing the Node.js heap size with the NODE_OPTIONS=--max-old-space-size=2048 environment variable. Also configure data retention to purge old heartbeat data periodically.

Container won't start after update: If Uptime Kuma fails to start after updating the Docker image, the database might need migration. Check the container logs with docker logs uptime-kuma. Usually, restarting the container a second time resolves the issue as the migration completes.

Conclusion

Uptime Kuma transforms website monitoring from an expensive subscription service into a lightweight, self-hosted tool that you control completely. With its beautiful interface, extensive notification options, and minimal resource requirements, there's no reason to pay for basic uptime monitoring anymore.

The setup takes less than five minutes with Docker, and the ongoing maintenance is essentially zero. Whether you're monitoring a single personal blog or hundreds of client websites, Uptime Kuma scales gracefully while keeping your monitoring data private and your wallet intact.

Deploy it on a Panelica server for the smoothest experience: Docker management through the panel, automatic reverse proxy configuration, and free SSL certificates. Combined with Panelica's built-in server resource monitoring, you'll have complete visibility into both your server health and your website availability from a single infrastructure.