AI Tool / Function Calling Schema Validator

Check that a tool/function definition for OpenAI or Anthropic is structurally correct and that its parameter schema compiles as valid JSON Schema, then test sample arguments against it - all in your browser. Nothing is sent to any AI provider or server, so you catch schema bugs for free, without burning API tokens on a live model call.

FormatOpenAI (parameters)Anthropic (input_schema)

Tool / Function Definition

{
  "name": "get_weather",
  "description": "Get the current weather for a given location.",
  "parameters": {
    "type": "object",
    "properties": {
      "location": { "type": "string", "description": "City and state, e.g. San Francisco, CA" },
      "unit": { "type": "string", "enum": ["celsius", "fahrenheit"] }
    },
    "required": ["location"],
    "additionalProperties": false
  }
}

Sample Arguments

{"location": "San Francisco, CA", "unit": "celsius"}

What this tool does

This validator checks a tool/function definition for OpenAI's function calling or Anthropic's tool use format: that it's valid JSON, has a name and description, and that its parameter schema (parameters for OpenAI, input_schema for Anthropic) compiles as valid JSON Schema. You can then paste a sample arguments payload - the kind of JSON a model would send when calling your tool - and check it against that schema, the same way our JSON Schema Validator checks any JSON.

Why validate a tool schema before deploying it

A malformed schema can cause the model to silently fail to call your tool, or to call it with the wrong shape of arguments.
A missing or vague description is technically valid JSON but leads to the model guessing wrong about when or how to use the tool.
Without "additionalProperties": false, a hallucinated extra argument passes validation instead of being caught early.

Step-by-step

Pick OpenAI or Anthropic to load a matching example.
Paste your own tool definition, replacing the sample.
Click Validate to run the structural checklist and compile the parameter schema.
Paste (or keep) sample arguments and re-run Validate to check they satisfy the schema.

Privacy

Everything here runs locally in your browser using the same JSON Schema engine as our Schema Validator. Nothing is sent to OpenAI, Anthropic, or any other server - this only checks structure, it does not make a live model call.

FAQ

What is a tool/function calling schema?: It's a JSON Schema that describes the arguments an AI model (like GPT or Claude) is allowed to send when it calls one of your tools/functions. The model uses it to generate structured, machine-readable arguments instead of free text.
What's the difference between OpenAI's and Anthropic's format?: Both wrap a JSON Schema in a 'name' and 'description', but OpenAI nests the schema under a 'parameters' field, while Anthropic nests it under 'input_schema'. The schema itself follows the same JSON Schema rules in both.
Why does the top-level type need to be "object"?: Both OpenAI and Anthropic expect tool arguments to arrive as a JSON object (key/value pairs), not a bare string, number, or array. A schema whose root 'type' isn't 'object' will be rejected or behave unpredictably.
Why does 'description' matter if it's not required by JSON Schema?: The model reads your 'description' fields to decide when and how to call the tool, and what to put in each argument. A missing or vague description often leads to the model calling the tool incorrectly, even if the schema is technically valid.
Does this tool call OpenAI or Anthropic's API to check my schema?: No. Everything here is a structural, offline check: is this valid JSON, is it shaped like a tool/function definition, does the parameter schema compile as valid JSON Schema, and does your sample arguments JSON satisfy it. Nothing is sent to any AI provider.
Does validating my schema here cost me API credits?: No. Checking your schema and testing sample arguments happens entirely offline in your browser - no OpenAI, Anthropic, or any model call is made. Catch structural bugs (bad types, missing required fields, invalid JSON Schema) here for free, before you spend real API tokens iterating against a live model.
Can I test whether a real model call would satisfy my schema?: Paste the arguments JSON you expect the model to produce (or one you received from an actual response) into the 'Sample Arguments' box and validate it against the parameter schema, the same way our JSON Schema Validator checks any JSON.
Should I set "additionalProperties": false?: It's a good idea. Without it, a model that hallucinates an extra argument will still pass validation. Setting it to false catches unexpected fields early, before they reach your function's implementation.
My schema uses $ref / oneOf / anyOf - is that supported?: The validator here checks any standard JSON Schema, including $ref, oneOf, anyOf, and allOf. Be aware some model providers restrict which keywords they support in tool schemas in strict/guaranteed modes - check your provider's current docs for those constraints.
Is my data uploaded to a server?: No. All tools run locally in your browser; your data isn't sent to any server.
Can I use the tool offline?: After the page loads once, most browsers will allow basic offline usage because processing is entirely client-side.
Can I beautify JSON?: Yes - use the Beautify actions in each tool where applicable.
Do you keep my files?: No. All tools run locally in your browser; data is not uploaded to any server.
Is there a size limit?: Large inputs are limited by your browser memory; for most cases typical files work fine.
Is it free?: Yes, All tools are 100% free and no sign-up required.