tutorial

Monitoring AUTOMATIC1111 Stable Diffusion WebUI with Vigilmon

AUTOMATIC1111 SD WebUI runs a local Gradio server with a full REST API — here's how to monitor app availability, the SD API health, generation worker liveness, and SSL certificates with Vigilmon.

AUTOMATIC1111 Stable Diffusion WebUI (also called SD WebUI or A1111) is the most widely-used open-source Stable Diffusion interface — a Python Gradio app that exposes a browser UI for text-to-image generation and a comprehensive REST API for programmatic access. When it's running on a remote server or exposed behind a reverse proxy, you need to know the moment the Gradio server crashes, the SD API goes dark, or a TLS certificate approaches expiry. Vigilmon gives you per-endpoint uptime monitoring, API health checks, generation worker heartbeats, and SSL certificate alerts for every SD WebUI deployment.

What You'll Set Up

  • HTTP uptime monitor for the SD WebUI Gradio interface (port 7860)
  • /internal/ping health endpoint monitor for the FastAPI application layer
  • /sdapi/v1/options REST API monitor confirming a model is loaded
  • SSL certificate expiry alerts for HTTPS-proxied SD WebUI deployments
  • Cron heartbeat for the SD generation worker thread via /sdapi/v1/progress

Prerequisites

  • AUTOMATIC1111 Stable Diffusion WebUI installed and running (default port 7860)
  • Network access to the SD WebUI host from the internet (direct or via reverse proxy)
  • A free Vigilmon account

Step 1: Monitor the SD WebUI Gradio Interface

SD WebUI spawns a Gradio web server on port 7860 by default. A successful 200 response on the root path confirms the Gradio app has loaded and the browser UI is ready for requests.

  1. Log in to vigilmon.online and click Add Monitor.
  2. Set Type to HTTP / HTTPS.
  3. Enter the SD WebUI URL: http://your-server-ip:7860 (or your proxied domain https://sd.yourdomain.com).
  4. Set Check interval to 1 minute.
  5. Set Expected HTTP status to 200.
  6. Click Save.

If you launch SD WebUI with --share, Gradio provides a temporary public URL — but for persistent monitoring, expose the app through a reverse proxy (nginx or Caddy) on a stable domain instead.

Step 2: Monitor the /internal/ping Health Endpoint

SD WebUI exposes a lightweight internal health endpoint at /internal/ping that returns {"status":"ok"} with a 200 status. This endpoint checks the FastAPI application layer running behind Gradio, independently of whether the Gradio UI itself is fully loaded.

  1. Click Add Monitor in Vigilmon.
  2. Set Type to HTTP / HTTPS.
  3. Enter: http://your-server-ip:7860/internal/ping
  4. Set Check interval to 1 minute.
  5. Set Expected HTTP status to 200.
  6. Optionally, set Expected response body contains to "status":"ok" for an additional signal check.
  7. Click Save.

This monitor catches FastAPI startup failures and crashes of the Python application layer even when the Gradio frontend is partially responsive.

Step 3: Monitor the /sdapi/v1/options REST API Endpoint

The SD API /sdapi/v1/options endpoint is the strongest health signal: a 200 response means the full SD API stack is operational and a Stable Diffusion model is loaded into memory. No model loaded equals no valid API response.

  1. Click Add Monitor in Vigilmon.
  2. Set Type to HTTP / HTTPS.
  3. Enter: http://your-server-ip:7860/sdapi/v1/options
  4. Set Method to GET.
  5. Set Check interval to 2 minutes.
  6. Set Expected HTTP status to 200.
  7. Click Save.

If SD WebUI is configured with --api flag authentication, add the Authorization: Basic <base64-encoded-credentials> header in the Vigilmon monitor's Custom Headers field.

To confirm SD WebUI has the API enabled, test from the command line:

curl http://your-server-ip:7860/sdapi/v1/options | jq '.sd_model_checkpoint'

A model checkpoint name in the output confirms the API and model are ready.

Step 4: SSL Certificate Alerts for HTTPS Deployments

Many SD WebUI users expose the Gradio interface behind nginx or Caddy with a domain and Let's Encrypt certificate. Silent certificate expiry locks users out of their remote SD WebUI instance.

Add a certificate expiry monitor for your SD WebUI domain:

  1. Open the HTTP monitor for your proxied SD WebUI domain (created in Step 1).
  2. Enable Monitor SSL certificate under the SSL section.
  3. Set Alert when certificate expires in less than 21 days.
  4. Click Save.

A sample nginx reverse proxy configuration for SD WebUI:

server {
    listen 443 ssl;
    server_name sd.yourdomain.com;

    ssl_certificate /etc/letsencrypt/live/sd.yourdomain.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/sd.yourdomain.com/privkey.pem;

    location / {
        proxy_pass http://127.0.0.1:7860;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_read_timeout 600s;
    }
}

Note the extended proxy_read_timeout — SD WebUI generation requests can take minutes for complex prompts and high-resolution outputs.

Step 5: Heartbeat Monitoring for the Generation Worker

SD WebUI's image generation runs on a background worker thread. Even when the Gradio UI and API endpoints respond, the generation pipeline can stall due to VRAM exhaustion, a hung model load, or a corrupted sampler state. The /sdapi/v1/progress endpoint returns the worker's current state.

Set up a cron heartbeat to periodically verify the generation worker is alive:

  1. In Vigilmon, click Add Monitor → Cron Heartbeat.
  2. Set the expected ping interval to 10 minutes.
  3. Copy the heartbeat URL (e.g. https://vigilmon.online/heartbeat/abc123).

Then add a script that polls /sdapi/v1/progress and pings the heartbeat URL when the worker responds as idle or in-progress (any valid JSON response means the worker thread is alive):

#!/bin/bash
# sd-webui-heartbeat.sh — run via cron every 10 minutes

SDAPI="http://127.0.0.1:7860/sdapi/v1/progress"
HEARTBEAT="https://vigilmon.online/heartbeat/abc123"

response=$(curl -sf --max-time 10 "$SDAPI")
if [ $? -eq 0 ] && echo "$response" | grep -q '"progress"'; then
    curl -sf "$HEARTBEAT" > /dev/null
fi

Add to crontab:

*/10 * * * * /path/to/sd-webui-heartbeat.sh

A JSON response from /sdapi/v1/progress confirms the generation worker thread is alive and the task queue is ready to accept new jobs. If the worker crashes, the endpoint stops responding and Vigilmon alerts after the expected 10-minute interval passes.

Step 6: Configure Alert Channels

  1. Go to Alert Channels in Vigilmon and add Slack, email, or a webhook.
  2. Set Consecutive failures before alert to 2 on the Gradio interface monitor — model loading at startup can take 30–120 seconds depending on the checkpoint size, so allow one failure before alerting.
  3. On the /sdapi/v1/options monitor, set Consecutive failures to 1 — if the model API is down while Gradio is up, that's always a critical signal worth immediate attention.

Summary

| Monitor | Target | What It Catches | |---|---|---| | Gradio interface | http://host:7860/ | Gradio server crash, Python process death | | FastAPI layer | http://host:7860/internal/ping | FastAPI startup failure, app layer crash | | SD API + model | http://host:7860/sdapi/v1/options | Model load failure, SD API not enabled | | SSL certificate | HTTPS proxied domain | Let's Encrypt renewal failure | | Worker heartbeat | /sdapi/v1/progress cron | Generation worker stall, VRAM OOM crash |

AUTOMATIC1111 SD WebUI gives you complete control over Stable Diffusion inference — but that control means you own the availability too. With Vigilmon watching the Gradio app, the SD API stack, the generation worker thread, and your SSL certificates, you get the observability layer your self-hosted AI image generation server needs.

Monitor your app with Vigilmon

Free plan — 5 monitors, no credit card required. Up and running in 60 seconds.

Start free →
← Back to all articles