By Monitive · 15 years in monitoring

API-first uptime monitoring for deploy pipelines, developers, and AI agents.

Create monitors with a curl call, an MCP prompt, or a GitHub Action. Get cross-region confirmation, evidence-rich incidents, and zero email overhead.

Get your API key Read quickstart View examples

Up to 50 monitors free Up to 100 during extended free tier 22 probe locations Browser push + webhooks + RSS No email required

curl -X POST https://api.uptimemonitoring.com/api/v1/monitors \
  -H "Authorization: Bearer umk_live_..." \
  -H "Content-Type: application/json" \
  -d '{
    "name": "myapp-healthz",
    "url": "https://myapp.com/healthz",
    "type": "http",
    "expected_status": "200"
  }'

{
  "monitor": {
    "id": 1287,
    "name": "myapp-healthz",
    "url": "https://myapp.com/healthz",
    "type": "http",
    "interval_sec": 60,
    "expected_status": "200",
    "enabled": true
  },
  "state": {
    "status": "up",
    "last_check_at": "2026-04-12T14:23:01Z",
    "evidence_buffer": [
      { "region": "EU", "status_code": 200, "ttfb_ms": 182 }
    ]
  }
}

15 years of monitoring infrastructure ·

22 global probe locations ·

Cross-region confirmation on every failure ·

Evidence buffer included with every incident ·

GitHub OAuth + API key in minutes

Use the surface you already work in.

Same backend. Same monitor state. Different ways to drive it.

Create and manage monitors from scripts, apps, or CI.

bash

curl -X POST https://api.uptimemonitoring.com/api/v1/monitors \
  -H "Authorization: Bearer $UPTIMEMONITORING_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "api-prod",
    "url": "https://api.example.com/healthz",
    "type": "http"
  }'

Let Claude, ChatGPT, or Cursor create, inspect, and assert monitor health for you.

text

User:
Create a 60-second monitor for https://api.example.com/healthz
and tell me if it is healthy right now.

Tool:
create_monitor

Result:
Monitor created: api-prod
Current status: up
Last evidence: EU · 200 · ttfb 184ms

Built for your workflow

Pick the surface that fits how you ship.

Fail deploys when your site is down

Use a GitHub Action to assert your deploy is reachable from 22 probe locations before traffic switches over.

Let your Claude agent monitor its own deployments

Add the UptimeMonitoring MCP server to Claude Code so your agent can create monitors, check status, and react to failures.

Uptime monitoring from inside Cursor

Configure UptimeMonitoring as an MCP server in Cursor and manage monitors from the agent panel.

Monitor any API with 50 free checks

Create monitors via the REST API with a single POST request — no dashboard required.

What happens when something breaks

We do not flip red on the first blip.

Create

You create a monitor through the API, MCP, or GitHub Action.

Test immediately

We run an immediate test check so typos and unreachable targets fail fast.

Check on schedule

Checks are spread across the minute to keep load stable.

Re-check failures

Infrastructure-class failures are confirmed from two additional regions before we flip state.

Deliver evidence

We store the incident with evidence and send it where you want it: webhook, browser push, RSS, or MCP pull.

check log

US-W ● 200 05:37:41 ← healthy

US-W ✗ dns 05:38:42 ← first failure

EU ✗ dns 05:38:44 ← recheck #1

US-E ✗ dns 05:38:46 ← recheck #2

→ incident created

Evidence, not just red dots

See what happened before the incident: DNS, TLS, timeout, 5xx, region, and timing breakdowns.

Last 20 checks included
Timing breakdowns per check
Region-aware evidence
Designed for debugging, not dashboards

incident evidence

{
  "id": 194,
  "type": "down",
  "monitor_id": 1287,
  "started_at": "2026-04-18T05:38:52Z",
  "resolved_at": "2026-04-18T05:45:44Z",
  "evidence": [
    {
      "region": "US-W",
      "timestamp": "2026-04-18T05:37:41Z",
      "status_code": 200,
      "dns_ms": 6.8,
      "tls_ms": 298,
      "connect_ms": 149,
      "ttfb_ms": 203
    },
    {
      "region": "US-W",
      "timestamp": "2026-04-18T05:38:42Z",
      "error_class": "dns"
    }
  ]
}

Webhooks for systems. Push for humans. MCP for agents.

No inbox spam. No deliverability headaches. You choose the channel.

Webhooks

For Slack, Twilio, Discord, ntfy, GitHub Actions, or your own router.

PUT /api/v1/monitors/1287/webhook
{ "url": "https://hooks.co/inc" }

Browser push

One-click opt-in from the dashboard. Fastest human fallback.

Enable notifications
Chrome on macOS · Active

RSS / incident feed

Subscribe from Slack, readers, or automation tools.

https://api.uptimemonitoring.com
  /feed/{token}/rss

MCP pull

Ask your agent for monitor state and recent incidents directly.

Tool: list_incidents
Filter: last 24h, status: open
Result: 1 incident, myapp-healthz

Validate the things that actually break

HTTP / HTTPS

Status codes, body match, timing evidence

Service ports

TCP checks for common service ports

Reachability

ICMP ping

DNS

Record presence and value checks

SSL

Certificate expiry monitoring

Timing evidence

DNS, connect, TLS, TTFB, download

Copy a working example

Start from a real recipe, not a blank page.

curl

Create a monitor from any terminal

curl -X POST https://api.uptimemonitoring.com/api/v1/monitors \
  -H "Authorization: Bearer $UPTIMEMONITORING_API_KEY" \
  -d '{"url":"https://api.example.com/healthz","type":"http"}'

Open example →

Node

Add monitoring to a deploy script

const res = await fetch(
  "https://api.uptimemonitoring.com/api/v1/monitors",
  {
    method: "POST",
    headers: { Authorization: `Bearer ${process.env.UPTIMEMONITORING_API_KEY}` },
    body: JSON.stringify({ url: "https://api.example.com/healthz", type: "http" })
  }
)

Open example →

Python

Automate from scripts or notebooks

import requests
requests.post(
    "https://api.uptimemonitoring.com/api/v1/monitors",
    headers={"Authorization": f"Bearer {api_key}"},
    json={"url": "https://api.example.com/healthz", "type": "http"}
)

Open example →

Claude

Natural language monitor management

Add UptimeMonitoring as an MCP server
Create a monitor for https://api.example.com/healthz
Assert that it is healthy after deploy

Open example →

Cursor

Monitor from your IDE

// In .cursor/mcp.json:
{
  "mcpServers": {
    "uptimemonitoring": {
      "url": "https://api.uptimemonitoring.com/mcp",
      "headers": {
        "Authorization": "Bearer umk_live_..."
      }
    }
  }
}

Open example →

Webhook recipes

Route incidents to any system

PUT /api/v1/monitors/1287/webhook
{
  "url": "https://hooks.slack.com/services/..."
}

Open example →

Free plan

Enough for real projects. Simple enough to remember.

Up to 50 monitors
Up to 100 during extended free tier (early users)
60-second minimum interval
22 global probe locations
1 webhook per monitor
10 API keys per account
30-day incident retention
Full MCP access
Browser push + RSS incident feed
No email required
No credit card required

Get your API key

Paid plans will add 30-second intervals, longer retention, and response-time threshold alerts.

Built by Monitive

UptimeMonitoring.com is the API-first, headless sibling to Monitive Pro.

Monitive has been operating monitoring infrastructure for 15 years. UptimeMonitoring.com takes that operational experience and applies it to a different job: deploy gates, API workflows, AI-agent tooling, and developer-first monitoring without email or dashboard sprawl.

15 years in monitoring
22 probe locations
Cross-region confirmation on failures
GitHub OAuth + API keys
Minimal data collection: GitHub identity only

API / MCP / GitHub Action
          │
          ▼
   Go dispatcher + evidence
          │
          ▼
   22-probe network
          │
          ▼
 webhooks / push / RSS / incidents

FAQ

Is it really free?

Yes. Free plan: up to 50 monitors. Early users can go up to 100 during the extended free tier while paid plans are being finalized.

Do I need an email address?

No. Signup uses GitHub OAuth. Email is optional only if you want future pricing updates.

How do alerts work without email?

Webhooks, browser push, RSS feeds, and MCP queries.

How do you avoid false positives?

Infrastructure-class failures are re-checked across regions before state changes.

Can I monitor private IPs or internal services?

No. Private and reserved targets are blocked.