How to Set Up Uptime Monitoring in Windsurf with MCP

Windsurf's Cascade agent is great at writing code, refactoring, and navigating large codebases. But most development work does not end at the last commit. You deploy services, and those services need monitoring. Typically that means switching to a browser, logging into a dashboard, and clicking through forms to set up health checks. It is a workflow that feels disconnected from the editor where you do everything else.

With CronAlert's MCP server, you can bring uptime monitoring directly into Windsurf. Cascade gets access to 11 monitoring tools — creating monitors, checking uptime stats, managing incidents, posting status updates — all from the same panel where you write and review code. This guide walks through the setup and shows you how to make the most of it.

What is MCP and why does it matter in Windsurf?

The Model Context Protocol (MCP) is an open standard that lets AI agents connect to external services through a structured interface. Instead of pasting API responses into a chat, the AI calls tools directly and gets structured data back. Windsurf has built-in MCP support, which means any MCP-compatible service can plug into Cascade as a set of callable tools.

CronAlert publishes an MCP server as an npm package (cronalert-mcp) and also hosts a remote endpoint. Once you register either one with Windsurf, Cascade gains the ability to interact with your monitoring infrastructure — listing monitors, pulling response time data, handling incidents — without you ever leaving the editor.

Prerequisites

• Windsurf IDE (Pro or Team plan for MCP support)
• Node.js 18+ — required for the npm method, not needed for the remote server method
• A CronAlert account — the free plan works, no credit card required
• A CronAlert API key — generate one at Settings > API Keys

Setup: npm method

This is the recommended approach. The MCP server runs locally on your machine via stdio transport, so tool calls are fast and your API key never leaves your computer except when making authenticated requests to CronAlert's API.

Log in to CronAlert and go to Settings > API Keys. Click "Create API Key," give it a name (e.g., "Windsurf"), and copy the key. You will not be able to see it again after leaving the page.

You have two ways to get to Windsurf's MCP configuration:

• From Windsurf: Click the MCP icon in the top-right corner of the Cascade panel, then select "Configure." This opens the config file in the editor.
• Directly: Open ~/.codeium/windsurf/mcp_config.json on macOS/Linux, or %USERPROFILE%\.codeium\windsurf\mcp_config.json on Windows.

Add the following to your mcp_config.json. If the file already has other servers, add the cronalert entry inside the existing mcpServers object.

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

Replace YOUR_API_KEY with the key you copied in step 1.

Save the file. Windsurf picks up MCP config changes automatically in most cases, but you may need to reload the window (Cmd+Shift+P or Ctrl+Shift+P, then "Developer: Reload Window"). Once loaded, Cascade has access to all 11 CronAlert tools. You can verify by asking Cascade: "What MCP tools do you have available?"

Alternative: remote server setup

If you do not want to install Node.js or deal with npm, Windsurf also supports remote MCP servers. CronAlert hosts a Streamable HTTP endpoint that you can connect to directly:

{
  "mcpServers": {
    "cronalert": {
      "serverUrl": "https://cronalert.com/mcp",
      "headers": { "Authorization": "Bearer YOUR_API_KEY" }
    }
  }
}

This connects Cascade directly to CronAlert's hosted endpoint. No npm package, no Node.js dependency. The tradeoff is that every tool call goes over the network, so there is slightly more latency compared to the local npm method. Both methods expose the same 11 tools.

What Cascade can do with CronAlert

The real power here is not just having monitoring tools available — it is how Cascade weaves them into its agentic workflow. Cascade can read your codebase, understand your project structure, and combine that knowledge with CronAlert's tools.

Scan your project and create monitors automatically

Try telling Cascade: "Look at this project's route files and set up monitors for all the public API endpoints." Cascade reads your source code, identifies the URLs, and calls create_monitor for each one. If you have a dozen endpoints spread across multiple route files, this saves you from filling out a form twelve times.

Check what is down right now

Are any of my services currently down?

Cascade calls list_monitors, filters for anything with a non-healthy status, and gives you a clear summary. If something is down, you can follow up immediately — "Show me the last 10 check results for that monitor" — without switching windows.

Review response time trends

Show me the response time trends for my production API over the last 24 hours

Cascade calls get_check_results and summarizes the data: average response time, any spikes, uptime percentage. Useful for catching slow degradation before it turns into an incident.

Pause monitors during deploys

I'm pushing a breaking change to the auth service — pause those monitors for the next hour

Cascade finds the relevant monitors via list_monitors, then calls update_monitor on each to pause them. When the deploy is done, tell it to resume. No false alerts during your maintenance window.

Post incident updates without leaving your editor

We have an active incident on api.myapp.com — post an update that the fix is deployed and we're monitoring recovery

Cascade calls list_incidents to find the active incident, then add_incident_update to post your message. Your status page subscribers get notified while you stay focused on the code that fixes the problem.

Cascade's agentic advantage

What makes this particularly useful in Windsurf is that Cascade runs multi-step tasks autonomously. You do not need to prompt each action individually. Tell it to "create monitors for all my API endpoints, check their status after a minute, and summarize which ones need attention" — and Cascade handles the entire sequence: reading your code, creating the monitors, waiting, checking results, and reporting back.

This also works well with Windsurf's Flows feature. You can build a Flow that includes deployment steps alongside monitoring steps. Deploy to production, verify the health check passes, and create or update CronAlert monitors — all as a single automated workflow.

Troubleshooting

MCP server not connecting

For the npm method: make sure Node.js 18+ is installed by running node --version in your terminal. Verify the JSON in mcp_config.json is valid (a trailing comma is a common culprit). Try reloading Windsurf after saving the config. You can also check the MCP server status by clicking the MCP icon in the Cascade panel.

Auth errors with the remote method

Make sure the Authorization header value includes the Bearer prefix (with a space). The header should look like "Bearer ca_abc123...", not just the raw key.

Keeping API keys out of the config

Windsurf supports ${env:VARIABLE_NAME} interpolation in mcp_config.json. Set your API key as an environment variable in your shell profile, then reference it:

"env": { "CRONALERT_API_KEY": "${env:CRONALERT_API_KEY}" }

This way the key lives in your shell config rather than in a JSON file you might accidentally commit.

Available tools reference

The CronAlert MCP server exposes 11 tools. Here is the full list:

Every tool accepts and returns JSON. Cascade handles the serialization — you describe what you want in plain English.

Frequently asked questions

Which Windsurf plan supports MCP?

MCP is available on Windsurf Pro and Team plans. If you are on the free tier of Windsurf, you will need to upgrade before you can configure MCP servers. On the CronAlert side, the free plan works fine — you get 25 monitors, 3-minute intervals, and full API access including MCP.

Should I use the npm package or the remote server?

The npm package (cronalert-mcp) runs locally via stdio, so tool calls do not go over the network and are slightly faster. The remote server (serverUrl) is easier to set up because it does not require Node.js — just a URL and an auth header. Both give you access to the same 11 tools with the same functionality.

Can I use environment variables in the config?

Yes. Windsurf supports ${env:VARIABLE_NAME} interpolation in mcp_config.json. This is the recommended approach for API keys so you do not hardcode secrets in a config file.

Does this work with Windsurf's Flows feature?

Yes. You can include monitoring steps in Cascade Flows for automated workflows. A practical example: a Flow that deploys your service, waits for it to be healthy, then creates or verifies CronAlert monitors for the new deployment. This ties your deployment and monitoring processes together in a single repeatable workflow.

Getting started

The setup takes under a minute. If you already have a CronAlert account, grab your API key from Settings > API Keys, add the config to Windsurf, and start asking Cascade to manage your monitors. If you are new to CronAlert, sign up for free — 25 monitors with email, Slack, Discord, and webhook alerts, no credit card required.

Once connected, the first thing worth trying: ask Cascade to look at your current project and suggest which endpoints need monitoring. It can read your route files, understand your API surface, and set up comprehensive health checks — all before you finish your coffee.