uptime monitoring integrations

Global Uptime Monitoring with Uptime Kuma + NetDiag

Use Uptime Kuma for alerts and UI, NetDiag for multi-region checks with quorum. Stop false alerts caused by single-region monitoring.

5 min read

Most uptime monitoring runs from one server in one region.

That works until it doesn't:

  • your site is up in Europe but down in Asia
  • DNS returns different answers per region
  • a CDN edge is broken
  • TLS handshake fails in one place only
  • your monitor screams while users are fine (or worse: users are not fine and you don't know)

This post shows a setup combining Uptime Kuma for alerts and UI with NetDiag for multi-region checks and quorum logic.

What you'll build

A Kuma monitor that calls NetDiag:

https://api.netdiag.dev/v1/checks?host=aws.amazon.com

NetDiag runs checks from 3 regions, aggregates the result, and returns:

  • status: Healthy
  • quorum.met: true
  • per-region ping / dns / tls / http

Then Kuma evaluates a single JSON value:

  • UP if $.quorum.met == true
  • DOWN if $.quorum.met == false

Why quorum beats single-region monitoring

Single-region monitors answer:

"Can my server reach your app?"

Quorum monitors answer:

"Is your app reachable from most places?"

This matters when the real world is messy:

  • partial outages
  • bad routing
  • DNS propagation differences
  • CDN edge issues
  • region-specific failures
  • flaky upstreams

With quorum you get fewer false positives and better signals during incidents.

Prerequisites

  • A running Uptime Kuma instance (self-hosted or docker)
  • A host/domain you want to monitor
  • NetDiag endpoint (public): https://api.netdiag.dev

Step 1: Create a new monitor

In Uptime Kuma:

  1. Click Add New Monitor
  2. Set Monitor Type to HTTP(s) - JSON Query

Step 2: Configure URL

Use this URL (replace with your domain):

https://api.netdiag.dev/v1/checks?host=example.com

Method: GET

Step 3: Set the JSON Query

In Kuma's JSON Query field, use:

$.quorum.met

Expected value:

true

This makes Kuma treat the monitor as:

  • UP when quorum is met
  • DOWN when quorum is not met

That's all it takes to turn Kuma into a multi-region monitor.

Step 4: Save and test

Click Save.

If everything is healthy you should see:

  • green status
  • response time based on NetDiag total run duration

NetDiag performs multiple checks per region, so response time is usually higher than a simple single ping monitor. That's expected.

Optional configurations

Different teams want different definitions of "truth."

Option A: Monitor overall status string

Instead of quorum, use:

JSON Query:

$.status

Expected Value:

Healthy

Similar to quorum but more high-level.

Option B: Strict mode (fail if any region fails)

If you want "any region unhealthy = alert me":

JSON Query:

$.regions[?(@.status!="Healthy")]

Expected Value:

[]

This means: "there are no unhealthy regions."

Use this if you operate global user traffic and care about any partial outage.

Option C: TLS-only monitoring (cert health)

Monitor TLS validity across regions:

JSON Query:

$.regions[?(@.tls.certificateValid!=true)]

Expected Value:

[]

If any region reports TLS invalid, Kuma marks DOWN.

Option D: HTTP status must be 200 in all regions

JSON Query:

$.regions[?(@.http.statusCode!=200)]

Expected Value:

[]

Simple and effective for web apps.

Notifications

Uptime Kuma handles alerting. It supports:

  • Telegram
  • Slack
  • Discord
  • Email
  • Webhooks
  • and many more

NetDiag focuses on signal quality. Kuma handles alert delivery.

Troubleshooting

Kuma shows DOWN but the site is up for you

That's often the point.

Common causes:

  • DNS answers differ per region
  • one CDN PoP is broken
  • region-specific routing issues
  • upstream service outage (partial)

Check NetDiag response details:

  • observations[] for warnings like DNS mismatch
  • regions[] for which region failed and why

Kuma says JSON Query failed

That usually means:

  • the API returned HTML or an error response
  • you hit a rate limit
  • transient network issues

Open the monitor's Logs, view the raw response and confirm you can see:

"quorum": { "met": true }

Example: What NetDiag returns

Shortened example of important fields:

{
  "host": "example.com",
  "status": "Healthy",
  "quorum": { "required": 2, "total": 3, "met": true },
  "durationMs": 1258,
  "observations": [
    {
      "code": "DNS_ANSWERS_MISMATCH",
      "severity": "warning",
      "message": "DNS resolution differs across regions"
    }
  ],
  "regions": [
    {
      "region": "ap-southeast",
      "status": "Healthy",
      "tls": { "certificateValid": true, "daysUntilExpiry": 270 },
      "http": { "statusCode": 200 }
    }
  ]
}

Uptime Kuma only needs one value: $.quorum.met == true

When this setup works well

This is ideal if you:

  • run a global product (users on multiple continents)
  • use a CDN and want to detect regional issues
  • want fewer false alarms
  • want real incident signals, not "my VPS can ping you"

Summary

Uptime Kuma handles notifications and dashboards.

NetDiag handles multi-region diagnostics and quorum signals.

Together:

  • global truth
  • clean alerts
  • no new monitoring UI to build
  • no custom alerting system to maintain

Related articles