MCP server for uptime monitoring

Let any AI agent create, check, and manage your monitors itself.

Your monitors, in your agent's hands.

  • The server exposes five tools and they cover everything the dashboard does: list_monitors for current status and 24h stats, create_monitor with only a URL required, test_monitor to run one check against a draft without saving, update_monitor for edits and for enabled: false to pause, and delete_monitor.

    Say "monitor my site" and the agent drives the rest. Say "is checkout slow because of us or the network?" and it reads connect time against time to first byte and tells you.

  • The interesting flow isn't you asking an agent to make a monitor. It's the agent doing it unprompted: it deploys a service, calls test_monitor to confirm the endpoint answers, then create_monitor to put it under watch, and the thing it just shipped is being checked before the deploy log scrolls away.

    Because create returns the first check's result, the agent knows immediately whether it pointed the monitor at the right URL, and corrects itself without a human in the loop.

  • test_monitor runs one real check against a config that doesn't exist yet and returns the latency breakdown a scheduled check would log. An agent can try a URL, a header, or a content rule, read the result, and only then create the monitor.

    It's the difference between an agent that guesses and one that checks its work, and it costs one call.

  • Authentication is a Bearer project API key, created in your project's Settings under Access tokens. A key binds to one project, so a connected agent can only touch that project's monitors; it can never create more keys or reach account settings.

    Give it an expiry for a throwaway experiment, and revoke it any time from the same list. The blast radius of a confused agent is one project's monitors, and nothing it does there is irreversible except delete.

Connect it in one line

UptimeX ships a remote MCP server at /mcp, speaking stateless streamable HTTP, which every current Model Context Protocol client supports. There is nothing to install or host.

In Claude Code it's one command. For clients configured by file, the JSON block is the whole setup: the endpoint and an Authorization header carrying a project key. In clients with a connector UI, paste the same two values.

More for developers.

Everything the dashboard does, the API does.

Create, test, update, mute, and delete monitors over HTTPS with a project key. The dashboard is one client of it, not a layer above it.

A POST to your endpoint when state changes.

The generic webhook carries a structured envelope, once when a monitor breaks and once when it recovers. Free on every plan.

A reference generated from the API itself.

Every endpoint, parameter, and schema comes from the OpenAPI document the API serves, so the docs can't describe a backend that isn't deployed.

One key, one project, revocable any time.

Project API keys authenticate the REST API and the MCP server alike. A key reads and writes its project's monitors and nothing else.

MCP Server questions

Any client that speaks the Model Context Protocol over streamable HTTP, which every current client does: Claude, Claude Code, or an agent you build yourself. Add it as a remote server with one URL and an Authorization header.

Five: list_monitors, create_monitor, update_monitor, delete_monitor, and test_monitor. Between them an agent can see status and 24h stats, register new monitors, pause or edit existing ones, and dry-run a config without saving it.

No. MCP access is included on every plan, with the same project API keys as the REST API. Plan limits still apply: a create that fails with monitor_limit means you've hit your monitor cap.

One project's monitors, nothing more. The key it authenticates with is project-scoped, can't mint more keys, and can't reach account settings. You can give it an expiry and revoke it from Settings at any time.

Know the second it breaks

Free to start. No credit card.