Free Uptime Monitoring API — Monitor URLs & Get Alerts via REST

Need to know when your API goes down — without setting up Grafana, Prometheus, or paying for UptimeRobot? The Agent Uptime Monitor API lets you create URL monitors, track response times, receive webhook alerts on downtime, and build status pages — all via REST.

In this guide you'll learn how to set up monitors, configure downtime alerts, query check history, and build real-world monitoring workflows with the API.

Quick Start — Monitor a URL in 60 Seconds

Get an API key (free), then create a monitor that checks your site every 60 seconds:

Step 1: Get an API Key

curl -X POST https://agent-gateway-kappa.vercel.app/v1/agent-monitor/api/keys/create

{
  "apiKey": "mon_abc123...",
  "credits": 20,
  "plan": "free"
}

Step 2: Create a Monitor

curl -X POST https://agent-gateway-kappa.vercel.app/v1/agent-monitor/api/monitors \
  -H "Authorization: Bearer mon_abc123..." \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Production API",
    "url": "https://api.example.com/health",
    "interval": 60,
    "method": "GET",
    "expectedStatus": 200,
    "timeout": 5000
  }'

# Response:
{
  "id": "f7a1b2c3-d4e5-6789-abcd-ef0123456789",
  "name": "Production API",
  "url": "https://api.example.com/health",
  "interval": 60,
  "method": "GET",
  "status": "checking",
  "created": "2026-03-04T12:00:00.000Z",
  "credits_remaining": 19
}

import requests

API_KEY = "mon_abc123..."
BASE = "https://agent-gateway-kappa.vercel.app/v1/agent-monitor"

# Create a monitor
resp = requests.post(
    f"{BASE}/api/monitors",
    headers={"Authorization": f"Bearer {API_KEY}"},
    json={
        "name": "Production API",
        "url": "https://api.example.com/health",
        "interval": 60,
        "expectedStatus": 200,
        "timeout": 5000,
    },
)
monitor = resp.json()
print(f"Monitor created: {monitor['id']}")

const API_KEY = 'mon_abc123...';
const BASE = 'https://agent-gateway-kappa.vercel.app/v1/agent-monitor';

const resp = await fetch(`${BASE}/api/monitors`, {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${API_KEY}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    name: 'Production API',
    url: 'https://api.example.com/health',
    interval: 60,
    expectedStatus: 200,
    timeout: 5000,
  }),
});
const monitor = await resp.json();
console.log(`Monitor created: ${monitor.id}`);

That's it. The API starts checking your URL immediately and tracks every result.

API Reference — All 12 Endpoints

All endpoints are prefixed with https://agent-gateway-kappa.vercel.app/v1/agent-monitor. Requires an API key in the Authorization: Bearer header.

Configure Webhook Alerts

Get notified the moment your site goes down — and again when it recovers:

# Configure webhook alerts for a monitor
curl -X PUT https://agent-gateway-kappa.vercel.app/v1/agent-monitor/api/monitors/MONITOR_ID/alerts \
  -H "Authorization: Bearer mon_abc123..." \
  -H "Content-Type: application/json" \
  -d '{
    "webhookUrl": "https://hooks.slack.com/services/T.../B.../xxx",
    "webhookHeaders": {"Content-Type": "application/json"}
  }'

# When the monitor goes down, you'll receive:
{
  "event": "monitor.down",
  "monitor": {
    "id": "f7a1b2c3-...",
    "name": "Production API",
    "url": "https://api.example.com/health"
  },
  "incident": {
    "type": "down",
    "statusCode": 0,
    "error": "Timeout",
    "startedAt": "2026-03-04T14:23:01.000Z"
  },
  "timestamp": "2026-03-04T14:23:01.000Z"
}

# Configure Slack webhook alerts
resp = requests.put(
    f"{BASE}/api/monitors/{monitor_id}/alerts",
    headers={"Authorization": f"Bearer {API_KEY}"},
    json={
        "webhookUrl": "https://hooks.slack.com/services/T.../B.../xxx",
        "webhookHeaders": {"Content-Type": "application/json"},
    },
)
print(resp.json())  # {"configured": true, "monitorId": "...", "webhookUrl": "..."}

// Configure Discord webhook alerts
await fetch(`${BASE}/api/monitors/${monitorId}/alerts`, {
  method: 'PUT',
  headers: {
    'Authorization': `Bearer ${API_KEY}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    webhookUrl: 'https://discord.com/api/webhooks/...',
    webhookHeaders: { 'Content-Type': 'application/json' },
  }),
});

The webhook fires on every state transition: monitor.down when the site becomes unreachable, and monitor.up when it recovers. Works with Slack, Discord, PagerDuty, or any custom endpoint.

Check History & Uptime Stats

Every health check is recorded with status, response time, and status code:

# Get detailed monitor info with uptime stats
curl https://agent-gateway-kappa.vercel.app/v1/agent-monitor/api/monitors/MONITOR_ID \
  -H "Authorization: Bearer mon_abc123..."

{
  "id": "f7a1b2c3-...",
  "name": "Production API",
  "url": "https://api.example.com/health",
  "status": "up",
  "interval": 60,
  "lastCheck": "2026-03-04T14:30:01.000Z",
  "lastResponseTime": 142,
  "uptimePercent": 99.87,
  "uptime24h": 100.0,
  "avgResponseTime": 156,
  "totalChecks": 1440,
  "totalIncidents": 2,
  "recentIncidents": [
    {
      "type": "recovery",
      "startedAt": "2026-03-04T03:15:00.000Z",
      "statusCode": 200,
      "responseTime": 89
    }
  ]
}

# Get raw check history (last 50 checks)
curl "https://agent-gateway-kappa.vercel.app/v1/agent-monitor/api/monitors/MONITOR_ID/checks?limit=50" \
  -H "Authorization: Bearer mon_abc123..."

{
  "checks": [
    {"timestamp": "2026-03-04T14:30:01Z", "status": "up", "statusCode": 200, "responseTime": 142},
    {"timestamp": "2026-03-04T14:29:01Z", "status": "up", "statusCode": 200, "responseTime": 138},
    {"timestamp": "2026-03-04T14:28:01Z", "status": "up", "statusCode": 200, "responseTime": 155}
  ],
  "total": 1440,
  "limit": 50
}

Build a Status Page

Get a summary of all your monitors in one call — perfect for building a public status page:

curl https://agent-gateway-kappa.vercel.app/v1/agent-monitor/api/status \
  -H "Authorization: Bearer mon_abc123..."

{
  "overall": "operational",
  "monitors": [
    {"name": "Production API", "status": "up", "uptimePercent": 99.87, "lastResponseTime": 142},
    {"name": "Payment Service", "status": "up", "uptimePercent": 100.0, "lastResponseTime": 45},
    {"name": "CDN Origin", "status": "up", "uptimePercent": 99.95, "lastResponseTime": 23}
  ],
  "total": 3,
  "up": 3,
  "down": 0,
  "paused": 0,
  "timestamp": "2026-03-04T14:30:00.000Z"
}

Advanced: Custom Check Configuration

Beyond basic URL checks, the API supports custom HTTP methods, headers, expected body content, and timeouts:

# Monitor a POST endpoint with custom headers and body matching
curl -X POST https://agent-gateway-kappa.vercel.app/v1/agent-monitor/api/monitors \
  -H "Authorization: Bearer mon_abc123..." \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Auth Service",
    "url": "https://auth.example.com/api/health",
    "method": "POST",
    "headers": {"X-Health-Check": "true"},
    "expectedStatus": 200,
    "expectedBody": "\"healthy\"",
    "interval": 300,
    "timeout": 10000
  }'

Monitor configuration options:

• interval — Check frequency in seconds: 30, 60, 300, 600, 900, 1800, or 3600
• method — HTTP method: GET, POST, PUT, HEAD, etc.
• headers — Custom request headers (auth tokens, API keys)
• expectedStatus — Expected HTTP status code (default: 200)
• expectedBody — String that must appear in the response body
• timeout — Max wait time in ms (up to 30,000)

Real-World Use Cases

Example: Monitoring Script with Slack Alerts

import requests

BASE = "https://agent-gateway-kappa.vercel.app/v1/agent-monitor"

# Step 1: Get an API key
key_resp = requests.post(f"{BASE}/api/keys/create")
API_KEY = key_resp.json()["apiKey"]
headers = {"Authorization": f"Bearer {API_KEY}"}

# Step 2: Create monitors for all your services
services = [
    {"name": "Main API", "url": "https://api.myapp.com/health", "interval": 60},
    {"name": "Payment Service", "url": "https://pay.myapp.com/health", "interval": 30},
    {"name": "CDN Origin", "url": "https://cdn.myapp.com", "interval": 300},
]

for svc in services:
    resp = requests.post(f"{BASE}/api/monitors", headers=headers, json=svc)
    monitor = resp.json()
    monitor_id = monitor["id"]
    print(f"Created monitor: {svc['name']} ({monitor_id})")

    # Configure Slack alerts
    requests.put(
        f"{BASE}/api/monitors/{monitor_id}/alerts",
        headers=headers,
        json={"webhookUrl": "https://hooks.slack.com/services/YOUR/SLACK/WEBHOOK"},
    )

# Step 3: Check overall status
status = requests.get(f"{BASE}/api/status", headers=headers).json()
print(f"Overall: {status['overall']} ({status['up']}/{status['total']} up)")

const BASE = 'https://agent-gateway-kappa.vercel.app/v1/agent-monitor';

// Step 1: Get an API key
const keyResp = await fetch(`${BASE}/api/keys/create`, { method: 'POST' });
const { apiKey } = await keyResp.json();
const headers = { 'Authorization': `Bearer ${apiKey}`, 'Content-Type': 'application/json' };

// Step 2: Create monitors
const services = [
  { name: 'Main API', url: 'https://api.myapp.com/health', interval: 60 },
  { name: 'Payment Service', url: 'https://pay.myapp.com/health', interval: 30 },
  { name: 'CDN Origin', url: 'https://cdn.myapp.com', interval: 300 },
];

for (const svc of services) {
  const resp = await fetch(`${BASE}/api/monitors`, {
    method: 'POST', headers, body: JSON.stringify(svc),
  });
  const monitor = await resp.json();
  console.log(`Created: ${svc.name} (${monitor.id})`);

  // Configure alerts
  await fetch(`${BASE}/api/monitors/${monitor.id}/alerts`, {
    method: 'PUT', headers,
    body: JSON.stringify({ webhookUrl: 'https://hooks.slack.com/services/YOUR/SLACK/WEBHOOK' }),
  });
}

// Step 3: Check status
const status = await (await fetch(`${BASE}/api/status`, { headers })).json();
console.log(`Overall: ${status.overall} (${status.up}/${status.total} up)`);

Comparison: Agent Uptime Monitor vs Alternatives

Best for: Developers who want monitoring via API without creating accounts, AI agents that need to monitor their tool endpoints, and teams building custom status pages or monitoring dashboards.

Manage Monitors — Pause, Resume, Delete

# Pause a monitor (during maintenance)
curl -X POST https://agent-gateway-kappa.vercel.app/v1/agent-monitor/api/monitors/MONITOR_ID/pause \
  -H "Authorization: Bearer mon_abc123..."

# Resume monitoring
curl -X POST https://agent-gateway-kappa.vercel.app/v1/agent-monitor/api/monitors/MONITOR_ID/resume \
  -H "Authorization: Bearer mon_abc123..."

# Trigger an immediate check (don't wait for next interval)
curl -X POST https://agent-gateway-kappa.vercel.app/v1/agent-monitor/api/monitors/MONITOR_ID/check \
  -H "Authorization: Bearer mon_abc123..."

# View incident history (down/recovery events)
curl https://agent-gateway-kappa.vercel.app/v1/agent-monitor/api/monitors/MONITOR_ID/incidents \
  -H "Authorization: Bearer mon_abc123..."

# Delete a monitor
curl -X DELETE https://agent-gateway-kappa.vercel.app/v1/agent-monitor/api/monitors/MONITOR_ID \
  -H "Authorization: Bearer mon_abc123..."

FAQ