How to Set Up Uptime Monitoring in Cursor with MCP

You just finished writing a new API endpoint. Tests pass locally. CI is green. You're about to merge and deploy. But there's one more thing — you need a monitor on that endpoint so you know when it breaks at 2 AM.

Normally this means opening a browser tab, navigating to your monitoring dashboard, filling out a form, and copying a URL from your code. It's not hard, but it's a context switch, and context switches add up.

With CronAlert's MCP server running in Cursor, you skip all of that. Open Composer, tell the AI to create a monitor for your endpoint, and you're done. You can also pull up uptime stats, investigate incidents, and manage monitors — all without leaving your editor.

What is MCP and why does Cursor support it?

MCP (Model Context Protocol) is an open standard that lets AI assistants call external tools and services. Think of it as a plugin system for AI — instead of the model only generating text, it can take actions like creating a monitor, querying an API, or posting an incident update.

Cursor has native MCP support baked into its AI features. When you configure an MCP server, Cursor's Composer and Agent mode gain access to that server's tools. The AI decides when to call them based on what you ask. This is what makes it possible to do uptime monitoring from inside your editor — CronAlert exposes its API as MCP tools, and Cursor's AI knows how to use them.

Prerequisites

Before you start, make sure you have:

• Cursor — Pro or Business plan (MCP is not available on the free tier)
• Node.js 18+ — the MCP server runs as a Node process
• A CronAlert account — the free plan works fine, you get 25 monitors

Setup in four steps

Head to cronalert.com/app/settings/api-keys and generate a new API key. Give it a descriptive name like "Cursor MCP" so you remember what it's for. Copy the key — you'll only see it once.

In your project root, create a .cursor/mcp.json file:

{
  "mcpServers": {
    "cronalert": {
      "command": "npx",
      "args": ["-y", "cronalert-mcp"],
      "env": {
        "CRONALERT_API_KEY": YOUR_API_KEY
      }
    }
  }
}

This is a project-level config — the MCP server will only be available when you have this project open in Cursor. If you want CronAlert available across all your projects, put the file at ~/.cursor/mcp.json instead. More on that distinction later.

Open the command palette (Cmd+Shift+P on Mac, Ctrl+Shift+P on Windows/Linux) and run Reload Window. Alternatively, just restart Cursor.

To verify the server connected, go to Cursor Settings > MCP. You should see "cronalert" listed with a green status indicator. If it shows red or disconnected, check the troubleshooting section in the FAQ below.

Open Composer (Cmd+I / Ctrl+I), make sure you're in Agent mode, and try something like:

"List all my monitors and tell me their current status."

Cursor's AI will call the list_monitors tool, fetch your monitors from CronAlert, and summarize the results. If you don't have any monitors yet, ask it to create one.

Workflow examples

The real value of having monitoring in your editor isn't just convenience — it's that monitoring becomes part of your development workflow instead of a separate chore. Here are the patterns that work well in practice.

Deploy and monitor in one shot

You just deployed a new health check endpoint. Instead of context-switching to a dashboard:

"Create a monitor for https://my-api.com/v2/health that expects a 200 status code."

The AI calls create_monitor with the URL and expected status. Your endpoint is monitored within seconds of deploying it.

Pre-merge sanity check

Before merging a big PR, you want to make sure nothing is already on fire:

"List all my monitors and tell me if any are currently down."

The AI fetches your monitor list, checks the status of each one, and gives you a summary. If something is failing, you probably want to know before you ship more changes.

Debug a production issue

Your on-call notification fires. You open Cursor (because that's where you'll fix it anyway) and start investigating:

"My API monitor is showing failures — get the recent check results and help me figure out what's going on."

The AI pulls check history with get_check_results, looks at response times and status codes, and helps you identify the pattern — maybe response times spiked before the failures started, or maybe a specific region is failing while others are fine.

Maintenance mode

You're about to do a database migration that will cause a few minutes of downtime. You don't want false alerts flooding your Slack channel:

"Pause all monitors that check auth.myapp.com — I'm doing maintenance on the auth service."

The AI lists your monitors, finds the ones matching that domain, and pauses them. When you're done, ask it to resume them.

Incident communication

There's an active incident and you need to update your status page while simultaneously working on the fix:

"Post an update on the current API incident — say we've identified a database connection pool exhaustion issue and are deploying a fix."

The AI calls add_incident_update to post the update to your status page. Your users stay informed while you stay focused on the code.

Project-level vs. global config

You have two options for where to put your MCP config, and the right choice depends on your situation.

.cursor/mcp.json in the project root — this is scoped to the project. Great for teams because you can commit the file to version control, and everyone on the team gets the MCP integration automatically. Just make sure you use a placeholder for the API key and document how to set it. Something like this in your README works:

Copy .cursor/mcp.json.example to .cursor/mcp.json and replace YOUR_API_KEY with your CronAlert API key.

~/.cursor/mcp.json in your home directory — this is global. The MCP server will be available in every project you open. This is the better option if you're a solo developer or if you want CronAlert available everywhere without adding config files to every repo.

Tips for getting the most out of Cursor + CronAlert

• Use Agent mode. Cursor's Composer has multiple modes. Agent mode is the one that can chain multiple MCP tool calls together — for example, listing monitors, finding the right one, and then fetching its check results in a single conversation.
• Combine with code edits. MCP tools work alongside Cursor's normal code editing. You can fix a bug in your endpoint and update the monitor's configuration in the same Composer session.
• Check MCP status. If something isn't working, go to Cursor Settings > MCP. The status indicator will tell you if the server is connected, disconnected, or erroring. This is the first place to look when troubleshooting.
• Be specific in prompts. "Create a monitor for my-api.com/health with a 200 expected status" works better than "monitor my API." The more context you give, the fewer follow-up questions the AI needs to ask.

Available MCP tools

CronAlert's MCP server exposes 11 tools. Here's the full list:

The AI in Cursor will pick the right tool based on what you ask. You don't need to memorize these — just describe what you want in natural language.

FAQ

Does MCP work in Cursor's free tier?

No. MCP requires Cursor Pro or Business. The free tier doesn't include MCP support. CronAlert's free plan works fine on the monitoring side though — you get 25 monitors at 3-minute intervals, which is plenty for most side projects.

Can I share the MCP config with my team?

Yes. Commit .cursor/mcp.json to your repository, but use a placeholder for the API key instead of a real value. Each developer generates their own key at cronalert.com/app/settings/api-keys and fills it in locally. If your team uses a shared CronAlert account, you can use a team API key — just don't commit it to the repo.

What if Cursor shows the MCP server as disconnected?

Three things to check:

1. Node.js version — run node --version in your terminal. You need 18 or higher.
2. Valid JSON — a missing comma or bracket in mcp.json will silently fail. Paste it into a JSON validator if you're unsure.
3. Reload the window — Cmd+Shift+P > "Reload Window." Cursor sometimes needs a kick after adding a new MCP config.

If it still won't connect, check the Cursor developer console (Cmd+Shift+I) for error messages from the MCP process.

Is there a VS Code extension instead?

Not currently. VS Code doesn't support MCP natively, so there's no equivalent integration. If you're not using Cursor, you can still use CronAlert's web dashboard or REST API directly. But if you want AI-powered monitoring inside your editor, Cursor is the way to go.