MCP server
The Oh Dear MCP server lets AI assistants query your monitoring data and, if you allow it, manage your monitors, status pages, and maintenance windows through the Model Context Protocol. Ask questions about your monitors, uptime, broken links, DNS, performance, sitemaps, and more, in natural language.
It speaks the standard protocol over HTTP, so this isn't a Claude-only thing. ChatGPT, Codex, Cursor, VS Code, Gemini CLI, Zed, and Windsurf all connect to the same URL.
The MCP server works with the monitoring data we already collect. AI-powered monitoring is the check that uses AI to verify what your pages actually display.
Connect #
Add this URL to your AI client as an MCP server (some clients call it a "custom connector"):
https://ohdear.app/mcp
The client redirects you to Oh Dear. You log in (if you aren't already), pick the team to share, and choose which permissions to grant. After approving, you're bounced back to your client and the connection is live.
We speak plain OAuth 2.1 with PKCE and Dynamic Client Registration, so every client below sorts out its own credentials. There's nothing to copy and paste, no API key to generate, and no allowlist to add your client's callback URL to. The connection appears under Connected AI assistants, where you can revoke it any time.
Claude.ai and Claude Desktop #
Open Settings, then Connectors, then "Add custom connector", and paste the URL above. Claude walks you through the approval.
Claude Code #
claude mcp add --transport http ohdear https://ohdear.app/mcp
Claude Code opens the OAuth flow on first use.
ChatGPT #
You'll need developer mode, which is available on Pro, Plus, Business, Enterprise, and Education plans, and only on the web.
Turn it on under Settings, Security and login, Developer mode. Then head to chatgpt.com/plugins, create a new app for a remote MCP server, and paste the URL above with OAuth as the authentication method.
OpenAI Codex #
codex mcp add ohdear --url https://ohdear.app/mcp
codex mcp login ohdear
Or add it to ~/.codex/config.toml yourself and run the login command afterwards:
[mcp_servers.ohdear] url = "https://ohdear.app/mcp"
Cursor #
Add this to ~/.cursor/mcp.json for every project, or to .cursor/mcp.json for a single one:
{ "mcpServers": { "ohdear": { "url": "https://ohdear.app/mcp" } } }
Cursor registers itself and starts the OAuth flow the first time it connects.
VS Code and GitHub Copilot #
Add this to .vscode/mcp.json in your project, or run "MCP: Open User Configuration" from the command palette to set it up once for every project:
{ "servers": { "ohdear": { "type": "http", "url": "https://ohdear.app/mcp" } } }
Gemini CLI #
gemini mcp add --transport http --scope user ohdear https://ohdear.app/mcp
Watch out for one thing if you edit ~/.gemini/settings.json by hand: the key is httpUrl, not url. Gemini reads url as an SSE endpoint, and ours isn't one.
{ "mcpServers": { "ohdear": { "httpUrl": "https://ohdear.app/mcp" } } }
Zed #
Open Settings, AI, MCP Servers, then "Add Server", then "Add Remote Server", and paste the URL above. Zed prompts you to authenticate the first time it connects.
Windsurf #
In ~/.codeium/windsurf/mcp_config.json, note that the key here is serverUrl:
{ "mcpServers": { "ohdear": { "serverUrl": "https://ohdear.app/mcp" } } }
Anything else #
If your client only speaks stdio, or its OAuth support is patchy, mcp-remote bridges the two and handles the OAuth flow for you. This works anywhere you can configure a command:
{ "mcpServers": { "ohdear": { "command": "npx", "args": ["-y", "mcp-remote", "https://ohdear.app/mcp"] } } }
The first request opens a browser window for approval; after that the token is stored locally and reused. Worth knowing: JetBrains AI Assistant can talk to remote MCP servers but doesn't run the OAuth flow itself yet, so mcp-remote is the way in there.
One catch across all of these: the approval needs a browser on the same machine, because the client listens on localhost for the callback. Over a bare SSH session with no browser, the flow can't complete.
From your own code #
If you're building on the OpenAI Responses API, point it at us as a hosted MCP tool:
{ "type": "mcp", "server_label": "ohdear", "server_url": "https://ohdear.app/mcp", "authorization": "" }
The authorization field wants an access token you already have, and OpenAI won't store it, so you need to send it on every request. That means running the OAuth flow yourself against https://ohdear.app/oauth/authorize and https://ohdear.app/oauth/token, or refreshing a token you obtained earlier. Our metadata lives at /.well-known/oauth-authorization-server if you'd rather discover the endpoints than hardcode them.
Permissions #
The consent screen offers two scopes:
- Read access (always granted): read your monitors, uptime, broken links, DNS, performance, sitemaps, cron checks, SSL certificates, status pages, existing maintenance windows, tag groups, and the notification destinations configured at team, tag, monitor, and tag-group level.
- Write access (opt-in): create, update, and delete monitors, monitor settings, status pages, recurring maintenance windows, and tag groups with their notification destinations. That covers more than tidying up: your assistant can post status page updates that email your subscribers, delete downtime history, add new places for your alerts to go, and snooze checks.
Both connection types can also report missing MCP or API functionality. Submitting feedback doesn't require permission to change your monitors or settings.
Each connection covers one team, so every tool call operates on that team. Want your assistant to work with a second team? Add the server to your client a second time under another name, and pick the other team there. Approving the same client again doesn't add a team: the new approval replaces the earlier connection.
A read-only connection doesn't get to see credentials. For the request headers and payloads you've set on a check, it learns which names are configured, not their values. URLs come back without a username or password, and with the query string hidden, since that's where tokens tend to live. It doesn't see the ping URLs of your cron checks either, because anyone holding one can fake a heartbeat. A connection with write access does get these values for the monitors you're allowed to edit, since it needs them to send a changed list back.
A few things stay hidden from every connection, write access or not: the secret of a private status page, the Application Health secret, and where a notification destination delivers to. For those, tools only say whether something is configured.
The consent screen also shows the address we'll send the authorization to. Any app can register with us under any name, so if the name says one thing and the address says another, cancel and check where the link came from. You can revoke a connection any time from Connected AI assistants.
What you can do #
Examples:
- "Show me all my Oh Dear monitors"
- "Which monitors have issues right now?"
- "Show me how the monitor for example.com is set up, checks and all"
- "How is the uptime check on example.com configured?"
- "What's the uptime for example.com over the last 24 hours?"
- "Are there any broken links on example.com?"
- "Is example.com still loading anything over plain http?"
- "How many URLs did the last crawl of example.com visit?"
- "Show DNS history for example.com"
- "What are the latest Lighthouse scores?"
- "Show recurring maintenance periods for example.com"
- "List my status pages"
- "Create a weekly maintenance window for Mondays at 4am"
- "Push the end of tonight's maintenance window for example.com back to 23:00"
- "Mark the latest incident update on my status page as resolved"
- "Give the nightly-backup cron check 30 minutes of grace time"
- "Add a new monitor for https://example.com with broken-link checks"
- "Rename the monitor for example.com to 'Marketing site'"
- "Enable the Lighthouse check on example.com without touching its other checks"
- "Enable the Application Health check for example.com with https://example.com/oh-dear-health-check-results as the URL and the secret from my .env file"
- "Delete the monitor for old-site.com"
- "Group the 'client-acme' tag and send its alerts to ops@acme.com"
- "List my tag groups and where their notifications go"
- "Show the notification destinations for the 'production' tag"
- "Change the alert types on the 'On-call' tag-group destination to uptime only"
- "Treat 401 responses as healthy for the staging monitor"
- "Point the example.com monitor at /health and check that the JSON says status is ok"
Updates only change what you ask for. Tell your assistant to push back the end of a maintenance window, and its start time and name stay exactly as they were. The same goes for monitors, cron checks, status pages, incident updates, tag groups, and notification destinations.
Your assistant can set the Application Health secret, but it can't read the stored one back: tools only tell you whether a secret is configured. We won't send a stored secret to a new site either. Move the health report URL to another site and your assistant has to pass the secret along in the same request. The same goes for the custom headers of a webhook destination. A secret you ask it to set does pass through your conversation, so treat that transcript like any other place you'd paste a secret.
Limits #
A few guardrails keep a runaway assistant from hammering your account, or ours:
- Each connection can make 100 requests per minute, and all your connections together 500. Go over either and we answer with a
429until the minute is up. - Uptime statistics come back grouped per hour unless you ask for something else, with at most 500 intervals per call. For a longer period, ask for a coarser grouping: a year per day is fine, a year per minute isn't.
- Some of what your assistant reads was written by the sites we monitor, not by us: link text on a crawled page, the message of a failing health check, ... We cut that text at 500 characters and lists at 100 items, and tell the assistant to treat it as data, not as instructions. That lowers the odds of a page talking your assistant into something, it doesn't rule it out. Let your client ask for confirmation before it changes or deletes anything.
Report missing functionality #
If your AI assistant can't finish a task because an MCP tool or API capability is missing, it can tell us through report_missing_functionality. This helps us decide what to add next. You can also ask it: "Report the missing functionality to Oh Dear."
The assistant should check the available tools or API documentation first. A missing permission, invalid input, or temporary failure isn't a feature gap. Send one report per distinct gap in a conversation.
The tool accepts these fields:
interface(required):mcporapi, depending on where the capability is missing. API gaps are still reported through this MCP tool, not a separate API endpoint.intended_action(required, up to 2,000 characters): what you wanted to accomplish.limitation(required, up to 4,000 characters): what was missing and why the available alternatives didn't work.attempted_operation(optional, up to 500 characters): the tool name or HTTP method and endpoint path you tried or checked. Leave it out if no relevant operation exists.
For example, the assistant could call report_missing_functionality with:
{ "interface": "mcp", "intended_action": "Export notification history.", "limitation": "No tool exposes past deliveries.", "attempted_operation": "list_notification_destinations" }
We store the full report with the connected user and team, and send it to the Oh Dear team's internal Slack channel with your name, email address, team, and AI client name when available. Include only the technical details needed to explain the gap. Leave out credentials, other personal data, request payloads, query strings, and conversation transcripts.
A successful call returns success: true, a report_id, and a confirmation message. It records feedback; it doesn't perform the blocked action, open a support ticket, or promise that we'll build the feature. Each call creates a new report, so there's no need to submit it again after receiving confirmation. A team can send 10 reports per hour, and so can one person across all their teams. Beyond that, the tool answers with an error and the report isn't recorded.
Manage connections #
Visit Connected AI assistants to see every AI assistant connected via OAuth, when each was last used, and revoke any of them.
Connections follow team membership. Remove someone from a team and their connections to that team stop working right away. The same happens to every connection of a team you delete.
What we log #
We log every tool call: which tool ran, with which arguments, whether it worked, and how long it took. That's how we debug problems and find out which tools need work.
Before storing the arguments, we take out the places credentials normally live:
- Notification destinations, and anything passed under a name like secret, token, password, or API key, become
[redacted]. - Of request headers and payloads, we keep the names and drop the values.
- URLs lose their username and password, and their query string.
- Text shaped like a well-known token (a Bearer token, a Slack webhook URL, ...) becomes
[redacted]wherever it shows up. - Arguments a tool doesn't know aren't stored, and neither are arguments too large to be useful.
That isn't a guarantee. A password typed into a free-text field, like a monitor's notes, looks like any other sentence to us and is stored as sent. Keep credentials out of those fields. We delete log entries after one year.
Feel free to reach out via support@ohdear.app or on X via @OhDearApp if you have any other questions. We'd love to help!