Hyperping runs a hosted MCP (Model Context Protocol) server. Connect Claude Code, Cursor, Codex, VS Code or your own agent to it with an API key, and the agent can check what is down, create and update monitors, pull uptime and SLA numbers, trace an outage and find who is on call, from your editor, your terminal or your product.
https://api.hyperping.io/v1/mcpCopy the prompt below and paste it into Claude Code, Cursor, Codex, Windsurf, or any agent that can edit files. It writes the config for the client it runs in, asks for your API key, and verifies the connection.
Set up the Hyperping MCP server for me.
1. Add a remote MCP server named "hyperping" to this client's MCP config:
URL: https://api.hyperping.io/v1/mcp
Transport: streamable HTTP
Header: Authorization: Bearer <HYPERPING_API_KEY>
Read the key from the HYPERPING_API_KEY environment variable if this
client supports variables in its config, so it never lands in a file
that gets committed. If you cannot edit the config yourself, print the
exact block and the path of the file it goes in.
2. If HYPERPING_API_KEY is not set, ask me for the key. I create it in
Hyperping under API Keys (https://app.hyperping.io/project/developers).
3. Read https://hyperping.com/mcp/llms.txt to learn the tools and query
patterns, and https://hyperping.com/docs/llms.txt to find any page of
the documentation when I ask how something works.
4. Check the connection with get_status_summary and tell me how many
monitors are up and down.In the dashboard sidebar, open API Keys. Keys are available during the free trial and on the Essentials, Pro and Business plans.
Read-only if the agent should only report and investigate. Read/Write if it should also create, edit, pause and resume monitors, or post incidents and maintenance on your status pages. Set an expiration for keys handed to short-lived agents.
Export it as HYPERPING_API_KEY in your shell or secret manager. The configs below read it from there wherever the client allows it. Keys start with sk_ and belong to a single project: create one per project the agent should see.
Every client needs the same three things: the URL https://api.hyperping.io/v1/mcp, the streamable HTTP transport, and an Authorization: Bearer header. Only the file and its format change.
One command from your terminal:
claude mcp add --transport http hyperping https://api.hyperping.io/v1/mcp \
--header "Authorization: Bearer $HYPERPING_API_KEY"To share the server with your team, commit a .mcp.json at the root of the repo. Claude Code expands ${HYPERPING_API_KEY} from each developer's environment, so the key itself is never committed. Run /mcp in a session to check the connection.
{
"mcpServers": {
"hyperping": {
"type": "http",
"url": "https://api.hyperping.io/v1/mcp",
"headers": {
"Authorization": "Bearer ${HYPERPING_API_KEY}"
}
}
}
}Create .cursor/mcp.json at the root of your project, or ~/.cursor/mcp.json for every project:
{
"mcpServers": {
"hyperping": {
"url": "https://api.hyperping.io/v1/mcp",
"headers": {
"Authorization": "Bearer ${env:HYPERPING_API_KEY}"
}
}
}
}Codex connects to streamable HTTP servers natively and reads the token from an environment variable. One command:
codex mcp add hyperping --url https://api.hyperping.io/v1/mcp \
--bearer-token-env-var HYPERPING_API_KEYOr add it to ~/.codex/config.toml, or .codex/config.toml in a project:
[mcp_servers.hyperping]
url = "https://api.hyperping.io/v1/mcp"
bearer_token_env_var = "HYPERPING_API_KEY"Create .vscode/mcp.json in your workspace. VS Code prompts for the key the first time the server starts and stores it encrypted, so the file can be committed:
{
"inputs": [
{
"type": "promptString",
"id": "hyperping-api-key",
"description": "Hyperping API key",
"password": true
}
],
"servers": {
"hyperping": {
"type": "http",
"url": "https://api.hyperping.io/v1/mcp",
"headers": {
"Authorization": "Bearer ${input:hyperping-api-key}"
}
}
}
}Add the server to ~/.config/devin/mcp_config.json (%APPDATA%\devin\mcp_config.json on Windows). Older Windsurf versions read ~/.codeium/windsurf/mcp_config.json.
{
"mcpServers": {
"hyperping": {
"serverUrl": "https://api.hyperping.io/v1/mcp",
"headers": {
"Authorization": "Bearer ${env:HYPERPING_API_KEY}"
}
}
}
}Add the server to ~/.gemini/settings.json, or .gemini/settings.json in a project:
{
"mcpServers": {
"hyperping": {
"httpUrl": "https://api.hyperping.io/v1/mcp",
"headers": {
"Authorization": "Bearer $HYPERPING_API_KEY"
}
}
}
}Add the server under context_servers in Zed's settings.json:
{
"context_servers": {
"hyperping": {
"url": "https://api.hyperping.io/v1/mcp",
"headers": {
"Authorization": "Bearer sk_your_key"
}
}
}
}The Claude apps add remote servers as custom connectors, which sign in with OAuth. Organizations enrolled in Anthropic's request headers beta can instead pick No sign-in, then add an authorization header with the value Bearer sk_your_key. Otherwise, run the mcp-remote bridge (Node.js 18 or later) from claude_desktop_config.json, which you open from Settings → Developer → Edit Config:
{
"mcpServers": {
"hyperping": {
"command": "npx",
"args": [
"-y", "mcp-remote", "https://api.hyperping.io/v1/mcp",
"--header", "Authorization:${AUTH_HEADER}"
],
"env": {
"AUTH_HEADER": "Bearer sk_your_key"
}
}
}
}The header value goes through env because some systems split arguments on spaces. Restart Claude Desktop after saving.
Any MCP client that supports remote servers works: point it at https://api.hyperping.io/v1/mcp with the streamable HTTP transport and an Authorization: Bearer header. Clients that only run local (stdio) servers can use the mcp-remote bridge shown for Claude Desktop. Connectors that only offer OAuth sign-in cannot connect yet.
Building an agent of your own, an on-call assistant or an internal SRE bot? The major model APIs call remote MCP servers themselves: pass the URL and the key, and the model gets the Hyperping tools with no client code.
curl https://api.anthropic.com/v1/messages \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: mcp-client-2025-11-20" \
-H "content-type: application/json" \
-d '{
"model": "claude-sonnet-5",
"max_tokens": 1024,
"messages": [{"role": "user", "content": "What is down right now?"}],
"mcp_servers": [{
"type": "url",
"url": "https://api.hyperping.io/v1/mcp",
"name": "hyperping",
"authorization_token": "'"$HYPERPING_API_KEY"'"
}],
"tools": [{"type": "mcp_toolset", "mcp_server_name": "hyperping"}]
}'Once connected, ask in plain language. Each of these maps to one or two tools:
"choices"."The server exposes 28 read tools and 8 write tools (create_monitor, update_monitor, pause_monitor, resume_monitor, create_incident, add_incident_update, resolve_incident, create_maintenance_window). The full list, with parameters and response shapes, is on the MCP Integration page.
The whole documentation is published in formats agents read directly, so an agent can answer "how do I set up a private status page?" from the source instead of from memory:
hyperping.com/docs/llms.txt indexes every page with a one-line description. Each section also has its own index, for example /docs/status-page/llms.txt.hyperping.com/docs/llms-full.txt is the whole documentation in one Markdown file, for tools that index a whole documentation set at once.index.md to its URL, for example /docs/agent-setup/index.md. The Copy as Markdown button at the top of each page copies it for a chat.hyperping.com/mcp/llms.txt describes every MCP tool, its parameters and the common query patterns.To make it standing context, paste this into your agent's project instructions (AGENTS.md, CLAUDE.md, .cursor/rules or equivalent):
## Hyperping (uptime monitoring and status pages)
- The hyperping MCP server is connected. Use it to check what is down
(get_status_summary), look up monitors, outages, uptime/SLA and on-call.
- Tools and query patterns: https://hyperping.com/mcp/llms.txt
- Docs index: https://hyperping.com/docs/llms.txt
Every page has a Markdown twin at <page url>/index.md.
- Never delete monitors. Pause them instead, and ask before any write.
- Monitors that belong in version control go through the Terraform
provider (hyperping/hyperping), not MCP writes.For monitors that should live in version control, use the Terraform provider instead of MCP writes. Agents handle it well: describe the monitor you want, ask for the HCL, then review the plan like any other infrastructure change.
An API key belongs to exactly one project. Cross-project access returns 404, even with a valid monitor ID.
Write tools refuse read-only keys in the tool handler. The agent cannot talk its way around it.
Agents can pause monitors but never delete them. Deletion stays in the dashboard and the REST API.
Delete a key in the dashboard and the next MCP call fails. Keys can also expire on their own, from one hour to one year.
Rate limits apply per project: 60 tool calls a minute and 600 an hour. Clients should initialize once and reuse the session. Details on the MCP Integration page.
A hosted Model Context Protocol server at https://api.hyperping.io/v1/mcp. It exposes a Hyperping project to AI agents as 36 tools: 28 read tools for monitors, outages, alerts, uptime, response times, MTTR, MTTA, on-call, integrations, status pages, incidents and maintenance windows, and 8 write tools to create, update, pause and resume monitors, publish, update and resolve status page incidents, and schedule maintenance. There is nothing to install.
Any MCP client that supports remote servers over streamable HTTP with a custom header: Claude Code, Cursor, OpenAI Codex, VS Code with GitHub Copilot, Windsurf, Gemini CLI and Zed connect directly. Clients that only run local servers, such as Claude Desktop, connect through the mcp-remote bridge. Your own agents can call it from the Claude API, the OpenAI Responses API or the Claude Agent SDK.
With a Hyperping API key sent as an Authorization: Bearer header. Each key belongs to one project and is either read-only or read and write. OAuth is not supported yet: clients that only offer OAuth sign-in connect through the mcp-remote bridge.
The MCP server uses API keys, which are available on the Essentials, Pro and Business plans and during the 14-day free trial. There is no extra charge for MCP calls. Keys created during the trial stop working if it ends on the free plan.
No. Deletion is not exposed over MCP. An agent with a read and write key can create, update, pause and resume monitors, publish incidents and schedule maintenance, but deleting any of them requires the dashboard or the REST API. A read-only key cannot change anything.
Per project, 60 tool calls a minute and 600 an hour, and 5 initialize calls a minute and 20 an hour. Calls also count toward the REST API quota of the project. Past a limit, the server returns a JSON-RPC error with retry_after_seconds.
Yes. https://hyperping.com/docs/llms.txt indexes every page, https://hyperping.com/docs/llms-full.txt holds the whole documentation in one Markdown file, and every page has a Markdown version at its URL followed by index.md.