UptimeEye MCP server

Quick start

1. Create a management key

In the app open API Keys → New API Key, choose the type “Management” and copy the key. It starts with ue_live_ and is shown once. Log ingest keys (ue_ingest_) do not work here.

2. Add the server to your client

Endpoint: https://api.uptimeeye.com/mcp (streamable HTTP), authenticated with Authorization: Bearer ue_live_…. With Claude Code it is one command:

claude mcp add --transport http uptimeeye https://api.uptimeeye.com/mcp \
  --header "Authorization: Bearer ue_live_XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"

3. Ask

Try “List my UptimeEye monitors” — then describe what you want monitored. The assistant looks up your notification channels first, because every monitor needs one.

Connect your client

Claude Code

Add --scope project to share the server with your team via .mcp.json — then keep the key in an environment variable instead of the file.

claude mcp add --transport http uptimeeye https://api.uptimeeye.com/mcp \
  --header "Authorization: Bearer $UPTIMEEYE_API_KEY"

Cursor

Global in ~/.cursor/mcp.json, or per project in .cursor/mcp.json:

{
  "mcpServers": {
    "uptimeeye": {
      "url": "https://api.uptimeeye.com/mcp",
      "headers": { "Authorization": "Bearer ue_live_XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" }
    }
  }
}

VS Code (GitHub Copilot agent mode)

VS Code prompts for the key once and stores it securely:

{
  "inputs": [
    { "type": "promptString", "id": "uptimeeye-key", "description": "UptimeEye API key (ue_live_…)", "password": true }
  ],
  "servers": {
    "uptimeeye": {
      "type": "http",
      "url": "https://api.uptimeeye.com/mcp",
      "headers": { "Authorization": "Bearer ${input:uptimeeye-key}" }
    }
  }
}

Claude Desktop

Claude Desktop starts local servers only, so it connects through the mcp-remote bridge (needs Node.js). Add this to claude_desktop_config.json and restart the app:

{
  "mcpServers": {
    "uptimeeye": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://api.uptimeeye.com/mcp", "--header", "Authorization:${UPTIMEEYE_AUTH}"],
      "env": { "UPTIMEEYE_AUTH": "Bearer ue_live_XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" }
    }
  }
}

Other clients: anything that supports remote MCP servers over streamable HTTP with a custom header works with the endpoint and header above.

Available tools

Tools carry MCP annotations: read-only tools are marked as such, delete tools as destructive, so well-behaved clients ask before running them.

Scheduled tasks are pinged by your job: GET https://api.uptimeeye.com/v1/beat/{taskId} on success. Optional: /start when the run begins and /fail to report a failed run and alert immediately. GET, POST and HEAD are all accepted.

Example prompts

• “Monitor https://shop.example.com every minute from eu-central-1 and us-east-1, alert me by email at ops@example.com if it's down or slower than 2 seconds.”
• “Create a heartbeat for our nightly backup at 02:30 Europe/Berlin with 30 minutes grace and give me the curl line for the crontab.”
• “Alert me if our Postgres at db.example.com:5432 stops accepting connections — check every minute.”
• “Which monitors are currently down, and are there open incidents?”
• “Tag every monitor whose URL contains staging with staging and pause them.”
• “Move all monitors from the ‘Old alerts’ channel to ‘On-call’, then delete ‘Old alerts’.”

Set up a project with an AI agent

Coding agents (Claude Code, Cursor, Copilot) can read your repository and the UptimeEye docs at the same time. Paste one of these prompts into the agent in your project; it finds the endpoints, jobs and stack by itself.

Monitor every public endpoint

Read https://uptimeeye.com/llms.txt. Find the public URLs and health endpoints of this project
(routes, deployment config, README). Using the UptimeEye MCP server, create one monitor per endpoint:
30 s interval if my plan allows it, expected status 200, attached to the notification channel I pick.
Show me the list before you create anything.

Add heartbeats to cron jobs

Find every cron job, scheduled worker and CI schedule in this repository. For each one, create an
UptimeEye scheduled task via MCP with the matching schedule and a sensible grace period. Then change
the job so it calls https://api.uptimeeye.com/v1/beat/<taskId> on success and https://api.uptimeeye.com/v1/beat/<taskId>/fail on error.

Ship logs

Add UptimeEye log shipping to this project. Follow https://uptimeeye.com/docs/logs/ingest and pick
the integration guide that matches our stack (Kubernetes, Docker, OpenTelemetry, Node.js, Python, Go,
Spring Boot, .NET, …). Read the ingest key from the environment variable UPTIMEEYE_INGEST_KEY and use
service and env as stream fields.

Permissions & safety

• A management key acts on one organization with the same rights as the REST API. Create one key per client so you can revoke them separately.
• Delete tools are annotated as destructive and the server instructs the assistant to ask for explicit confirmation first.
• Plan limits apply exactly as in the app — the assistant cannot exceed your monitor count or minimum interval.
• Keys are stored hashed; the plain key is shown once at creation. Requests are processed in the EU (Germany).

Prefer infrastructure as code? The same operations are available through the Terraform provider.

FAQ

What is the UptimeEye MCP server?

A Model Context Protocol endpoint at https://api.uptimeeye.com/mcp (streamable HTTP). AI assistants that speak MCP can list, create and change monitors, cron job heartbeats and notification channels of your organization — the same operations as the REST API and the Terraform provider.

Which plan do I need?

Any plan, including Free. The assistant works within your plan's limits: if you ask for more monitors or a shorter interval than the plan allows, the tool returns the limit and the assistant tells you.

Which clients work?

Every MCP client that can send an Authorization header over streamable HTTP: Claude Code, Cursor, VS Code, Windsurf and others. Clients that only support local stdio servers (such as Claude Desktop) connect through the mcp-remote bridge. Web connectors that require OAuth are not supported yet.

Can the assistant set up Slack, Teams or PagerDuty alerts?

Not over MCP — these integrations need an interactive authorization in the app. Create the channel once in the app, then the assistant can attach any monitor to it by id. Email and webhook channels can be created directly over MCP.

Can the assistant read my logs?

Not yet. Log search is available in the app and over the API; MCP tools for logs are planned. To ship logs, follow the Logs docs — a coding agent can do that setup for you (see the prompts above).

How do I revoke access?

Delete the key under API Keys in the app. Every client using it loses access immediately.