MCPWatch is an observability platform for MCP (Model Context Protocol) servers. It lets you trace every tool call, catch errors before users do, and understand performance at a glance.

How do I install MCPWatch?

Install the SDK for your language (npm install @mcpwatch/sdk for TypeScript or pip install mcpwatch for Python), add one import, and wrap your MCP server. You'll see events in under two minutes.

Yes! MCPWatch has a generous free tier with 50,000 events per month.

What MCP clients does MCPWatch support?

MCPWatch works with every MCP-compatible client including Claude Desktop, Cursor, VS Code, Zed, and Windsurf.

MCP Observability Platform

See what your MCP servers actually do

Name: MCPWatch
Author: MCPWatch

Observability for the Model Context Protocol. Trace every tool call, catch errors before users do, understand performance at a glance.

Start Free

mcpwatch — live trace

LIVE

Time MethodDurationmsStatus

Works with

Claude Desktop Cursor VS Code Zed Windsurf

Your MCP servers are black boxes

You ship MCP tools, but have no idea what happens after deployment.

Tool calls fail silently

No visibility into what went wrong. Users hit errors, and you only find out when they complain — if they bother.

Performance is a mystery

No latency tracking across tool chains. Is it your server, the LLM, or the network? You're flying blind.

Debugging is guesswork

Reproducing issues requires manual log trawling. By the time you find the cause, the user has moved on.

MCPWatch changes that.

Everything you need to observe

From real-time traces to proactive alerts — full observability for your MCP servers.

Traces Errors Analytics Alerts

TRACE abc-123-def 342ms total

tools/list

290ms

db.query

205ms

cache.get

12ms

tools/call

52ms

Waterfall traces for every operation

See nested MCP operations with precise timing breakdowns
Follow a request from client through every tool call and resource fetch
Spot bottlenecks instantly with color-coded latency indicators

ERRORS Last 24h 3 groups

ToolNotFoundError 142x

weather-server, file-server

TimeoutError 38x

db-server

ValidationError 12x

api-server

Errors grouped and prioritized

Automatic error grouping by type, message, and affected server
Frequency tracking shows which errors impact the most users
One-click drill-down to the exact trace that triggered the error

ANALYTICS 7-day overview

Throughput (req/min) 1,247

p50

42ms

p95

187ms

p99

523ms

Error rate 0.3%

Metrics that matter

Throughput, latency percentiles, and error rates at a glance
Break down performance by server, tool, or client
Trend analysis to catch regressions before users notice

ALERTS Active rules

Error rate spike Email + Webhook

Trigger when error_rate > 5% for 5 minutes

Server disconnection Email

Trigger when server heartbeat missing > 60s

Latency degradation Webhook

Trigger when p95 > 500ms for 10 minutes

Know before your users do

Email and webhook notifications for error spikes and latency degradation
Instant alerts when MCP servers disconnect or stop responding
Configurable thresholds and cooldown periods to reduce noise

Two minutes to first event

Zero infrastructure changes. One import. Full visibility.

TypeScript Python

server.ts

import { MCPWatch } from '@mcpwatch/sdk';

const watch = new MCPWatch({
  apiKey: process.env.MCPWATCH_API_KEY,
});

// Wrap your MCP server — that's it
export default watch.wrap(myMCPServer);

server.py

from mcpwatch import MCPWatch

watch = MCPWatch(
    api_key=os.environ["MCPWATCH_API_KEY"],
)

# Decorate your MCP server — that's it
@watch.trace
async def handle_tool_call(request):
    ...

$ npm install @mcpwatch/sdk

$ pip install mcpwatch

See your MCP servers at a glance

A purpose-built dashboard for MCP observability. Not another generic APM.

app.mcpwatch.dev/dashboard

Active Servers

Requests (24h)

24.3k

Avg Latency

47ms

Error Rate

0.2%

Request Volume Last 24 hours

Recent Traces

tools/call weather-server: get_forecast 34ms

tools/call file-server: read_file 12ms

tools/call db-server: query — TimeoutError 502ms

Real-time traces

Every request, every tool call, as it happens.

Error grouping

Errors clustered by root cause, not individual occurrence.

Performance metrics

Latency percentiles, throughput, and trends over time.

Works with every MCP client and server

Drop-in observability for the entire MCP ecosystem. No vendor lock-in.

Claude Desktop

Cursor

VS Code

Zed

Windsurf

Any MCP Client

MCPWatch works at the transport layer — compatible with any MCP-compliant client or server.

Pricing

Simple, transparent pricing

Start free and scale as your observability needs grow. No hidden fees, no surprise charges.

MonthlyAnnual

Free

50K events / month
1 project
7-day retention
Community support

Get Started Free

Pro

$49/mo

1M events / month
Unlimited projects
30-day retention
Alerts & notifications
Priority support

Start Pro Trial

Scale

$199/mo

Unlimited events
Unlimited projects
90-day retention
SSO / SAML
Dedicated support
SLA guarantee

Contact Sales

Compare plans

Feature	Free	Pro	Scale
Events / month	50K	1M	Unlimited
Projects	1	Unlimited	Unlimited
Data retention	7 days	30 days	90 days
Team members	1	10	Unlimited
Alerts	—
SSO / SAML	—	—
Priority support	—
Dedicated support	—	—
SLA guarantee	—	—
Quota grace period	—	20% buffer	N/A

When you exceed your plan's event limit, MCPWatch continues ingesting events for a 20% grace buffer. Events in the grace period are stored but hidden in the dashboard until you upgrade. Beyond the grace buffer, ingestion pauses until the next billing cycle.

Start seeing what your
MCP servers actually do

Free to start. Scale when you're ready.