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, find who is on call and declare an incident that pages them, or run your status pages with their incidents and maintenance windows, from your editor, your terminal or your product.
Paste this sentence into Claude Code, Codex, Cursor, VS Code, Windsurf, Gemini CLI, OpenCode, Zed or any other coding agent:
Fetch and execute the appropriate instructions to set me up for Hyperping from https://hyperping.com/agent-setup/prompt.mdThe agent reads hyperping.com/agent-setup/prompt.md, a Markdown file of instructions written for agents, and does the rest itself: it asks for your API key if HYPERPING_API_KEY is not set, saves it in ~/.config/hyperping/env (readable by you only) and adds one line to your shell profile that loads it, registers the Hyperping MCP server in its own config, offers to add a short Hyperping section to its user instructions, and checks the connection. Open the file to see every command before it runs. On an EU account, add "My Hyperping account is in the EU region." to the sentence.
https://api.hyperping.io/v1/mcpIn the dashboard sidebar, open API Keys (EU accounts: eu.hyperping.io). 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, declare, acknowledge and escalate incidents, or manage your status pages, their incidents and maintenance. Set an expiration for keys handed to short-lived agents.
Export it as HYPERPING_API_KEY from your secret manager, or keep it in a file only you can read, such as ~/.config/hyperping/env (chmod 600, one line: export HYPERPING_API_KEY='sk_…'), loaded by one line of your shell profile: [ -f ~/.config/hyperping/env ] && . ~/.config/hyperping/env. That is what the one-prompt setup does; on Windows it uses setx. Do not write the key into the profile itself: profiles often live in a dotfiles repository. The configs below read the variable wherever the client allows it. Keys start with sk_ and belong to a single project: create one per project the agent should see.
To configure a client by hand instead, 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. The single quotes keep ${HYPERPING_API_KEY} as written: Claude Code stores the reference and reads the variable each time it connects, so the key never lands in its config. Keep --header after the URL.
claude mcp add --transport http --scope user 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. The Cursor CLI reads the same file and loads a new server once you approve it with agent mcp enable hyperping (cursor-agent on older installs):
{
"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"VS Code runs Copilot agents in the Copilot harness, which reads ~/.copilot/mcp-config.json (the same file as GitHub Copilot CLI). Servers go under mcpServers and variables are written ${NAME}:
{
"mcpServers": {
"hyperping": {
"type": "http",
"url": "https://api.hyperping.io/v1/mcp",
"headers": {
"Authorization": "Bearer ${HYPERPING_API_KEY}"
},
"tools": ["*"]
}
}
}The older VS Code format, the mcp.json of your user profile (MCP: Open User Configuration), still works: ~/Library/Application Support/Code/User/mcp.json on macOS, ~/.config/Code/User/mcp.json on Linux, %APPDATA%\Code\User\mcp.json on Windows. It puts servers under servers instead of mcpServers and writes variables as ${env:NAME}. VS Code forwards these servers to Copilot harness sessions, except those that prompt for an input.
{
"servers": {
"hyperping": {
"type": "http",
"url": "https://api.hyperping.io/v1/mcp",
"headers": {
"Authorization": "Bearer ${env:HYPERPING_API_KEY}"
}
}
}
}Add the server to ~/.config/devin/mcp_config.json (%APPDATA%\devin\mcp_config.json on Windows), then refresh the server list in the MCP panel. Older Windsurf versions read ~/.codeium/windsurf/mcp_config.json, with serverUrl in place of url. The Devin docs do not say whether ${env:...} is expanded in headers: if the server reports an authentication error, write the key itself in the header, in this user-level file only.
{
"mcpServers": {
"hyperping": {
"url": "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. Gemini CLI connects to no MCP server, user-level ones included, in a folder it does not trust: trust the folder when it asks.
{
"mcpServers": {
"hyperping": {
"httpUrl": "https://api.hyperping.io/v1/mcp",
"headers": {
"Authorization": "Bearer ${HYPERPING_API_KEY}"
}
}
}
}Add the server to ~/.config/opencode/opencode.json. OpenCode 2 lists servers under mcp.servers, and "oauth": false stops it from trying an OAuth sign-in:
{
"mcp": {
"servers": {
"hyperping": {
"type": "remote",
"url": "https://api.hyperping.io/v1/mcp",
"oauth": false,
"headers": {
"Authorization": "Bearer {env:HYPERPING_API_KEY}"
}
}
}
}
}Add the server under context_servers in Zed's settings.json. Zed does not expand variables in headers, so the key goes in as is:
{
"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@0.16.5", "https://api.hyperping.io/v1/mcp",
"--header", "Authorization:${AUTH_HEADER}",
"--transport", "http-only"
],
"env": {
"AUTH_HEADER": "Bearer sk_your_key"
}
}
}
}The header value goes through env because some systems split arguments on spaces. The bridge is pinned to mcp-remote@0.16.5, the version tested with Hyperping. 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 46 read tools and 23 write tools (on the EU server, 41 and 22: the log tools are US only). The writes cover monitors (create_monitor, update_monitor, pause_monitor, resume_monitor, run_check_now), incidents (create_outage, acknowledge_outage, escalate_outage, resolve_outage), status pages (create_status_page, update_status_page, add_status_page_services, remove_status_page_services), status page incidents (create_status_page_incident, add_status_page_incident_update, resolve_status_page_incident, update_status_page_incident, edit_status_page_incident_update) and maintenance (create_maintenance_window, update_maintenance_window, complete_maintenance_window, cancel_maintenance_window) and logs (create_log_dashboard_from_template). The full list, with parameters and response shapes, is on the MCP Integration page, and the product update walks through the status page, incident and maintenance tools.
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.
- Status pages are public, their incidents and maintenance can notify
subscribers, and create_outage pages on-call: show me the exact text
and targets before any of these writes.
- 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, and the same goes for status pages and incidents. The one exception is canceling a maintenance window that has not started. Deletion stays in the dashboard and the REST API.
Every tool declares MCP annotations that clients use to ask before a write. Each write an agent makes with an API key is recorded in the project's audit log under that key, like a write made over the REST API. The audit log is available on the Business plan. Writes made with a legacy project token leave no ApiKeyWriteAction entry.
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 69 tools: 46 read tools for monitors, uptime, response times, MTTR, MTTA, incidents, alerts, on-call, integrations, cron job healthchecks, servers, browser check runs, logs, the audit log, status pages, status page incidents and maintenance windows, and 23 write tools to create, update, pause and resume monitors, re-run a check from every region, declare incidents that page on-call and acknowledge, escalate or resolve them, create and edit status pages, publish, update and correct status page incidents, schedule, change, end or cancel maintenance, and create log dashboards. The EU server, https://api.eu.hyperping.io/v1/mcp, has the same tools without the 6 log tools: 63 in all. 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, OpenCode and Zed connect directly. Paste one sentence into any of them and the agent sets itself up from https://hyperping.com/agent-setup/prompt.md. 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, for monitors, status pages or incidents: an agent with a read and write key can pause a monitor, but deleting one requires the dashboard or the REST API. The one exception is canceling a maintenance window that has not started yet, which deletes it. 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, 800 requests an hour by default, which answers HTTP 429 once used up. Past an MCP 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.