Monitoring Changedetection.io with Vigilmon: Service Health, Web UI, Notification Workers & SSL Alerts

Changedetection.io is the self-hosted web page change detection service that teams and individuals use to track price changes, content updates, regulatory notices, competitor announcements, and any web content that needs to be watched automatically. It runs as a Python/Flask application backed by a local data store, with background workers that periodically fetch watched URLs and trigger notifications through email, Slack, webhooks, and dozens of other channels. When Changedetection.io goes down, all monitored pages stop being checked — and changes that occur during the outage are missed entirely. Vigilmon gives you external visibility into Changedetection.io's service health, web UI availability, notification worker signals, and SSL certificate so you know the moment your change-detection service itself goes offline.

What You'll Build

• An HTTP monitor for Changedetection.io web UI availability
• A liveness check on the service health endpoint
• SSL certificate monitoring for your Changedetection.io domain

Prerequisites

• A running Changedetection.io instance with a public or network-reachable domain
• HTTPS configured via a reverse proxy (e.g., https://changes.example.com)
• A free account at vigilmon.online

Step 1: Verify Changedetection.io Web UI Availability

Changedetection.io serves its dashboard from the root path. A successful response confirms the Flask application is running and the reverse proxy is routing correctly:

curl -I https://changes.example.com
# Expected: HTTP/2 200

The root path returns the watched-pages dashboard. A 200 response confirms the Python application is running and able to serve the UI. This is your primary availability signal — if it fails, no watched pages are being checked and no notifications are being sent.

Step 2: Create a Vigilmon HTTP Monitor for Web UI Availability

1. Log in to Vigilmon → Add Monitor → HTTP.
2. URL: https://changes.example.com.
3. Check interval: 60 seconds.
4. Response timeout: 10 seconds.
5. Expected status: 200.
6. Keyword: Changedetection.
7. Label: Changedetection.io Web UI.
8. Click Save.

This monitor catches:

• Flask application process crashes or container restarts
• Data store corruption that prevents the application from starting
• Reverse proxy misconfigurations that block traffic from reaching the service
• Out-of-memory kills (large watch lists with screenshot capture can be memory-intensive)
• Configuration errors after upgrades that prevent the service from starting

When this monitor fires, all URL-watching activity has stopped. Any changes that occur on monitored pages during the outage will be missed.

Step 3: Monitor the Service Health Endpoint

Changedetection.io exposes a health endpoint that confirms the application is running and operational:

curl https://changes.example.com/healthcheck
# Expected: HTTP 200

A typical response:

ok

This confirms the Flask process is running and responding to requests.

1. Add Monitor → HTTP.
2. URL: https://changes.example.com/healthcheck.
3. Check interval: 2 minutes.
4. Expected status: 200.
5. Keyword: ok.
6. Label: Changedetection.io Health.
7. Click Save.

Why monitor the health endpoint separately from the web UI? The root dashboard path renders your full watch list, which involves reading the data store and templating a response. The /healthcheck endpoint is a lightweight probe that confirms just the application is alive. If the data store becomes corrupted or very large watch lists cause template rendering to time out, the health check will still respond while the dashboard times out — giving you a signal to distinguish application health from data layer health.

Step 4: Monitor Notification Workers

Changedetection.io's background worker processes are what actually fetch monitored URLs at their configured intervals and trigger notifications when changes are detected. A worker stall — caused by a hung network request, browser automation timeout, or resource exhaustion — means pages stop being checked silently. The web UI may still load and look healthy while detection has completely stopped.

Use Vigilmon's cron heartbeat monitor to verify the detection loop is running:

1. In Changedetection.io, set up a test URL (e.g., a page you control that you can update manually) with a very short check interval.
2. Add an outgoing notification webhook to that watch entry that pings your Vigilmon heartbeat URL:

In Changedetection.io's notification settings:

https://vigilmon.online/heartbeat/YOUR_HEARTBEAT_URL

3. In Vigilmon, click Add Monitor → Cron Heartbeat.
4. Set the expected interval to match the test URL's check interval (e.g., every 10 minutes).

When the background worker is running and fetching URLs normally, your test URL will be checked at its interval and the heartbeat URL will be pinged as part of notifications. If the worker stalls or the detection loop hangs, the heartbeat stops arriving and Vigilmon alerts you.

Step 5: Monitor SSL Certificates

Changedetection.io handles sensitive monitoring tasks — tracking regulatory pages, competitive intelligence, and time-sensitive content changes. A certificate expiry breaks access for all configured integrations:

• Browser access fails with certificate error pages
• API-based notification consumers stop receiving delivery
• Any external services polling the Changedetection.io API for status break

1. Add Monitor → SSL Certificate.
2. Domain: changes.example.com.
3. Alert when expiry is within: 30 days.
4. Alert again: 14 days, 7 days, 3 days, 1 day.
5. Click Save.

Step 6: Configure Alerting

In Vigilmon under Settings → Notifications, configure your alert channels:

| Monitor | Trigger | Action | |---|---|---| | Web UI | Non-200 or keyword missing | Check Flask container; inspect application logs; verify data store integrity | | Health Endpoint | Non-200 or keyword missing | Check application process; inspect resource usage; verify container is running | | Worker Heartbeat | Heartbeat missing | Inspect worker logs; check for hung URL fetches; verify browser/Playwright container | | SSL certificate | < 30 days to expiry | Renew certificate; verify Let's Encrypt auto-renewal is configured |

Alert after: 2 consecutive failures for HTTP monitors — this catches real outages within ~2 minutes while filtering transient network blips.

Common Changedetection.io Failure Modes and What Vigilmon Catches

| Scenario | Vigilmon monitor | |---|---| | Flask process crash | Web UI and health monitors fire simultaneously | | Data store corruption | Application fails to start; both HTTP monitors fire | | Worker detection loop hang | Heartbeat monitor fires; web UI remains accessible | | Out-of-memory kill (screenshot capture) | Container restarts; both HTTP monitors fire | | Browser automation container crash | Detection fails for browser-rendered pages; heartbeat stops | | Reverse proxy misconfiguration | Web UI fires; application container remains healthy | | SSL certificate expires | SSL monitor alerts at 30 days; browser access breaks | | Network egress blocked (firewall rule change) | URL fetches fail; detection stops; heartbeat monitor fires | | Disk full (screenshot storage) | Screenshot capture fails; detection may partially degrade |

The entire value of Changedetection.io depends on it running continuously — a service that's offline for a day means a day of undetected changes. Vigilmon watches Changedetection.io's web UI, health endpoint, detection workers, and SSL certificate so you know within 60 seconds when your change-detection service has itself stopped working.

Start monitoring Changedetection.io in under 5 minutes — register free at vigilmon.online.