Trexmi
Validator Ready

MCP Schema Validator

Validate the core structure of one MCP tool definition, including its name, description, inputSchema, required fields, outputSchema, and annotations.

Require one JSON object at the root Validate the MCP tool name and description types Check inputSchema type, properties, and required containers Check optional outputSchema and annotations containers
This is a focused structural check, not full JSON Schema evaluation or an MCP server connection test.
INPUT MCP tool definition *
0 chars0 words0 lines
Ctrl / ⌘ + Enter
MCP schema validation report Core tool fields, inputSchema container, errors, and compatibility warnings.
About the tool

What MCP Schema Validator does

MCP Schema Validator checks the core structure of a single Model Context Protocol tool definition. It verifies that the root is an object, the tool has a non-empty name, inputSchema is a JSON Schema object with type: object, and common containers such as properties, required, outputSchema, and annotations have usable types.

The report separates errors from compatibility warnings. An invalid inputSchema is an error; a missing description or a tool name outside current interoperability guidance is a warning. This distinction prevents recommended metadata from being presented as a mandatory protocol failure.

MCP Schema Validator showing errors warnings and inputSchema checks
Review core MCP tool fields and JSON Schema containers before integration testing.

How to use

  1. Paste one tool. Use the tool object returned inside an MCP tools list, not the entire JSON-RPC response.
  2. Validate the JSON. Malformed JSON is rejected before MCP field checks begin.
  3. Fix errors first. Follow each JSON-style path to the affected name, schema, required list, output schema, or annotations value.
  4. Review warnings. Improve naming and descriptions for broader client and model compatibility.
  5. Run deeper tests. Validate the full JSON Schema and call the registered tool through the production MCP client.
Built for the task

Why use MCP Schema Validator?

Focused controls, predictable output, and a workflow designed around this exact transformation.

01

Path-based findings

Every structural issue points to the affected MCP field.

02

Core container checks

Check inputSchema, properties, required, outputSchema, and annotations shapes.

03

Errors vs warnings

Required structure is separated from recommended interoperability guidance.

04

Machine-readable report

Copy or download counts, findings, checks, and the documented validation scope.

Useful answers

Questions about MCP Schema Validator

Practical details about input, output, privacy, limits, and the best way to use this tool.

01 What does MCP Schema Validator check?

It checks one tool object, its name and optional description, the inputSchema object and common containers, plus optional outputSchema and annotations objects.

02 Does it validate an entire tools/list response?

No. Paste one tool definition, not the surrounding JSON-RPC response or tools array.

03 Why must inputSchema.type be object?

MCP tool arguments are named parameters represented by a JSON object, so the input schema uses an object root.

04 Is description required?

The focused validator treats a missing or empty description as a warning. A precise description helps clients and models choose the correct tool.

05 Why can a tool name produce only a warning?

Current MCP naming length and character guidance is expressed as interoperability guidance. The validator warns instead of turning every deviation into a protocol error.

06 Does it evaluate every JSON Schema keyword?

No. It checks common containers and types but does not resolve references or fully evaluate Draft 2020-12 vocabularies.

07 Does a valid result prove that the tool handler works?

No. The validator does not connect to a server, list tools, call the handler, validate permissions, or inspect returned content.

08 Are MCP annotations trusted?

No. Clients should treat tool annotations as untrusted unless they come from a trusted server.

Examples

Valid MCP tool definition

The required tool name and object input schema pass the focused structural check.

Input
{
  "name": "search_docs",
  "description": "Search product documentation",
  "inputSchema": {
    "type": "object",
    "properties": {"query": {"type": "string"}},
    "required": ["query"],
    "additionalProperties": false
  }
}
Output
valid: true
error_count: 0
warning_count: 0
checks.inputSchema: true

Reject an array input schema

MCP tool call arguments are represented by an object input schema.

Input
{
  "name": "search_docs",
  "description": "Search product documentation",
  "inputSchema": {
    "type": "array",
    "items": {"type": "string"}
  }
}
Output
$.inputSchema.type — MCP tool inputSchema.type must be object.

Report duplicate required names

Errors and quality warnings are reported independently.

Input
{
  "name": "create_ticket",
  "inputSchema": {
    "type": "object",
    "properties": {"subject": {"type": "string"}},
    "required": ["subject", "subject"]
  }
}
Output
Error: $.inputSchema.required — required property names must be unique.
Warning: $.description — Add a precise description so clients and models can choose the tool correctly.

Paste one MCP tool definition

The accepted input is a JSON object representing one tool, such as an item from the tools array returned by tools/list. Do not paste the outer JSON-RPC envelope. JSON syntax is parsed first, so missing commas, invalid quotes, comments, or trailing commas are reported before MCP-specific checks.

The root name identifies the tool. description explains its purpose, and inputSchema defines call arguments. Current MCP versions can also describe display metadata, icons, an outputSchema, annotations, execution behavior, and extension metadata; this focused validator does not require optional fields.

Core MCP and inputSchema checks

The root must be an object and name must be a non-empty string. If description is present, it must be a string. inputSchema must be a JSON object with type: object. When present, properties must be an object and required must be an array of unique strings.

An optional outputSchema must be a JSON Schema object, while optional annotations must be an object. These checks catch common serialization and container mistakes without claiming that every nested schema keyword has been evaluated.

Compatibility and description warnings

A missing description does not make the basic object unparsable, but it gives a model less information for choosing among tools. The validator therefore reports it as a warning. Write an action-oriented description that states what the tool returns, the important inputs, and the situations in which another tool should be preferred.

Current MCP guidance recommends tool names between 1 and 128 characters using ASCII letters, digits, underscore, hyphen, or dot. It also treats names as case-sensitive and recommends uniqueness within a server. A name outside that profile receives a compatibility warning.

Validation limits and edge cases

This tool does not fully evaluate JSON Schema Draft 2020-12. It does not resolve $ref, check every nested keyword, validate example arguments, verify output against outputSchema, inspect x-mcp-header constraints, or determine whether a client supports an extension. A valid structural report can still contain a logically incorrect or unsafe contract.

The validator also does not connect to an MCP server. It cannot verify authorization, user confirmation, rate limiting, side effects, tool-result errors, timeouts, or sanitization. Those behaviors must be tested at the protocol and handler layers.

From schema check to tool call

Create a starting definition with MCP Tool Schema Generator, then run this structural check. Use JSON Schema Validator for supported data rules and compare provider-specific wrapping with JSON to OpenAI Function Schema. Finally list and call the tool through the actual MCP server and client, including invalid arguments and permission failures.

Official MCP and JSON Schema references

Review the current MCP tools specification and JSON Schema Draft 2020-12 for the complete requirements that a production implementation must satisfy.