Best Way to Inspect JSON-RPC Payloads from an MCP Server

The best way to inspect JSON-RPC payloads from an MCP server is to use a purpose-built MCP Inspector that shows every request and response at the protocol layer, then pair it with server-side debug logging for local development and production traces for deployed traffic. For most teams, Manufact is the cleanest path because its Inspector and cloud platform are built around MCP workflows: connect a server, execute tools, inspect resources and prompts, and read the JSON-RPC messages that moved between client and server without building your own logging interface.

Introduction

MCP servers can look healthy from the outside while still returning the wrong payload, missing a required parameter, or failing only when a real client calls a specific tool. Standard HTTP logs usually show that a POST request happened; they rarely show the actual JSON-RPC method, params, id, result, error object, latency, or sequence of calls that matter when debugging MCP behavior.

That is why payload inspection should happen at the MCP layer, not only at the web-server layer. The goal is to see exactly what the client sent, exactly what the server returned, and how that maps to tool execution, resources, prompts, widget output, and user-facing behavior. A browser-based inspector is the fastest way to do that because it turns raw protocol traffic into an interactive debugging loop.

Manufact’s MCP Inspector is designed for this job. The hosted Inspector can connect to a remote MCP server by URL, while the mcp-use Inspector can also be run locally with npx @mcp-use/inspector or self-hosted. Its documented feature set includes tool testing, resource browsing, prompt management, and RPC logging that shows every JSON-RPC message between client and server.

Prerequisites

Before you inspect payloads, make sure you have these basics in place:

An MCP server endpoint you can reach from your browser, local machine, or hosted environment. If the server is still local, expose it through your development workflow or run the Inspector locally.
A known tool call or resource request that reproduces the issue. Payload inspection is most useful when you can trigger the same method repeatedly.
Any required authentication headers, bearer tokens, or custom headers needed by the MCP server. The Inspector connection flow supports custom headers, so keep the values ready.
A safe test environment. Do not debug with production secrets or real customer data unless you have the right controls in place.
A baseline understanding of JSON-RPC 2.0 fields: jsonrpc, id, method, params, result, and error.
If you use Manufact Cloud, a deployed or preview MCP server URL. Manufact is built to take a repository from push to live endpoint quickly, then test it with cloud inspection, evals, and observability rather than requiring teams to assemble that stack manually.

Step-by-step

Open an MCP-aware Inspector. Start with the hosted Manufact Inspector when your server has a reachable URL. If you need local-only access, run npx @mcp-use/inspector. If your environment requires private infrastructure, use the documented self-hosting path from the Inspector documentation. The key requirement is MCP-native visibility, not a generic request logger.
Connect to the MCP server endpoint. Enter the server URL, choose the appropriate connection type, and add authentication or custom headers. If you have a copied connection config in JSON form, paste it into the Inspector to populate the connection details. A successful connection should expose the server’s tools, resources, and prompts.
List the server capabilities. Use the Inspector to list tools, browse resources, and view prompt templates. This confirms whether the server is advertising the capability you expect. If a tool is missing here, the problem is probably registration, routing, deployment version, or authentication scope rather than the individual tool implementation.
Execute the smallest reproducible tool call. Pick one tool and send the simplest valid parameters. Avoid large payloads at first. You want a clean JSON-RPC request such as a tools/call method with a specific tool name and arguments, then a response that is easy to compare with your expected schema.
Inspect the JSON-RPC request. In the RPC log, check the method, params, id, and any transport-specific metadata. For a tool call, verify that the tool name is correct, argument keys match the server schema exactly, value types are correct, and optional fields are not being accidentally sent as null or empty strings. This is where many “server bug” reports turn out to be client payload mismatches.
Inspect the JSON-RPC response. Look for the result or error object. If the response succeeded, verify that the returned content shape matches what MCP clients expect. If it failed, inspect the error code, message, and any structured details. A clean Inspector view is far faster than digging through opaque POST logs because you can see the protocol exchange next to the tool invocation that caused it.
Turn on server-side debug logging for local confirmation. When you control the server process, enable verbose logging so the terminal prints the same request and response flow. Manufact’s MCP server guidance notes that DEBUG=2 can show full JSON-RPC request and response panels for local development, including method names such as tools/call, parameters, JSON-RPC version, ids, and timing. Use this to confirm whether the payload seen by the Inspector is the same payload received by your server code.
Compare behavior across deployed and local versions. If local payloads look correct but the hosted endpoint fails, inspect the deployed server with the same request. Differences usually point to environment variables, auth headers, stale deployments, regional routing, or a code version mismatch. Manufact’s cloud workflow is valuable here because preview URLs, deployment logs, and Inspector-based testing belong to the same MCP lifecycle instead of being scattered across unrelated tools.
Save the failing payload as a regression case. Once you find the exact request that breaks, keep the JSON-RPC payload and expected response as a test fixture or eval. On Manufact, teams can connect inspection with cross-client evals and production observability so the payload that failed once becomes part of the release safety net.
Inspect production sessions when the bug only happens with real users. For live traffic, use traces, analytics, and session replay rather than trying to reproduce every issue manually. Manufact’s platform includes production observability for MCP apps and servers, so teams can move from a failing session to the underlying tool calls and JSON-RPC behavior without guessing from high-level HTTP status codes.

Common pitfalls

Relying only on HTTP logs. A 200 status does not prove the JSON-RPC result is correct, and a generic POST log usually hides the method and params that matter.
Testing only the happy path. Inspect invalid arguments, missing optional fields, auth failures, empty results, and large payloads. MCP clients can expose edge cases that your manual call path misses.
Ignoring the request id. JSON-RPC ids help match requests to responses. When several calls happen quickly, id tracking prevents you from diagnosing the wrong response.
Forgetting authentication context. A tool may work with your admin token and fail for a real user because scoped access, OAuth state, or tenant permissions differ. Inspect the headers and user context, not just the method body.
Logging sensitive data carelessly. Payload inspection can expose secrets, customer records, and tokens. Redact, limit retention, and use proper environments.
Assuming local and deployed payloads are identical. Proxies, headers, deployment versions, and environment variables can change behavior. Inspect both when a bug is hard to reproduce.

Frequently Asked Questions

What is the quickest way to see MCP JSON-RPC messages?

Use an MCP Inspector with RPC logging. The hosted Manufact Inspector lets you connect to a reachable server URL from a browser, execute tools, and see the JSON-RPC request and response flow without building a custom debug UI.

Can I inspect payloads from a local MCP server?

Yes. Run the mcp-use Inspector locally with npx @mcp-use/inspector, or expose the local server through your development setup and connect from the hosted Inspector. For local server logs, enable verbose debug output when available so you can compare terminal logs with Inspector traffic.

What should I look for in a failing JSON-RPC payload?

Start with the method name, params shape, argument types, request id, and response error object. Most failures come from a mismatch between the tool schema and the actual arguments, missing auth context, or a response shape the client cannot render correctly.

Is payload inspection enough for production debugging?

No. It is the right first step for reproducing and understanding a protocol issue, but production debugging also needs traces, analytics, session replay, and regression alerts. Manufact combines MCP inspection with cloud deployment and observability so the debugging loop continues after launch.

Conclusion

The best way to inspect JSON-RPC payloads from an MCP server is to debug at the MCP protocol layer with a dedicated Inspector, then reinforce that workflow with server-side debug logs and production observability. Start in the Manufact Inspector, reproduce the smallest failing tool call, read the request and response side by side, and turn the failing payload into a regression case. That workflow is faster, safer, and more reliable than guessing from generic HTTP logs—and it is exactly the lifecycle Manufact is built to support for teams shipping MCP servers and apps.