MCP Server

Uptimeify exposes a stateless Model Context Protocol server so AI agents can run our free checks directly.

For an overview of what the server can do and which clients it works with, see the MCP server page on uptimeify.io. This page is the technical reference.

Endpoint

POST https://uptimeify.io/mcp: Streamable HTTP transport, stateless. The anonymous check tools need no authentication; the authenticated tools require a Bearer API token (see below).

Discover the server programmatically via the MCP Server Card:

GET https://uptimeify.io/.well-known/mcp/server-card.json

Connect an MCP client

Point any MCP client that speaks the Streamable HTTP transport at the endpoint above.

• Anonymous tools work with just the URL: no token needed.
• Authenticated tools require your Uptimeify API token as an Authorization: Bearer <token> header. Create one under Settings → API tokens: leave the customer field empty for an organization-wide token (sees all your monitors), or pick a customer to scope the token to that customer only. The token is shown once on creation: copy it right away.

Clients that support remote HTTP MCP servers with custom headers can point at the URL directly:

{
  "mcpServers": {
    "uptimeify": {
      "url": "https://uptimeify.io/mcp",
      "headers": { "Authorization": "Bearer wsm_your_token_here" }
    }
  }
}

For clients that only speak stdio, bridge to the HTTP endpoint with mcp-remote:

{
  "mcpServers": {
    "uptimeify": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://uptimeify.io/mcp", "--header", "Authorization: Bearer wsm_your_token_here"]
    }
  }
}

Omit the Authorization header entirely if you only need the anonymous check tools.

Rate limits

The anonymous tools run real network probes on your behalf, so they are capped per client IP. You do not need an account to hit these limits, and you do not need one to stay under them:

The two layers apply together: 120 calls a minute spread across different tools is fine, 120 calls a minute of whois is not. Exceeding a limit returns HTTP 429 with a retryAfter value in seconds, telling you when the current window ends. Windows are fixed, not sliding, so a client that waits out retryAfter gets a full fresh allowance.

The limits are enforced per IP, not per token: an API token does not raise the ceiling, and running several agents behind one NAT address makes them share it. If you have a use case that genuinely needs more, get in touch rather than working around it.

Available tools

All tools are anonymous and read-only. They mirror our public web tools:

• check_ssl: TLS/SSL certificate inspection (host, optional port)
• check_dns, dns_propagation, mx_lookup: DNS resolution and propagation (domain)
• spf_check, dkim_check (domain, selector), dmarc_check: mail authentication (domain)
• dnsbl_check (ip), whois (domain), domain_expiry (domain)
• http_headers (url), hsts_check (domain), redirect_check (url)
• port_check (host, port), ping_test (host, optional port)
• website_status (url), response_time (url)
• ip_geolocation (query), asn_lookup (query), reverse_dns (ip)

Authenticated tools (read-only)

These tools read your own monitoring data. Send your Uptimeify API token as an Authorization: Bearer <token> header on the MCP request. A customer-scoped token sees only its own customer's monitors; an organization token sees all customers in the organization. All are read-only.

• list_monitors: list your website monitors (no arguments)
• monitor_status (monitor_id): a single monitor with its current up/down status
• list_incidents (optional limit): recent incidents across your monitors
• check_history (monitor_id, optional from, to): recent checks, optionally within an ISO date range
• uptime_summary (monitor_id): uptime and average response time for day / month / year

If you call one of these without a token, the tool returns an error asking for the Authorization: Bearer header. Create a token under Settings → API tokens.

Connect via OAuth (Claude Desktop / Claude.ai)

Uptimeify's /mcp endpoint also supports standard MCP OAuth (OAuth 2.1 + PKCE + Dynamic Client Registration): this is how Claude's remote-MCP connector authenticates without you creating an API token by hand.

1. In Claude, add https://uptimeify.io/mcp as a remote MCP server and choose Connect.
2. Claude registers itself automatically (Dynamic Client Registration) and opens a browser window asking you to sign in to Uptimeify and approve access.
3. The consent screen always states read-only access to your monitors, incidents, and status pages: the OAuth connection can never create, edit, or delete anything, and it inherits exactly your own account's visibility: a customer-restricted user's Claude sees only that customer, while an org admin's Claude sees the whole organization.
4. Once approved, Claude can call the same 5 read-only tools available to wsm_ API tokens: list_monitors, monitor_status, list_incidents, check_history, uptime_summary.

OAuth access tokens are short-lived (1 hour) and refresh silently while Claude keeps using the connection; the underlying grant expires automatically after 7 days of inactivity. You can review and revoke connected applications at any time under Settings → Connected apps (see Connected apps): revoking is immediate and reconnecting requires going through OAuth consent again.

OAuth and static wsm_ API tokens both work on /mcp at the same time: connecting via OAuth does not require removing an existing API-token integration.

Example (tools/list)

curl -X POST https://uptimeify.io/mcp \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json, text/event-stream' \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'

Example (authenticated tool call)

List your own monitors: add the Authorization header:

curl -X POST https://uptimeify.io/mcp \
  -H 'Authorization: Bearer wsm_your_token_here' \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json, text/event-stream' \
  -d '{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"list_monitors","arguments":{}}}'