16 years in monitoring 50 monitors free · GitHub login · no email typed in · no card

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

Create monitors with a curl call, an MCP prompt, or a GitHub Action.

claude — my-app
Connect (one command)
claude mcp add --transport http monitive \
  https://api.monitive.com/mcp
Then just ask Claude
❯ Create an HTTP monitor for https://example.com named "My Site"
❯ List my monitors
❯ What is the current status of monitor 123?

Have an API key? Add --header "Authorization: Bearer mk_live_..." to authorize via key.

keys: my.monitive.com/keys 60s checks · 22 probe locations
16 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.monitive.com/api/v1/monitors \
  -H "Authorization: Bearer $MONITIVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "api-prod",
    "url": "https://api.example.com/healthz",
    "type": "http"
  }'

What happens when something breaks

We do not flip red on the first blip.

1

Create

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

2

Test immediately

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

3

Check on schedule

Checks are spread across the minute to keep load stable.

4

Re-check failures

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

5

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,
  "ref": "k7q2mx-7",
  "type": "down",
  "monitor_id": 1287,
  "monitor_ref": "k7q2mx-14",
  "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 your own endpoint, or a relay such as alert-bridge in front of Slack, Discord, Pushover, or ntfy.

POST /api/v1/recipients
{ "name": "ops", "type": "webhook", "config": {"url": "https://hooks.co/inc"} }

PUT  /api/v1/monitors/{id}/recipients   # attach it (read first — full replacement)

Concurrent edits can lose a change — see the alert-recipients guide.

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.monitive.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

Browser push and email get muted by Do Not Disturb — exactly when an outage matters. Wire a webhook to Pushover (bypasses DND on iOS and Android) or ntfy for phone alerts the moment something breaks.

Reliable alerts guide →

Validate the things that actually break

HTTP / HTTPS

Status codes, body match, timing evidence

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.monitive.com/api/v1/monitors \
  -H "Authorization: Bearer $MONITIVE_API_KEY" \
  -d '{"url":"https://api.example.com/healthz","type":"http"}'

Node

Add monitoring to a deploy script

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

Python

Automate from scripts or notebooks

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

Claude

Natural language monitor management

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

Cursor

Monitor from your IDE

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

Webhook recipes

Route incidents to any system

# 1. Create a recipient with your endpoint
POST /api/v1/recipients
{ "name": "ops", "type": "webhook", "config": { "url": "https://your.app/hook" } }

# 2. Read the monitor's current recipients, then attach yours
GET  /api/v1/monitors/{id}/recipients
PUT  /api/v1/monitors/{id}/recipients
# Concurrent edits can lose a change — see docs/guides/alert-recipients

Free plan

Enough for real projects. Simple enough to remember.

  • 50 monitors
  • Checks every minute
  • 22 global probe locations
  • Reusable webhook recipients
  • 10 API keys per account
  • 30 days of incident history
  • Full MCP access
  • Browser push + RSS incident feed
  • No email typed in
  • No credit card required

Built by Monitive

Monitive has been operating monitoring infrastructure for 16 years.

That operational experience now powers deploy gates, API workflows, AI-agent tooling, and developer-first monitoring without dashboard sprawl.

  • 16 years in monitoring
  • 22 probe locations
  • Cross-region confirmation on failures
  • GitHub, Google, Microsoft, or email sign-in + API keys
  • GitHub or Google sign-in: no email address to type in
API / MCP / GitHub Action
          │
          ▼
   Go dispatcher + evidence
          │
          ▼
   22-probe network
          │
          ▼
 webhooks / push / RSS / incidents

FAQ

Is it really free?

Yes. The free plan includes 50 monitors, checked every minute, with 30 days of incident history.

Do I need to type in an email address?

Sign in with GitHub, Google, Microsoft, or email. With GitHub or Google, neither provider has you type in an address. Email sign-in is the exception: you enter one directly. GitHub sign-in still needs a verified primary email on GitHub's side regardless of what you type: sign-in fails if GitHub reports none, or only an unverified one. We normally store whatever address GitHub returns as your account's email, the same as a direct email sign-in — except we skip saving it if your account already has an email on file, or if that address already belongs to a different account. Google sign-in needs no address that you separately enter or that we store.

How do alerts reach me?

Webhooks, email, 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.