# Checkly MCP for AI Agents MCP

> Checkly lets your AI agent take full control of application monitoring and synthetic testing. You can track API uptime, view detailed performance metrics for web apps, and manually trigger checks—all through natural conversation with no dashboard required.

## Overview
- **Category:** loved-by-devs
- **Price:** Free
- **Tags:** api-monitoring, synthetic-testing, uptime-tracking, end-to-end-testing, performance-monitoring

## Description

Need to know if your APIs are up? Checkly connects your monitoring stack directly into any AI client. Instead of logging into a separate dashboard every time you need an update, you just ask your agent. It instantly retrieves the status of all your API and browser monitors. You can audit alert configurations (for Slack or PagerDuty) without clicking through menus, check historical performance metrics for specific flows, or even force a manual run to verify system health on demand.

This capability means your team gets immediate visibility into application reliability right where they're already working. If you manage infrastructure monitoring, this MCP is essential for keeping your development process fast and responsive. It works alongside the full catalog of integrations found on Vinkius, making it a single point of truth for uptime and performance data.

## Tools

### get_checkly_account_info
Retrieves core organizational metadata for the Checkly account.

### get_check_performance_metrics
Pulls historical performance data and response times for a specific monitor.

### get_check_details
Fetches detailed configuration information about an individual check or monitor.

### list_checkly_alert_channels
Lists all active external channels, such as Slack and PagerDuty, receiving alerts for the account.

### list_checkly_checks
Retrieves a list of every configured API and browser monitor in the system.

### list_check_groups
Lists the logical groupings that contain multiple related checks or monitors.

### list_checkly_heartbeats
Shows all configured heartbeat (cron) jobs and their last run status.

### trigger_check_run
Forces a specified check to execute immediately, simulating an instant system test.

## Prompt Examples

**Prompt:** 
```
Show me the performance history for the main API endpoint over the last 7 days.
```

**Response:** 
```
**API Performance Report: /api/main**

| Metric | Last 24 Hrs | Week Avg | Trend |
| :--- | :---: | :---: | :---: |
| Average Response Time | 350ms | 380ms | ↑ (Slight Increase) |
| Peak Latency | 1.1s | 800ms | Stable |
| Uptime | 100% | 99.9% | Excellent |

*Note: Performance dipped slightly on Tuesday afternoon, coinciding with the database migration.*
```

**Prompt:** 
```
List all monitors and tell me if any are failing right now.
```

**Response:** 
```
**Current Monitor Status**

*   ✅ Main API Gateway: Passing (Last run 5m ago)
*   ⚠️ User Auth Service: **Failing**. Last error: '401 Unauthorized'. Check details for required credentials.
*   ✅ Shopping Cart Flow: Passing (Last run 2m ago)

I recommend investigating the User Auth Service failure immediately.
```

**Prompt:** 
```
What are my alert channels and what's the status of the nightly report sync?
```

**Response:** 
```
**Alert Channels Configured:**
*   Slack: #devops-alerts (Active)
*   Email: sres@company.com (Active)
*   PagerDuty: Primary (Active)

**Heartbeat Status:** The 'Nightly Report Sync' ran 1 hour ago and is reported as **Active**. Everything looks nominal.
```

## Capabilities

### View all monitors and group details
List every API or browser monitor you have configured and see which groups they belong to.

### Get detailed check information
Retrieve specific data points for any individual monitor, including configuration details.

### Check performance metrics over time
Pull historical response times and performance scores for a specified check to spot trends or regressions.

### Manually force a test run
Instantly trigger any monitor to execute its full sequence of tests, verifying current system health on demand.

### Audit alert channels
List every external channel (like Slack or Email) that is currently configured to receive alerts when a check fails.

## Use Cases

### Debugging a new API endpoint
A developer just merged a payment service change. Instead of manually waiting for the scheduled check, they ask their agent to run an immediate test via `trigger_check_run`. The agent reports back that the transaction monitor failed and provides detailed error messages.

### Quarterly SRE audit
The SRE needs proof of uptime. They prompt the agent for performance metrics on the main checkout flow (`get_check_performance_metrics`). The agent compiles a 30-day report showing consistent low latency, passing the quarterly review.

### Onboarding new team members
A junior engineer needs to know what's being monitored. They ask the agent to list all active monitors (`list_checkly_checks`), getting a complete overview of every API and browser check in seconds.

### Reviewing background tasks
The team suspects a nightly job failed. Instead of checking logs, they ask the agent to list all heartbeats (`list_checkly_heartbeats`), confirming if the critical database cleanup cron job ran successfully within its expected window.

## Benefits

- Stop context switching. Instead of opening multiple dashboards to check status, you ask your agent to list all monitors or get specific performance data instantly.
- Prove system stability with historical metrics. Use the `get_check_performance_metrics` tool to retrieve average response times and identify slow-down trends without manual chart digging.
- Validate changes on demand. Need an immediate status check? The agent executes a test run using `trigger_check_run`, giving you real-time feedback on system health right in the chat.
- Maintain visibility across your stack. Easily audit every configured alert channel with `list_checkly_alert_channels` to ensure nothing is missed when things break.
- Understand your setup at a glance. Quickly use `list_checkly_checks` and `list_check_groups` to get an overview of all monitoring assets without clicking through the UI.

## How It Works

The bottom line is, you manage complex monitoring tasks using simple conversation instead of navigating multiple web interfaces.

1. Subscribe to this MCP and provide your Checkly API Key and Account ID.
2. Connect the credentials within any compatible AI client (Claude, Cursor, etc.).
3. Ask your agent a natural language question like, 'What's the status of my checkout flow?' or 'List all failing monitors.' The agent then executes the necessary checks and delivers the results.

## Frequently Asked Questions

**How can Checkly MCP help me monitor my API uptime?**
Checkly lets your agent check the current status of any monitored endpoint instantly. You don't have to open a dashboard; you just ask, and it tells you if the API is up or if there was an error.

**Does Checkly MCP track historical performance data?**
Yes, it does. You can ask for detailed performance metrics on specific checks to see how fast your APIs were over days or weeks, helping you find slow spots before they break completely.

**What if I need to manually test a new feature right now?**
You can use the MCP to trigger an immediate check run. This forces the system to run tests on demand, giving you real-time proof that your latest changes are working correctly.

**Is Checkly MCP better than just using my CI/CD pipeline for checks?**
While CI/CD pipelines are great for code testing, this MCP handles the continuous monitoring of live production endpoints and web flows. It gives you visibility into how the entire application performs in a real-world environment.

**How do I check if all my alert systems are set up correctly?**
The MCP allows you to list every configured alert channel, including Slack and PagerDuty. You can audit these settings from your chat interface to ensure that failure notifications go to the right people.