--- title: "Agent Setup: MCP for Claude Code, Cursor and Codex" description: "Connect Claude Code, Cursor, Codex, VS Code or your own agent to the Hyperping MCP server in one prompt. Monitors, incidents, on-call and status pages as tools." url: https://hyperping.com/docs/agent-setup --- > Documentation index > Section index: https://hyperping.com/docs/agent-setup/llms.txt > Full docs index: https://hyperping.com/docs/llms.txt # Agent setup: connect AI agents to Hyperping 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. Endpoint `https://api.hyperping.io/v1/mcp` Transport Streamable HTTP, nothing to install Auth Bearer API key, one project per key Tools 49: 28 read, 21 write Plans Free trial, Essentials, Pro and Business Docs [llms.txt](https://hyperping.com/docs/llms.txt), [llms-full.txt](https://hyperping.com/docs/llms-full.txt), Markdown per page ## Set up in one prompt Copy 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. Paste into any coding agent ```text 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 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. ``` ## Create an API key 1. Open API Keys In the dashboard sidebar, open [**API Keys**](https://app.hyperping.io/project/developers). Keys are available during the free trial and on the Essentials, Pro and Business plans. 2. Pick the permission `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. 3. Keep it out of the repo 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. ## Manual setup per client 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. ### Claude Code One command from your terminal: ```bash 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. ```json { "mcpServers": { "hyperping": { "type": "http", "url": "https://api.hyperping.io/v1/mcp", "headers": { "Authorization": "Bearer ${HYPERPING_API_KEY}" } } } } ``` ### Cursor Create `.cursor/mcp.json` at the root of your project, or `~/.cursor/mcp.json` for every project: ```json { "mcpServers": { "hyperping": { "url": "https://api.hyperping.io/v1/mcp", "headers": { "Authorization": "Bearer ${env:HYPERPING_API_KEY}" } } } } ``` ### OpenAI Codex Codex connects to streamable HTTP servers natively and reads the token from an environment variable. One command: ```bash codex mcp add hyperping --url https://api.hyperping.io/v1/mcp \ --bearer-token-env-var HYPERPING_API_KEY ``` Or add it to `~/.codex/config.toml`, or `.codex/config.toml` in a project: ```toml [mcp_servers.hyperping] url = "https://api.hyperping.io/v1/mcp" bearer_token_env_var = "HYPERPING_API_KEY" ``` ### VS Code (GitHub Copilot) 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: ```json { "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}" } } } } ``` ### Windsurf (Devin Desktop) 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`. ```json { "mcpServers": { "hyperping": { "serverUrl": "https://api.hyperping.io/v1/mcp", "headers": { "Authorization": "Bearer ${env:HYPERPING_API_KEY}" } } } } ``` ### Gemini CLI Add the server to `~/.gemini/settings.json`, or `.gemini/settings.json` in a project: ```json { "mcpServers": { "hyperping": { "httpUrl": "https://api.hyperping.io/v1/mcp", "headers": { "Authorization": "Bearer $HYPERPING_API_KEY" } } } } ``` ### Zed Add the server under `context_servers` in Zed's `settings.json`: ```json { "context_servers": { "hyperping": { "url": "https://api.hyperping.io/v1/mcp", "headers": { "Authorization": "Bearer sk_your_key" } } } } ``` ### Claude Desktop and claude.ai 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**: ```json { "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. **My client is not listed** 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. ## Use it from your own agents 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. ```bash 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"}] }' ``` > **Give automated agents a read-only key** > > An agent that runs unattended rarely needs to change anything. A `Read-only` key keeps every write tool out of reach, whatever the prompt says. When an agent does need writes, keep them behind a human: every tool carries MCP annotations that say whether it writes, overwrites something or reaches people outside the dashboard, and clients such as Claude Code use them to ask before running a write. In your own agents, `require_approval` or an allowlist of tools does the same: the Agent SDK example above allows two read tools only, while the Claude API and OpenAI examples run every tool the key allows, so give them a `Read-only` key. Some writes are public or page people: status pages are public, their incidents and maintenance can notify subscribers, and a declared incident pages the on-call responders. ## Try it Once connected, ask in plain language. Each of these maps to one or two tools: - "What is down right now, and since when?" - "Create an HTTP monitor for api.example.com, checked every 30 seconds from London and Frankfurt." - "Add a POST check on our inference endpoint that fails if the response does not contain `"choices"`." - "Which monitors had the worst uptime this month? Give me the SLA numbers." - "Show me the timeline of the last outage on the checkout monitor." - "Who is on call right now for the API monitor?" - "Pause the staging monitors during tonight's migration, then resume them." - "Payments are failing at checkout and no monitor caught it. Declare an incident and page whoever is on call for payments." - "Post an incident on our status page: payments are failing at checkout. Show me the text before you publish it." - "Create a status page at acme.hyperping.app with the API and checkout monitors. Show me the setup before you create it." - "Schedule a maintenance window for the database upgrade on Sunday from 02:00 to 04:00 UTC and announce it on the status page." - "The database upgrade is running late. Extend the maintenance by 30 minutes and post an update on the status page." The server exposes 28 read tools and 21 write tools. The writes cover monitors (`create_monitor`, `update_monitor`, `pause_monitor`, `resume_monitor`), 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`). The full list, with parameters and response shapes, is on the [MCP Integration](https://hyperping.com/docs/mcp) page, and the [product update](https://hyperping.com/blog/product-update-mcp-status-pages-and-incidents) walks through the status page, incident and maintenance tools. ## Give your agent the docs 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`](https://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`](https://hyperping.com/docs/status-page/llms.txt). - [`hyperping.com/docs/llms-full.txt`](https://hyperping.com/docs/llms-full.txt) is the whole documentation in one Markdown file, for tools that index a whole documentation set at once. - Every page has a Markdown version: add `index.md` to its URL, for example [`/docs/agent-setup/index.md`](https://hyperping.com/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`](https://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): AGENTS.md / CLAUDE.md ```text ## 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 /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. ``` ## Monitoring as code For monitors that should live in version control, use the [Terraform provider](https://hyperping.com/docs/community/terraform) 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. ## Security model 1. Keys are project-scoped An API key belongs to exactly one project. Cross-project access returns `404`, even with a valid monitor ID. 2. Read-only is enforced server-side Write tools refuse read-only keys in the tool handler. The agent cannot talk its way around it. 3. No deletes, with one exception 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. 4. Writes are annotated and logged 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](https://hyperping.com/docs/projects/audit-logs) 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. 5. Revocation is immediate 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](https://hyperping.com/docs/mcp) page. ## FAQ ### What is the Hyperping MCP server? A hosted Model Context Protocol server at https://api.hyperping.io/v1/mcp. It exposes a Hyperping project to AI agents as 49 tools: 28 read tools for monitors, uptime, response times, MTTR, MTTA, incidents, alerts, on-call, integrations, status pages, status page incidents and maintenance windows, and 21 write tools to create, update, pause and resume monitors, declare incidents that page on-call and acknowledge, escalate or resolve them, create and edit status pages, publish, update and correct status page incidents, and schedule, change, end or cancel maintenance. There is nothing to install. ### Which AI agents work with Hyperping? 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. ### How does the MCP server authenticate? 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. ### Which plans include the MCP server? 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. ### Can an AI agent delete my monitors? 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. ### What are the MCP rate limits? 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. ### Can AI agents read the Hyperping documentation? 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. ## Next steps [ MCP tool reference→ All 49 tools, transport details, limits, and the security model in depth. ](https://hyperping.com/docs/mcp)[ REST API→ Direct HTTP access to the same resources, with the same API keys. ](https://hyperping.com/docs/api/overview)[ Terraform provider→ Declare monitors, status pages, and escalation policies in HCL. ](https://hyperping.com/docs/community/terraform) [← REST API reference](https://hyperping.com/docs/api/overview)[MCP Integration →](https://hyperping.com/docs/mcp) [](https://x.com/hyperping)[](https://www.linkedin.com/company/hyperping) © 2026 Hyperping