WebMCP Verifier: Validate Model Context Protocol (MCP) Servers

Are you building a custom Model Context Protocol (MCP) server and struggling to debug the JSON-RPC traffic? Testing SSE (Server-Sent Events) endpoints manually can be a massive headache. To solve this, I've built the WebMCP Verifier—a free online diagnostic tool to instantly validate and test your MCP servers.

You can access the tool here: WebMCP Verifier on Krypton's Tools.

What is the WebMCP Verifier?

WebMCP Verifier is an online diagnostic client that connects directly to your Model Context Protocol (MCP) Server-Sent Events (SSE) endpoint to validate JSON-RPC protocol compliance, handshake sequences, and tool capabilities.

Instead of writing custom Python or Node.js scripts just to check if your server responds to an initialize request, you can simply paste your URL into the browser and get instant visual feedback.

Key Features

• Automated Handshake Validation: Verifies the initialize and notifications/initialized sequence.
• Capabilities Discovery: Automatically fetches and displays available Tools, Prompts, and Resources.
• Raw Traffic Console: A terminal-styled log window that displays real-time JSON-RPC 2.0 messages (requests, responses, and errors) for easy debugging.
• CORS Proxy Support: Built-in proxying to bypass strict browser CORS limitations, allowing you to test local or restrictive endpoints without altering your server configuration.

How to Test Your MCP Server

Follow these simple procedural steps to validate your server endpoint:

1. Start Your MCP Server: Ensure your server is running and exposing an SSE transport endpoint (e.g., http://localhost:8000/sse).
2. Enter the Endpoint: Navigate to the WebMCP Verifier and paste your URL into the connection bar.
3. Initiate Connection: Click "Connect". The verifier will attempt to establish an SSE connection and discover the corresponding HTTP POST endpoint for RPC messages.
4. Inspect Capabilities: Once connected, browse through the discovered tools and resources in the UI.
5. Debug Traffic: Watch the live console for any -32600 (Invalid Request) or parsing errors.

WebMCP Verifier vs. Manual Testing

Here is a quick comparison of using a dedicated verifier versus writing manual test scripts:

Anthropic MCP vs. Chrome WebMCP Standard

If you are researching WebMCP, you might have noticed some confusion in the naming conventions. It is crucial to distinguish between two completely different technologies that share similar acronyms:

• Anthropic's MCP (Model Context Protocol): This is a universal, open standard JSON-RPC protocol (running over stdio or SSE) that allows AI models (like Claude) to securely connect to local or remote tools and resources. Our Verifier tool is designed specifically to test these SSE-based MCP servers.
• Google Chrome's WebMCP Standard: This is a separate, recently proposed web standard for browsers. Chrome's WebMCP allows web developers to embed AI agent instructions and structural hints directly into HTML using JSON-LD, making websites "agent-ready".

While Chrome's WebMCP focuses on frontend DOM structuring for AI agents, Anthropic's MCP focuses on backend tool execution and secure protocol handshakes. Our online diagnostic tool helps developers strictly with the latter (validating Anthropic-compliant JSON-RPC traffic).

💡 Need to create structured JSON-LD data? If you are building semantic schemas for your web pages or AI agents, use our free visual JSON-LD Schema Generator to instantly generate and test valid Schema.org tags (FAQPage, HowTo, SoftwareApplication, and Article).

Understanding the MCP JSON-RPC 2.0 Handshake Wire Protocol

To effectively debug failing connections, it helps to understand what the WebMCP Verifier sends and expects across the network. The Model Context Protocol mandates a strict two-step handshake over SSE and HTTP POST:

Step 1: The Initialize Request & Response

Once the SSE connection is established, the client sends an initialize JSON-RPC method request to discover capabilities and negotiate the protocol version:

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "initialize",
  "params": {
    "protocolVersion": "2024-11-05",
    "capabilities": {
      "roots": { "listChanged": true },
      "sampling": {}
    },
    "clientInfo": {
      "name": "webmcp-verifier",
      "version": "1.0.0"
    }
  }
}

Your MCP server must respond with its own information and declared capabilities:

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "protocolVersion": "2024-11-05",
    "capabilities": {
      "tools": { "listChanged": true },
      "resources": { "subscribe": true },
      "prompts": { "listChanged": true }
    },
    "serverInfo": {
      "name": "my-custom-mcp-server",
      "version": "0.1.0"
    }
  }
}

Step 2: The Initialized Notification

Immediately after receiving the valid initialize result, the client dispatches a notification confirming initialization. Notifications in JSON-RPC do not expect a response:

{
  "jsonrpc": "2.0",
  "method": "notifications/initialized"
}

Only after this sequence is complete does the client send tools/list to fetch the registered tool schema and input parameters.

Standard MCP JSON-RPC Error Codes & Troubleshooting

When an MCP server fails to process a request, it returns a standard JSON-RPC 2.0 error object. Here is a troubleshooting reference for common error codes encountered during testing:

Debugging Common Errors

During my own development of MCP servers, the most common issue I encountered was the handshake timeout. If your server fails to respond to the initialize request within a few seconds, the client will abort. Always ensure that your server parses the JSON-RPC version exactly as "2.0" and returns the required server info and protocol version (2024-11-05).

Another frequent hurdle is CORS. If your server is not explicitly configured to allow cross-origin requests, browser-based clients will fail the preflight OPTIONS check. The WebMCP Verifier includes proxy capabilities to help sidestep this during local development.

Check out the WebMCP Verifier on Krypton's Tools today and streamline your AI tooling development!

• What is a WebMCP Verifier?

  A WebMCP Verifier is an online diagnostic tool that connects to your Model Context Protocol (MCP) Server-Sent Events (SSE) endpoint to validate JSON-RPC protocol compliance, handshake sequences, and tool discovery.

• How do I validate my MCP server?

  Paste your MCP server's SSE URL into the WebMCP Verifier. The tool will automatically initiate the handshake, request the capabilities list (tools, prompts, resources), and display raw JSON-RPC traffic for debugging.

• Why does my MCP server fail to connect in the browser?

  Browser-based WebMCP clients are subject to strict CORS (Cross-Origin Resource Sharing) policies. Ensure your MCP server explicitly allows requests from the verifier's origin or use a backend proxy to bypass browser restrictions.

• What is the Model Context Protocol (MCP)?

  The Model Context Protocol (MCP) is an open standard that allows AI models to securely connect to external data sources and tools, providing a unified JSON-RPC interface for fetching resources, listing prompts, and executing remote functions.