Skip to main content

Documentation

Complete guide to setting up website monitoring with PingZen. API documentation, code examples, and best practices.

MCP Setup

130 tools

Connect PingZen to your AI tool via Model Context Protocol (MCP). Manage monitors, alerts, and incidents directly from your AI chat.

How it works

Zero API keys. Zero copy-paste.

Add the URL to your AI client → browser opens → log in → done. OAuth 2.0 handles everything automatically.

  1. Add the config below to your AI client
  2. Your AI client opens a browser for authorization
  3. Log in to PingZen (Google, Yandex, Telegram, or Email)
  4. Click "Allow" — and MCP is connected!

Setup by Client

Claude Code

claude mcp add-json pingzen '{"type":"http","url":"https://pingzen.dev/mcp/"}'

Type /mcp inside Claude Code to verify.

Cursor

.cursor/mcp.json
{
  "mcpServers": {
    "pingzen": {
      "url": "https://pingzen.dev/mcp/"
    }
  }
}

If Cursor doesn't show all tools (limit ~40), use a tagged URL: https://pingzen.dev/mcp/?include_tags=monitors,alerts

VS Code

.vscode/mcp.json
{
  "servers": {
    "pingzen": {
      "type": "http",
      "url": "https://pingzen.dev/mcp/"
    }
  }
}

Claude Desktop

claude_desktop_config.json
{
  "mcpServers": {
    "pingzen": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "https://pingzen.dev/mcp/"
      ]
    }
  }
}

Config file location: macOS: ~/Library/Application Support/Claude/claude_desktop_config.json | Windows: %APPDATA%\Claude\claude_desktop_config.json

Claude Desktop only supports STDIO — mcp-remote bridges to the HTTP server. Requires Node.js.

Windsurf

mcp_config.json
{
  "mcpServers": {
    "pingzen": {
      "serverUrl": "https://pingzen.dev/mcp/"
    }
  }
}

Cline (via API Key)

Cline doesn't support MCP OAuth yet. You'll need an API key — create one in the dashboard.

cline_mcp_settings.json
{
  "mcpServers": {
    "pingzen": {
      "type": "streamableHttp",
      "url": "https://pingzen.dev/mcp/",
      "headers": {
        "Authorization": "Bearer pz_YOUR_API_KEY"
      }
    }
  }
}

Replace pz_YOUR_API_KEY with your actual key. Make sure to include "type": "streamableHttp" — without it, Cline defaults to SSE.

Available Tools

Monitors
15
Alerts
8
Alert Channels
9
Incidents
7
Status Pages
7
Heartbeats
10
Workspaces
7
Groups
9
Telegram
3
Reports
10
Maintenance
6
Webhooks
8
Webhook Checks
8
Web Push
3
Dashboard
1
Auth & Profile
11
Feedback
4
Probes
3
Meta (search)
1

Tag Filtering
new

130 tools give full API coverage, but not every agent needs all of them at once. Tags let you get just the right group of tools with a single URL parameter:

  • Cursor (40-tool limit) — connect with relevant tags instead of all 130
  • Cline — fewer tools in context = better tool selection and lower token usage
  • CI/CD agents — connect only monitors,incidents for automation without clutter
  • Claude Code / Claude Desktop — works automatically (defer_loading), no tags needed

All 130 tools (default)

https://pingzen.dev/mcp/

Monitors + alerts only (~35 tools, fits Cursor limit)

https://pingzen.dev/mcp/?include_tags=monitors,alerts

Monitoring + incidents + status (for automation)

https://pingzen.dev/mcp/?include_tags=monitors,incidents,status_pages

Everything except auth

https://pingzen.dev/mcp/?exclude_tags=auth

Available tags: monitors, alerts, channels, incidents, status_pages, heartbeats, workspaces, groups, telegram, reports, maintenance, webhooks, webhook_checks, web_push, dashboard, auth, feedback, probes, meta

Tool Search
new

The AI agent doesn't need to scan all 130 definitions — search_tools finds the right tool from a task description. The agent asks "what can the server do with SSL?" and gets a ranked list.

Example:

search_tools({ "query": "SSL certificate", "top_k": 5 })
→ create_monitor (score: 4.2), get_monitor_sla (score: 2.1), ...

Supports tag filtering — you can search only among alerts or only among monitors.

Claude Code uses search_tools automatically via defer_loading — all 130 tools are available without context overflow. No configuration needed.

Example Prompts

  • "List all my monitors"
  • "Create an HTTP monitor for example.com"
  • "What's the uptime for my sites?"
  • "Set up a Telegram alert for my monitor"
  • "Show me open incidents"

Troubleshooting

Browser opens but I can't log in
Make sure you have a PingZen account. Sign up at pingzen.dev, then retry the connection. Google, Yandex, Telegram, and Email login are supported.
Getting authentication error (401)
If using OAuth — reconnect the MCP server (browser should open). If using API key — check that the key is active and starts with pz_. Header format: "Authorization: Bearer pz_..."
Connection timeout
Make sure https://pingzen.dev/mcp/ is reachable from your network. Check your proxy and firewall settings.
Tools not showing up
Restart your AI client after changing the configuration. In Claude Code, use /mcp to verify.
Cline doesn't support OAuth
Cline doesn't support MCP OAuth yet. Use an API key — create one in the PingZen dashboard and add it to your config. Also make sure to include "type": "streamableHttp".

Client Support

ClientOAuthAPI Key
Claude Code
Cursor
VS Code
Claude Desktop
Windsurf
Cline

Code Mode
experimental

Instead of calling tools one by one, the AI agent writes a Python script that executes multiple calls at once in a sandbox. Intermediate data (list of 300 monitors, report) stays in the sandbox and doesn't pollute the context window.

98%
accuracy (Stainless eval)
N→1
round-trips
~98%
token savings

Connect:

https://pingzen.dev/mcp/code/

What the AI agent sees (3 meta-tools instead of 130):

search("monitor uptime") → create_monitor, get_uptime_stats, ...
get_schema(["create_monitor"]) → { parameters: { url, protocol, ... } }
execute("""
  monitors = await call_tool("list_monitors", {})
  down = [m for m in monitors if m["status"] == "down"]
  return f"{len(down)} monitors down"
""")

Uses FastMCP 3.2 + Monty sandbox (Rust, 15s timeout, 50MB memory). Separate endpoint — the main /mcp/ works as before.

Platform Integration

To integrate PingZen MCP into your AI platform (ExecAI, custom MCP client, etc.), use OAuth 2.0 or an API key.

Minimal integration — one line:

https://pingzen.dev/mcp/

Transport: streamable-http | Auth: OAuth 2.0 (PKCE) or API key (pz_*)

OAuth 2.0 Endpoints

EndpointMethodURL
MCP ProtocolPOSThttps://pingzen.dev/mcp/
Protected Resource (RFC 9728)GEThttps://pingzen.dev/.well-known/oauth-protected-resource/mcp
Authorization Server (RFC 8414)GEThttps://pingzen.dev/mcp/.well-known/oauth-authorization-server
Dynamic Client RegistrationPOSThttps://pingzen.dev/mcp/register
AuthorizationGEThttps://pingzen.dev/mcp/authorize
Token ExchangePOSThttps://pingzen.dev/mcp/token
Token RevocationPOSThttps://pingzen.dev/mcp/revoke

How OAuth Works

  1. Platform sends POST /mcp/ without auth → receives 401 with resource_metadata URL
  2. Reads RFC 9728 + RFC 8414 metadata → discovers all OAuth endpoints
  3. Registers via DCR (POST /mcp/register) → gets client_id + client_secret
  4. Redirects user to /mcp/authorize with PKCE code_challenge
  5. User logs into PingZen (Google, Yandex, Telegram or email) and clicks "Allow"
  6. Browser redirects back to the platform with an authorization code
  7. Platform exchanges code + code_verifier for access_token (1 hour) and refresh_token (90 days)

Data & Security

What your platform stores:

  • • client_id and client_secret (own, from DCR)
  • • access_token — JWT, expires in 1 hour
  • • refresh_token — expires in 90 days

The platform does not receive the user's password, email, or personal data.

What PingZen stores:

  • • User account (created by the user themselves)
  • • Platform OAuth client (client_id, redirect_uri)
  • • Refresh token hashes (SHA-256)
  • • User's monitors, alerts, and incidents

The user can revoke platform access at any time.

Important: the platform does not create the user account. The user registers or logs in to pingzen.dev themselves via the consent page (Google, Yandex, Telegram or email). This is the standard OAuth 2.0 model.

Manifest (server.json)

Full manifest for registering PingZen MCP on your platform:

server.json
{
  "name": "dev.pingzen/mcp",
  "title": "PingZen Uptime Monitoring",
  "description": "Monitor websites, APIs and services with 130 tools across 23 protocols",
  "version": "0.14.0",
  "websiteUrl": "https://pingzen.dev",
  "icons": [
    {
      "src": "https://pingzen.dev/android-chrome-192x192.png",
      "mimeType": "image/png",
      "sizes": [
        "192x192"
      ]
    }
  ],
  "remote": {
    "type": "streamable-http",
    "url": "https://pingzen.dev/mcp/",
    "oauth": {
      "discoveryUrl": "https://pingzen.dev/.well-known/oauth-protected-resource/mcp",
      "authorizationUrl": "https://pingzen.dev/mcp/authorize",
      "tokenUrl": "https://pingzen.dev/mcp/token",
      "registrationUrl": "https://pingzen.dev/mcp/register",
      "revocationUrl": "https://pingzen.dev/mcp/revoke",
      "scopes": [
        "mcp"
      ],
      "pkceRequired": true,
      "codeChallengeMethod": "S256"
    }
  },
  "features": {
    "tools": 130,
    "resources": 9,
    "prompts": 3,
    "protocols": 23
  },
  "categories": [
    "monitoring",
    "devops",
    "infrastructure",
    "uptime"
  ],
  "languages": [
    "en",
    "ru"
  ]
}

Common Questions

What protocols can I monitor?

PingZen supports 23 protocols: HTTP/HTTPS, WebSocket (WS/WSS), TCP, UDP, ICMP Ping, gRPC, DNS, WHOIS, SSL certificates, Email (SMTP/IMAP/POP3), FTP/FTPS, DNSBL, PageSpeed, SOCKS5, MTProxy, API Check, and Transaction. You can monitor websites, APIs, servers, databases, and any network service.

How fast can I get alerts?

Telegram alerts are delivered within 1-2 seconds of detection. Slack and Discord notifications arrive almost instantly. You can configure multiple alert channels for redundancy.

Can I organize monitors by project?

Yes! PingZen supports workspaces, which let you organize monitors by project, environment, or team. Each workspace can have its own alert configurations and team members.

Is there an API for automation?

Absolutely. PingZen provides a full REST API with OpenAPI documentation. You can create, update, and delete monitors programmatically.

How do status pages work?

Status pages are public, branded pages showing your services' uptime. You can display real-time status and allow customers to subscribe for updates.

What happens if I reach my monitor limit?

We'll notify you when approaching your limit. You can pause some monitors or contact us for increased capacity. We never stop monitoring without warning, ensuring your critical services stay protected.

Ready to stop missing downtime?

Join thousands of teams who trust PingZen. Setup takes 30 seconds.