MCP endpoint

← All guides

Looking for the marketing overview? See the MCP feature page. This article assumes you've already decided to use it and want to know how it actually works.

What you need

• A Pingoru Pro plan ($15/month). MCP is a Pro feature.
• An API key minted at /app/api-keys. Keys start with pk_; the secret is shown once at creation time and is hashed in our database — there's no way to recover a lost secret, so paste it into your AI tool's config immediately.
• An MCP-compatible client. /features/mcp#setup has copy-paste config for the major ones; if your client isn't listed it just needs the endpoint URL and a Bearer token.

The endpoint

https://mcp.pingoru.io/

Streamable HTTP, stateless — every request stands alone, so multi-worker deployments and bookmarkable connections both work. Speak JSON-RPC 2.0 per the MCP specification; tools are surfaced via the standard tools/list and called via tools/call.

Authentication

Every request needs an Authorization: Bearer pk_… header:

curl -sS https://mcp.pingoru.io/ \
  -H "Authorization: Bearer pk_YOUR_SECRET_HERE" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'

Keys are revocable from the dashboard. Revoking takes effect on the next request — there's no propagation lag because key state lives in the same SQLite the API server reads.

We log call metadata (timestamp, tool name, slug argument, status code, duration) for 90 days for forensics and abuse detection. We do not log response bodies, prompts, or anything from the conversation that produced the call.

Tool reference

9 tools, all read-only. Tools split into two scopes:

• Catalog tools work against any provider in the curated popular set or any provider you have a monitor on (see Provider scope for why). Catalog tools: provider_status, provider_components, component_status, provider_incidents, incident_detail, search_providers.
• Account tools only see your own monitors and notifications. Account tools: my_monitors, my_active_alerts, my_recent_incidents.

provider_status

Get the current status and any active incidents for a status-page vendor.

Signature: provider_status(slug: string)

Returns: { slug, name, health, in_maintenance, active_incident_count, last_checked_at, status_url }

Try it: "Is GitHub down right now?"

provider_components

List a provider's components with their current status; optionally filter to non-operational only.

Signature: provider_components(slug: string, only_problematic?: boolean)

Returns: [{ component_id, name, group_name?, status, last_observed_at }]

Try it: "Which Cloudflare components are degraded?"

component_status

Pinpoint the status of a single component by name (case-insensitive substring match).

Signature: component_status(slug: string, component: string)

Returns: { component_name, group_name?, status, in_active_incident, current_incident? }

Try it: "What's the status of EC2 us-east-1?"

provider_incidents

Recent incident history for a provider (last 1–30 days), with optional filter to a single component.

Signature: provider_incidents(slug: string, days?: number = 7, component?: string)

Returns: [{ id, title, started_at, resolved_at, duration_minutes, impact, affected_components, url }]

Try it: "Any AWS issues this week?"

incident_detail

Full timeline for one incident: every status update with timestamp, plus start/resolve times and duration.

Signature: incident_detail(slug: string, incident_id: number)

Returns: { incident: {...}, updates: [{ posted_at, body, status }] }

Try it: "Walk me through the May 3 Stripe outage."

search_providers

Find providers by name or slug. Use when the agent does not know the exact slug.

Signature: search_providers(query: string, limit?: number = 10)

Returns: [{ slug, name, category, is_active }]

Try it: "Look up that DBaaS — planetscale?"

my_monitors

List all of the caller's monitored services with their current rolled-up health.

Signature: my_monitors()

Returns: [{ public_id, name, provider: { slug, name }, health, active_incident_count, in_maintenance }]

Try it: "What's the health of my entire stack?"

my_active_alerts

Open incidents on the caller's monitored services right now.

Signature: my_active_alerts()

Returns: [{ monitor_id, monitor_name, provider_slug, incident: { id, title, started_at, impact, components } }]

Try it: "Is anything I monitor broken right now?"

my_recent_incidents

Resolved incidents on the caller's monitors over the last N days (max 30).

Signature: my_recent_incidents(days?: number = 7)

Returns: [{ monitor_id, provider_slug, incident: {...} }]

Try it: "What burned us this week?"

Provider scope (the slug-allowlist gate)

Catalog tools (provider_status, provider_components, component_status, provider_incidents, incident_detail) gate which providers your assistant can ask about. The rule is simple:

• The 50 most-asked-about vendors are always available — AWS, GitHub, Stripe, Cloudflare, GCP, Azure, OpenAI, Anthropic, Slack, M365, Datadog, Twilio, SendGrid, etc.
• Any provider you have a monitor on is available. Adding a monitor is free — go to /app/monitors, click Add monitor, search for the vendor.

Asking about a provider that's neither popular nor monitored returns:

{
  "error": "provider_not_in_your_stack",
  "slug": "linear",
  "name": "Linear",
  "hint": "MCP can only query providers in the curated popular set
           ... or providers you have a monitor on. Add a free
           monitor for 'Linear' from /app/monitors and the agent
           will see it on the next call."
}

Why the gate? It stops a single account from harvesting our 6,000+ catalog and republishing it. It doesn't stop you from asking about the long tail — just adds the (free) step of creating a monitor first.

Slug resolution (typo-tolerant)

Every tool that takes a slug argument runs the input through a four-stage resolver before giving up:

1. Exact slug match — fastest path. Slugs are lower-kebab-case, e.g. amazon-web-services, microsoft-365.
2. Curated alias map — for the shorthand humans say that doesn't match a slug. Examples below.
3. Fuzzy search via Meilisearch — typo-tolerant name and slug matching. Re-ranked locally by character overlap so incident-title noise can't drag the wrong vendor to the top.
4. Stop-word-stripped retry — "is jira down?" becomes "jira" before the second pass.

The kinds of input the resolver handles:

When fuzzy fallback fires, the tool's response includes matched_via: "fuzzy" and echoes the original query so the assistant can confirm with the user before quoting the result.

Rate limits

Limits hit returns HTTP 429 with a structured JSON-RPC error. The "30-day window" is rolling — it resets 30 days after your account's first MCP call, not on the first of the month. Need more headroom for a power workflow? Contact us for a per-account override.

Errors

Incident lookback

Tools that take a days argument (provider_incidents, my_recent_incidents) are capped at 30 days. Asking for older history is intentionally not supported — the protocol is for "what's broken / has been broken recently?" questions, not historical research. For older history, point your assistant at the upstream vendor's own status page (each tool surfaces status_url in its response).

Setup recipes

Configure your AI tool by pasting your API key + the endpoint URL into the right config file. The setup tabs on /features/mcp#setup generate a filled-in snippet for each supported tool — copy-paste, restart, done. Tools we've tested:

• Claude Desktop — Anthropic's desktop chat app. The most polished MCP experience and our recommended starting point.
• Claude Code — Anthropic's CLI for terminal-based pair programming. Add the Pingoru MCP server with a single command.
• Cursor — AI-first code editor (VS Code fork). MCP support is built in via Settings → MCP.
• Cline — Open-source autonomous coding agent for VS Code. Configure via the MCP Servers tab in the sidebar.
• Continue.dev — Open-source AI coding assistant for VS Code and JetBrains. MCP support via the experimental servers config.
• Zed — High-performance native editor by ex-Atom team. MCP support via the assistant-servers config.
• Goose — Block's open-source local-first AI agent. MCP-native; add the server with the Goose CLI.
• ChatGPT (via bridge) — ChatGPT doesn't speak MCP natively yet. The community bridges (e.g. mcp-bridge) translate MCP into ChatGPT's connector format.

Anything else that speaks MCP works too — see the "My tool isn't here" tab for the raw config shape.

Worked example

Asking Claude Desktop "is GitHub having any problems right now?" produces a tool call like this under the hood:

POST https://mcp.pingoru.io/
Authorization: Bearer pk_…
Content-Type: application/json
Accept: application/json, text/event-stream

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "provider_status",
    "arguments": { "slug": "github" }
  }
}

And gets back:

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "content": [{
      "type": "text",
      "text": "{
        \"slug\": \"github\",
        \"name\": \"GitHub\",
        \"health\": \"operational\",
        \"active_incident_count\": 0,
        \"active_incidents\": [],
        \"last_checked_at\": \"2026-05-06T22:36:38Z\",
        \"status_url\": \"https://www.githubstatus.com\"
      }"
    }],
    "isError": false
  }
}

Claude then phrases that as "GitHub looks healthy — no active incidents as of two minutes ago" and you move on with your day.

Troubleshooting

Didn't find what you needed? Let us know — we'll add it to the guides.