MCP server

Let AI assistants such as Claude, Cursor and VS Code check and manage your monitors.

UptimeDuck runs a Model Context Protocol (MCP) server. MCP is an open standard that lets AI assistants call tools in other services. Once connected, you can ask your assistant things like "Which of my monitors are down?", "How was the uptime of my API last week?" or, with read & write access, "Pause the staging monitors".

The assistant acts as you, in one workspace, with the access level you gave it and never more than your role in that workspace allows. There are two ways to connect: sign in from your assistant, or paste an API token into its settings.

Most assistants can connect by signing in, with nothing to copy or store. Add this server URL to your assistant:

https://mcp.uptimeduck.com/mcp

Your assistant opens UptimeDuck in your browser. Log in if you are not already.
If the assistant asks for write access, choose the Access: Read only or Read & write (see Scopes). If you belong to more than one workspace, choose the workspace too.
Click Allow. The assistant is connected and appears under Connected apps in API & Integrations, where you can disconnect it at any time.

Claude (web and desktop): Settings → Connectors → Add custom connector, then paste the URL.
Claude Code: run claude mcp add --transport http uptimeduck https://mcp.uptimeduck.com/mcp, then /mcp and choose Authenticate.
Cursor: add "uptimeduck": { "url": "https://mcp.uptimeduck.com/mcp" } under mcpServers in ~/.cursor/mcp.json, then click Connect next to it in Cursor Settings.
VS Code: add "uptimeduck": { "type": "http", "url": "https://mcp.uptimeduck.com/mcp" } under servers in .vscode/mcp.json and start the server. VS Code asks you to sign in.
Other clients: any MCP client that supports OAuth sign-in. The server supports dynamic client registration, so there is no client ID to set up.

Signing in works on every plan, Free included. If your assistant cannot sign in, use an API token instead.

Use an API token instead

Use a token for clients that cannot sign in, or for scripts. First create one:

In panel.uptimeduck.com, open the account menu at the bottom of the sidebar and choose API & Integrations.
Click Create token and give it a name you will recognise, such as Claude Desktop.
Pick a Scope: Read only or Read & write (see Scopes).
Pick an Expiry: 30 days, 90 days (default), 180 days, 1 year or never.
Copy the token. It starts with udk_ and is shown only once.

API tokens are available on every plan, Free included. Each plan sets how many active tokens you can have at the same time: 1 on Free, 10 on Starter, 50 on Medium, 100 on Large and 300 on Enterprise. See Plans & limits. Assistants that sign in do not count toward this limit.

Connect with a token

The server uses the Streamable HTTP transport. Every request needs your token in an Authorization header.

Server URL	`https://mcp.uptimeduck.com/mcp`
Header	`Authorization: Bearer YOUR_API_TOKEN`

Replace YOUR_API_TOKEN with your token in the examples below.

Claude Code

claude mcp add --transport http uptimeduck https://mcp.uptimeduck.com/mcp \
  --header "Authorization: Bearer YOUR_API_TOKEN"

Run /mcp inside Claude Code to check that uptimeduck is connected.

Claude Desktop

To use a token instead of signing in, Claude Desktop connects through the mcp-remote helper, which needs Node.js. Open Settings → Developer → Edit Config and add this to claude_desktop_config.json, then restart Claude Desktop:

{
  "mcpServers": {
    "uptimeduck": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://mcp.uptimeduck.com/mcp",
        "--header",
        "Authorization:${UPTIMEDUCK_AUTH}"
      ],
      "env": {
        "UPTIMEDUCK_AUTH": "Bearer YOUR_API_TOKEN"
      }
    }
  }
}

Cursor

Add the server to ~/.cursor/mcp.json for all projects, or .cursor/mcp.json for one project:

{
  "mcpServers": {
    "uptimeduck": {
      "url": "https://mcp.uptimeduck.com/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_TOKEN"
      }
    }
  }
}

Do not commit a project file that contains your token.

VS Code

Add this to .vscode/mcp.json in your workspace, or run MCP: Open User Configuration from the Command Palette. VS Code asks for the token the first time and stores it securely, so it is not saved in the file:

{
  "inputs": [
    {
      "type": "promptString",
      "id": "uptimeduck-token",
      "description": "UptimeDuck API token",
      "password": true
    }
  ],
  "servers": {
    "uptimeduck": {
      "type": "http",
      "url": "https://mcp.uptimeduck.com/mcp",
      "headers": {
        "Authorization": "Bearer ${input:uptimeduck-token}"
      }
    }
  }
}

Other MCP clients that support Streamable HTTP with custom headers work the same way with a token: use the server URL and the Authorization header above. To check the connection, ask your assistant to run whoami.

Tools

These tools only read data and work with any connection:

Tool	What it does
`whoami`	The account, workspace, plan and token scope the token acts as.
`list_monitors`	Uptime monitors with their current status. Can filter by status and project.
`get_monitor`	Settings, status, last failure reason, and uptime and response times for the last 24 hours. Heartbeat monitors include their push URL.
`get_monitor_stats`	Uptime percentage and response times for the last 24 hours, 7 days or 30 days.
`get_monitor_results`	The most recent check results: time, region, status, status code, response time and error.
`list_incidents`	Downtime incidents with start, end, duration and cause. Defaults to the last 30 days.
`list_server_monitors`	Servers running the UptimeDuck agent, with online status and CPU, RAM and disk usage.
`get_server_monitor`	One server's status, hardware, resource usage and monitored disks.
`list_projects`	Projects with their overall status, monitor counts and status page link.
`get_status_page`	A project's public status page: whether it is published, its URL, custom domain and title.
`list_regions`	Monitoring regions and their codes.
`list_notification_channels`	Alert channels with their type, name and whether they are enabled. Channel settings such as webhook URLs are never returned.

These tools change data and need Read & write access:

Tool	What it does
`create_monitor` write	Create an HTTP(s), TCP, Ping, blacklist (RBL) or Minecraft server monitor.
`create_heartbeat_monitor` write	Create a cron monitor and return its heartbeat URL. Like in the panel, it starts paused: point your job at the URL, then call `resume_monitor`.
`update_monitor` write	Change a monitor's name, target, interval, regions, alert channels and other settings.
`pause_monitor` write	Pause a monitor so it stops checking and alerting.
`resume_monitor` write	Resume a paused monitor.
`delete_monitor` write	Delete a monitor and its history. The assistant must pass `confirm: true`, otherwise nothing is deleted.
`assign_monitor_to_project` write	Move a monitor into a project, or remove it from its project.

Write tools follow the same rules as the panel: the same validation and the same plan limits on monitors, intervals, regions and alert channels. When a limit is reached, the tool returns the error code PLAN_LIMIT_REACHED and nothing is changed. Every change made through a write tool is recorded with the token or connected app that made it.

Scopes

Scope	Can do
Read only	Use the read tools. Write tools are refused with `FORBIDDEN`.
Read & write	Use all tools, as long as your role in the workspace can manage monitors.

The same two levels apply whether you sign in or use a token.

A connection never has more access than you: if you are a team member with view-only access, read & write access still cannot change anything. Start with read only and give read & write only when you want the assistant to make changes. Tokens also work with the REST API at https://api.uptimeduck.com/api/v1, with the same scopes.

Rate limit

Each token can make 120 requests per minute by default. Above that, requests get HTTP 429 until the minute is over. Assistants usually make a few requests per question, so this is rarely reached.

Security

Treat a token like a password. Anyone who has it can use UptimeDuck as you, within its scope.
UptimeDuck stores only a hash of the token. If you lose it, revoke it and create a new one.
Revoke a token at any time from API & Integrations. It stops working immediately. The page also shows when each token was last used.
Tokens expire after 90 days unless you choose another expiry. Expired tokens stop working and stay listed so you can see what to replace.
Never expires is available, but a token like that keeps working until you revoke it. If it leaks, it can be used for as long as you have not noticed. Prefer an expiry date where you can.
Use one token per assistant or device, so you can revoke one without breaking the others.
Signed-in assistants get short-lived access that renews on its own. Disconnect one under Connected apps to cut it off immediately.