How to Self-Host Uptime Kuma: Free Server and Website Monitoring

How to Self-Host Uptime Kuma: Free Server and Website Monitoring

Learn how to self-host Uptime Kuma, a beautiful open-source monitoring tool for your servers and websites. Complete Docker setup guide with best practices.

#self-hosting #docker #tutorials #monitoring #vps

Server downtime is expensive. Whether you’re running a personal blog, a side project, or a business-critical application, you need to know the moment something goes wrong — not hours later when users start complaining.

Most monitoring services charge $10-50/month per monitored endpoint. For self-hosters managing multiple services, those costs add up fast. That’s where Uptime Kuma comes in: a beautiful, open-source monitoring solution you can host yourself for the cost of server resources you’re already using.

In this guide, you’ll learn how to deploy Uptime Kuma using Docker, configure monitoring for your services, and set up intelligent alerts that notify you the moment something breaks.

What is Uptime Kuma?

Uptime Kuma is a self-hosted monitoring tool that checks if your websites, APIs, and servers are online and responding correctly. Think of it as a self-hosted alternative to services like UptimeRobot, Pingdom, or StatusCake.

Key features:

  • Multiple monitor types: HTTP(s), TCP, DNS, ping, Docker containers, and more
  • Beautiful dashboard: Real-time status overview with historical uptime graphs
  • Multi-channel notifications: Email, Discord, Slack, Telegram, Pushover, and 90+ integrations
  • Status pages: Public or private status pages for your services
  • Certificate monitoring: Get alerted before SSL certificates expire
  • Keyword monitoring: Verify that specific content appears on your pages
  • Authentication: Protect your dashboard with user accounts
  • Lightweight: Runs efficiently on minimal resources

Unlike heavyweight enterprise monitoring solutions, Uptime Kuma is designed for simplicity. You can have it running and monitoring your first service in under 10 minutes.

Why Self-Host Your Monitoring?

Self-hosting your monitoring might seem counterintuitive — what if your monitoring server goes down? — but it offers several advantages:

1. No monthly fees: Commercial monitoring services charge per check or endpoint. Self-hosting eliminates recurring costs.

2. Unlimited monitors: Check as many services as you want without hitting plan limits.

3. Data privacy: Your uptime data and service URLs stay on your infrastructure.

4. Internal service monitoring: Monitor services on private networks without exposing them to third-party monitoring.

5. Customization: Full control over check intervals, alerting logic, and integrations.

About the “monitoring the monitor” problem: The smart approach is to monitor Uptime Kuma itself using a free tier of a commercial service like UptimeRobot (50 monitors free) or a simple external cron job. We’ll cover this later in the guide.

Prerequisites

Before we begin, you’ll need:

  • A Linux server (VPS or dedicated) running Docker
  • Basic command-line familiarity
  • A domain name (optional, but recommended for SSL)
  • 1GB RAM minimum (2GB recommended)
  • Docker and Docker Compose installed

Don’t have a VPS yet? Here are solid options for hosting Uptime Kuma:

  • Hetzner Cloud: €4.15/month for 2GB RAM (excellent European network)
  • DigitalOcean: $6/month for 1GB RAM (beginner-friendly)
  • Vultr: $6/month for 1GB RAM (25+ global locations)
  • Hostinger VPS: $5.99/month for 2GB RAM (good value)

A basic shared VPS is perfect for Uptime Kuma since monitoring traffic is minimal. You can easily run it alongside other self-hosted apps.

Step 1: Prepare Your Server

First, ensure your server is up to date and Docker is installed:

# Update system packages
sudo apt update && sudo apt upgrade -y

# Verify Docker is installed
docker --version

# If Docker isn't installed, install it
curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh

# Add your user to the docker group (optional, avoids using sudo)
sudo usermod -aG docker $USER
newgrp docker

Create a directory for Uptime Kuma:

mkdir -p ~/uptime-kuma
cd ~/uptime-kuma

Step 2: Create Docker Compose Configuration

Create a docker-compose.yml file:

version: '3.8'

services:
  uptime-kuma:
    image: louislam/uptime-kuma:1
    container_name: uptime-kuma
    volumes:
      - ./data:/app/data
    ports:
      - "3001:3001"
    restart: unless-stopped
    environment:
      - TZ=America/New_York  # Change to your timezone

Configuration notes:

  • Image: Uses the official Uptime Kuma image with version tag 1 for stability
  • Volumes: Persists database and configuration in ./data
  • Ports: Exposes port 3001 (you can change this if needed)
  • Timezone: Set this to your local timezone for accurate timestamps

Step 3: Launch Uptime Kuma

Start the container:

docker compose up -d

Verify it’s running:

docker compose logs -f

You should see output indicating Uptime Kuma has started successfully. Press Ctrl+C to exit the logs.

Check the container status:

docker compose ps

Step 4: Access the Dashboard

Uptime Kuma is now running on port 3001. Access it via:

http://YOUR_SERVER_IP:3001

First-time setup:

  1. You’ll see a welcome screen asking you to create an admin account
  2. Enter a username and strong password
  3. Click “Create” — you’re now logged in to your Uptime Kuma dashboard

Important: There’s no default password. The first person to access Uptime Kuma creates the admin account, so make sure you do this immediately after deployment.

Running Uptime Kuma on a random port without SSL is fine for testing, but for production use, you should:

  1. Put it behind a reverse proxy
  2. Use a proper domain name
  3. Enable HTTPS with a valid SSL certificate

Option A: Nginx Proxy Manager (Easiest)

If you’re already using Nginx Proxy Manager, add a new proxy host:

  1. Go to Nginx Proxy Manager → Hosts → Proxy Hosts → Add Proxy Host
  2. Domain Names: uptime.yourdomain.com
  3. Scheme: http
  4. Forward Hostname/IP: uptime-kuma (container name) or your server IP
  5. Forward Port: 3001
  6. Enable SSL tab → Request a new certificate with Let’s Encrypt
  7. Save

Update your docker-compose.yml to remove the ports section and connect both containers to the same network:

version: '3.8'

services:
  uptime-kuma:
    image: louislam/uptime-kuma:1
    container_name: uptime-kuma
    volumes:
      - ./data:/app/data
    networks:
      - proxy
    restart: unless-stopped
    environment:
      - TZ=America/New_York

networks:
  proxy:
    external: true

Make sure the proxy network exists (created by Nginx Proxy Manager).

Option B: Traefik

If you’re using Traefik, add labels to your service:

version: '3.8'

services:
  uptime-kuma:
    image: louislam/uptime-kuma:1
    container_name: uptime-kuma
    volumes:
      - ./data:/app/data
    networks:
      - traefik
    restart: unless-stopped
    environment:
      - TZ=America/New_York
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.uptime-kuma.rule=Host(`uptime.yourdomain.com`)"
      - "traefik.http.routers.uptime-kuma.entrypoints=websecure"
      - "traefik.http.routers.uptime-kuma.tls.certresolver=letsencrypt"
      - "traefik.http.services.uptime-kuma.loadbalancer.server.port=3001"

networks:
  traefik:
    external: true

After updating your configuration, restart the container:

docker compose down
docker compose up -d

You can now access Uptime Kuma securely at https://uptime.yourdomain.com.

Step 6: Create Your First Monitor

Let’s set up monitoring for a website:

  1. Click “Add New Monitor” in the dashboard
  2. Monitor Type: HTTP(s)
  3. Friendly Name: “Personal Blog”
  4. URL: https://yourblog.com
  5. Heartbeat Interval: 60 seconds (how often to check)
  6. Retries: 3 (failures before marking as down)
  7. Request Timeout: 48 seconds
  8. Click Save

Uptime Kuma will immediately start monitoring your site. You’ll see:

  • Current status (online/offline)
  • Response time graph
  • Uptime percentage
  • Certificate expiration date (for HTTPS sites)

Monitor Types Explained

Uptime Kuma supports several monitor types:

HTTP(s): Check if a website is online and returns a 2xx status code

  • Best for: Websites, web apps, APIs
  • Can verify specific keywords are present
  • Monitors SSL certificate expiration

TCP Port: Check if a specific port is open and accepting connections

  • Best for: SSH, databases, game servers
  • Simple connection test, no protocol parsing

Ping: ICMP ping to verify server is reachable

  • Best for: Basic server availability
  • Doesn’t verify specific services are working

DNS: Verify DNS records resolve correctly

  • Best for: Detecting DNS issues before they affect users
  • Can check specific record types (A, AAAA, CNAME, etc.)

Docker Container: Monitor Docker container status on the same host

  • Best for: Ensuring critical containers stay running
  • Requires mounting Docker socket

Push: Passive monitoring where your app sends heartbeats

  • Best for: Cron jobs, scheduled tasks
  • Service pushes to a unique URL when it runs

Step 7: Configure Notifications

Monitoring without notifications is useless — you need to know when something breaks. Uptime Kuma supports 90+ notification channels.

Setting Up Email Notifications

  1. Click Settings (top right)
  2. Go to Notifications
  3. Click Setup Notification
  4. Notification Type: Email (SMTP)
  5. Friendly Name: “Email Alerts”
  6. Fill in your SMTP settings:
    • Hostname: smtp.gmail.com (for Gmail)
    • Port: 587
    • TLS: Enabled
    • Username: [email protected]
    • Password: your app password (not your regular password)
    • From Email: [email protected]
    • To Email: where to receive alerts
  7. Click Test to verify it works
  8. Apply on all existing monitors (optional)
  9. Click Save

Gmail app password: If using Gmail, you need to create an app-specific password at https://myaccount.google.com/apppasswords (requires 2FA enabled).

Setting Up Discord Notifications

Discord is popular among self-hosters for quick mobile notifications:

  1. In Discord, go to Server Settings → Integrations → Webhooks
  2. Click New Webhook
  3. Name it “Uptime Kuma”
  4. Choose a channel
  5. Copy the webhook URL
  6. In Uptime Kuma, add a new notification:
    • Type: Discord
    • Friendly Name: “Discord Alerts”
    • Discord Webhook URL: paste your webhook URL
    • Test and save

Now you’ll get instant Discord messages when services go down or come back online.

  • Telegram: Fast mobile notifications with inline status
  • Slack: Great for team environments
  • Pushover: Reliable push notifications with priority levels
  • Gotify: Self-hosted push notifications
  • Home Assistant: Integration with smart home automations
  • PagerDuty: For on-call rotations and escalation

You can configure multiple notification channels and choose which monitors use which notifications.

Step 8: Create a Status Page (Optional)

Uptime Kuma includes a status page feature — a public page showing the status of your services. Perfect for letting users check if issues are on their end or yours.

  1. Click Status Pages in the left sidebar
  2. Click Add New Status Page
  3. Configure:
    • Title: “Service Status”
    • Description: Optional description
    • Slug: status (creates URL /status/status)
    • Theme: Choose light or dark
    • Published: Enable to make it public
  4. Add a Group:
    • Click Add Group
    • Name it “Core Services”
    • Drag monitors into the group
  5. Click Save

Your status page is now live at:

https://uptime.yourdomain.com/status/status

You can customize the theme, add your logo, and organize monitors into logical groups. Status pages can be public (anyone can view) or password-protected.

Step 9: Advanced Configuration

Certificate Expiration Monitoring

Uptime Kuma automatically monitors SSL certificate expiration for HTTPS monitors. To get alerts before certificates expire:

  1. Edit an HTTPS monitor
  2. Scroll to Certificate Expiry Notification
  3. Set Days Before Expiry: 14 (alerts 14 days before expiration)
  4. Select which notifications to trigger
  5. Save

You’ll get early warnings to renew Let’s Encrypt certificates or address certificate issues.

Keyword Monitoring

Verify that your website isn’t showing error messages:

  1. Edit a monitor
  2. Enable Keyword
  3. Enter a keyword that should appear (e.g., “Welcome”)
  4. Keyword Type: “Exists” (fails if keyword is missing)
  5. Save

This catches scenarios where your site returns HTTP 200 but shows an error page.

Custom HTTP Headers

For monitoring authenticated endpoints:

  1. Edit an HTTP(s) monitor
  2. Expand Advanced
  3. Add headers: 
    Authorization: Bearer your-token
  4. Save

Useful for monitoring APIs that require authentication.

Monitoring Internal Services

To monitor services on the same host (databases, internal APIs):

  1. Use host.docker.internal as the hostname (on Docker Desktop)
  2. Or use the container name if both are on the same Docker network
  3. For monitoring the Docker host’s services, use the host’s private IP

Example monitoring a database container:

  • Type: TCP Port
  • Hostname: postgres (container name)
  • Port: 5432

Step 10: Maintenance and Best Practices

Regular Backups

Uptime Kuma stores all data in /app/data inside the container (mapped to ./data on your host). Back up this directory regularly:

# Simple backup
tar -czf uptime-kuma-backup-$(date +%Y%m%d).tar.gz ./data

# Automated daily backup (add to cron)
0 2 * * * cd ~/uptime-kuma && tar -czf /backups/uptime-kuma-$(date +\%Y\%m\%d).tar.gz ./data

For production environments, check out our guide on backing up self-hosted apps.

Update Regularly

Uptime Kuma is actively developed with frequent updates:

cd ~/uptime-kuma
docker compose pull
docker compose up -d

The uptime-kuma:1 tag automatically pulls the latest stable version in the v1 series, balancing stability with updates.

Monitor the Monitor

The irony of self-hosted monitoring: what monitors the monitor? Here are strategies:

Option 1: External free tier

  • Use UptimeRobot free tier (50 monitors) to check your Uptime Kuma dashboard
  • Configure it to ping https://uptime.yourdomain.com every 5 minutes

Option 2: Push monitoring

  • Create a push monitor in Uptime Kuma
  • Set up a cron job on a different server/service to ping it
  • If Uptime Kuma is down, the push monitor will show as down

Option 3: Multi-region deployment

  • Run Uptime Kuma instances in different regions
  • Have them monitor each other
  • At least one should alert you if others fail

Option 4: Health check service

  • Use Healthchecks.io (free tier available)
  • Configure a cron job that pings Healthchecks after successfully reaching Uptime Kuma

Resource Management

Uptime Kuma is lightweight but can consume resources if you monitor hundreds of services:

  • Typical resource usage: 100-300MB RAM for 50-100 monitors
  • Increase check intervals for less critical services (5 minutes instead of 1 minute)
  • Disable historical data retention for less important monitors
  • Use database maintenance to clean old records

Security Considerations

  1. Always use HTTPS — protect your dashboard from MitM attacks
  2. Strong passwords — use a password manager to generate complex credentials
  3. Limit exposure — don’t expose the dashboard publicly if you don’t need to
  4. Regular updates — security fixes are released frequently
  5. Reverse proxy authentication — add an extra auth layer via your reverse proxy

Common Issues and Troubleshooting

Container Won’t Start

Check logs:

docker compose logs -f

Common causes:

  • Port 3001 already in use (change port in docker-compose.yml)
  • Permissions on ./data directory
  • Docker network conflicts

Monitors Always Show as Down

  1. Verify the URL/hostname is correct
  2. Check if your server can reach the target: 
    curl -I https://target-site.com
  3. Increase timeout and retry settings
  4. Check for firewall rules blocking outbound connections

Notifications Not Working

  1. Test the notification from Settings → Notifications
  2. Check spam folders for email notifications
  3. Verify webhook URLs are correct
  4. Some services require IP whitelisting — check your notification provider’s docs

High Memory Usage

If Uptime Kuma uses excessive memory:

  1. Reduce historical data retention
  2. Increase check intervals for less critical monitors
  3. Remove unused monitors
  4. Restart the container to clear memory leaks: 
    docker compose restart

Uptime Kuma vs. Commercial Alternatives

How does self-hosting compare to paid services?

FeatureUptime KumaUptimeRobotPingdom
CostFree (hosting only)Free tier limited$10+/month
MonitorsUnlimited50 free, paid beyond10+ depending on plan
Check interval10 seconds minimum5 minutes (free)1 minute
Notifications90+ integrationsLimited on freeEmail, SMS, webhooks
Status pagesIncludedPaid add-onIncluded
Data ownershipFull controlThird-partyThird-party
Internal monitoringYesNoNo
Setup complexityMediumLowLow

For self-hosters with multiple services, Uptime Kuma becomes cost-effective almost immediately. The tradeoff is managing the infrastructure yourself.

Integrations and Automation

Home Assistant Integration

Monitor your smart home services and trigger automations based on service status:

  1. Add the Uptime Kuma integration in Home Assistant
  2. Configure API access
  3. Create automations (e.g., flash lights red when your NAS goes offline)

Grafana Dashboards

Visualize uptime data in Grafana using the Uptime Kuma JSON API.

API Access

Uptime Kuma has a basic API for programmatic access:

  • Create monitors via API
  • Query current status
  • Integrate with custom tools

API documentation: Check the GitHub repo for current API endpoints and examples.

Should You Self-Host Uptime Kuma?

Self-host if:

  • You have multiple services to monitor and want to avoid per-monitor fees
  • You need to monitor internal/private services
  • You value data privacy and control
  • You’re comfortable managing Docker containers
  • You have a reliable VPS or home server

Use a commercial service if:

  • You only need to monitor 1-3 services (free tiers are fine)
  • You don’t have infrastructure to self-host on
  • You need guaranteed multi-region monitoring from day one
  • You prefer zero maintenance responsibilities

For most self-hosters, Uptime Kuma hits the sweet spot: powerful enough for serious use, simple enough to deploy in minutes.

Next Steps

Now that you have Uptime Kuma running, consider:

  1. Monitor all critical services — start with your most important apps
  2. Set up multiple notification channels — redundancy in alerting is crucial
  3. Create a public status page — build trust with your users
  4. Implement external monitoring — make sure something watches Uptime Kuma itself
  5. Automate backups — protect your monitoring configuration
  6. Review alert fatigue — tune check intervals and retries to avoid false positives

Want to dive deeper into self-hosting? Check out these guides:

Conclusion

Uptime Kuma proves that self-hosted tools can be just as polished and powerful as commercial alternatives — sometimes more so. With minimal server resources, you get unlimited monitoring, beautiful dashboards, flexible alerting, and complete control over your data.

The initial setup takes 10-30 minutes depending on your reverse proxy configuration. After that, Uptime Kuma runs quietly in the background, alerting you only when something needs your attention.

For self-hosters managing multiple services, it’s an essential tool. Instead of discovering problems when users complain, you’ll know within seconds — and often before anyone else notices.

Start monitoring smarter. Self-host Uptime Kuma today.

Stay in the loop 📬

Get self-hosting tutorials, tool reviews, and infrastructure tips delivered to your inbox. No spam, unsubscribe anytime.

Join 0 self-hosters. Free forever.

#self-hosting #docker #tutorials #monitoring #vps