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

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

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

- [Create your first monitor](https://my.monitive.com)
- [Read quickstart](https://monitive.com/docs/)

### MCP · Claude Code

Connect (one command):

```bash
claude mcp add --transport http monitive \
  https://api.monitive.com/mcp
```

Then just ask Claude:

```text
❯ 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.

### curl · REST API

Create a monitor:

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

Check its state:

```bash
curl https://api.monitive.com/api/v1/monitors/123 \
  -H "Authorization: Bearer mk_live_..."
```

### GitHub Action

Post-deploy gate:

```yaml
- name: Verify deploy health
  uses: uptimemonitoring/assert-healthy@v1
  with:
    api-key: ${{ secrets.MONITIVE_API_KEY }}
    monitor-id: ${{ vars.MONITOR_ID }}
    timeout: 120
```

Fails the workflow if the monitor is not healthy after your deploy.

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.

### REST API

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"
  }'
```

### MCP

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](https://monitive.com/github-actions-health-check/): 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](https://monitive.com/claude-deploy-monitoring/): Add the Monitive MCP server to Claude Code so your agent can create monitors, check status, and react to failures.
- [Uptime monitoring from inside Cursor](https://monitive.com/cursor-uptime-monitoring/): Configure Monitive as an MCP server in Cursor and manage monitors from the agent panel.
- [Monitor any API with 50 free checks](https://monitive.com/api-uptime-monitoring/): 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.

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:

```text
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:

```json
{
  "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.

```text
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.](https://monitive.com/docs/guides/alert-recipients/)

### Browser push

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

```text
Enable notifications
Chrome on macOS · Active
```

### RSS / incident feed

Subscribe from Slack, readers, or automation tools.

```text
https://api.monitive.com
  /feed/{token}/rss
```

### MCP pull

Ask your agent for monitor state and recent incidents directly.

```text
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 →](https://monitive.com/guides/reliable-alerts)

## 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

```bash
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"}'
```

[Open example →](https://monitive.com/docs/examples/)

### Node

Add monitoring to a deploy script

```js
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" })
  }
)
```

[Open example →](https://monitive.com/docs/examples/)

### Python

Automate from scripts or notebooks

```python
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"}
)
```

[Open example →](https://monitive.com/docs/examples/)

### Claude

Natural language monitor management

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

[Open example →](https://monitive.com/docs/examples/)

### Cursor

Monitor from your IDE

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

[Open example →](https://monitive.com/docs/examples/)

### Webhook recipes

Route incidents to any system

```text
# 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
```

[Open example →](https://monitive.com/docs/examples/)

## 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

[Get your API key](https://my.monitive.com)

## 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

```text
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.

---

Your first monitor takes 30 seconds. Sign in with GitHub, Google, Microsoft, or email, and your first check runs right away. 50 monitors, free, no card. [Start watching](https://my.monitive.com/)
