/

JSON Schema Builder

Processed Client Side

Build a JSON Schema for LLM structured outputs and tool use, then export to OpenAI, Anthropic, Gemini, Zod, and Pydantic — all generated in your browser.

Schema
Schema name
Fields
Export
3 fields
{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "title": "PersonProfile",
  "type": "object",
  "properties": {
    "name": {
      "type": "string",
      "description": "Full name"
    },
    "age": {
      "type": "integer"
    },
    "role": {
      "type": "string",
      "enum": [
        "admin",
        "editor",
        "viewer"
      ]
    }
  },
  "required": [
    "name",
    "age",
    "role"
  ]
}
JSON · ready to paste into your API request

Bookmark this tool now — skip the search next time you need it.

About JSON Schema Builder

This tool runs entirely in your browser. Whatever you paste is processed on your own device and is never uploaded, logged, or sent to any server.

The JSON Schema Builder is a visual editor for the schemas that constrain an LLM’s output. Add fields, give each one a type and a description, nest objects and arrays as deep as you need, drag rows to reorder them — then export the same structure as plain JSON Schema, an OpenAI response_format block, an OpenAI function definition, an Anthropic tool input_schema, a Gemini schema, a Zod object, or a Pydantic model. Writing these by hand is tedious and easy to get subtly wrong, and every provider wraps the same schema in a slightly different envelope. Building it once and switching the export tab removes both problems.

Key features

  • Visual field editor — name, type, description, and required flag per field, with no hand-written braces
  • Seven field types: string, number, integer, boolean, enum, object, and array
  • Unlimited nesting: objects hold child fields, and arrays get a single item definition describing their element shape
  • Drag rows by the handle to reorder fields; key order carries through to every export
  • Seven export targets: JSON Schema (draft 2020-12), OpenAI response_format, OpenAI function, Anthropic, Gemini, Zod, and Pydantic
  • Provider envelopes generated correctly — strict mode, additionalProperties, and the required array are all filled in the way each API expects
  • Descriptions carried into every format, because they are what actually steers the model’s field-by-field output
  • Enum values typed as a simple comma-separated list and expanded into the right construct per target
  • Live field count, and everything generated in your browser — no key, no account, no upload

How to use it

  1. Name the schema, then add your first field and pick its type.
  2. Write a description for each field — it is the instruction the model reads, so be specific.
  3. For an object, add child fields inside it. For an array, define the single item shape that every element follows.
  4. Mark which fields are required, and drag rows to put them in a sensible order.
  5. Switch to the export tab for your provider and copy the generated schema straight into your code.

Tips & common mistakes

  • Descriptions do the heavy lifting. "ISO 8601 date, e.g. 2026-03-14" produces far more reliable output than a bare string field called date, whatever the model.
  • OpenAI strict structured output requires every property to be listed in required and additionalProperties to be false. The OpenAI exports do that for you — which is why an optional field there has to be modelled as a nullable type rather than an absent one.
  • Prefer enum over a free-text string whenever the value comes from a fixed set. It is the single most effective way to stop a model inventing a fourth status.
  • Keep schemas shallow. Deeply nested structures are harder for a model to fill in consistently, and easier to debug when they are two levels rather than five.
  • Zod and Pydantic exports are for validating the response after it arrives. Sending the JSON Schema and validating with the generated model is the pair that catches a bad response before it reaches your code.
  • Field order is preserved through every export, and models tend to fill fields in the order they are given — put the fields that need the most reasoning after the ones that provide context for them.
  • This builds the contract. To mock an example response that satisfies it, use the JSON Payload Generator, and to check a real response against it, use the JSON Schema Validator.
  • To convert plain JSON to YAML or back, use the JSON ⇄ YAML Converter.

Related tools

Browse all 24 JSON tools

Frequently asked questions

10

Building the schema that constrains an LLM’s output. You define fields visually, then export the same structure as JSON Schema, an OpenAI response_format or function definition, an Anthropic tool schema, a Gemini schema, a Zod object, or a Pydantic model.

Seven: JSON Schema (draft 2020-12), OpenAI response_format, OpenAI function, Anthropic, Gemini, Zod for TypeScript, and Pydantic for Python. Switching tabs regenerates the same fields in the new format.

Set a field’s type to object and add child fields inside it, or to array and define the single item shape that every element follows. Nesting can go as deep as you need.

OpenAI strict structured output requires every property to appear in required and additionalProperties to be false. To make a field genuinely optional there, model it as a nullable type rather than an absent one.

They matter more than almost anything else. The description is the instruction the model reads for that field, so "ISO 8601 date, e.g. 2026-03-14" produces far more reliable output than a bare string field named date.

Whenever the value comes from a fixed set. Enumerating the allowed values is the most effective way to stop a model inventing a status or category that your code does not handle.

Validating the response after it arrives. Sending the JSON Schema to the model and parsing the reply with the generated Zod or Pydantic model gives you a check on both ends.

No. The builder generates schema text in your browser — it never calls any model provider, so there is no key, no account, and no cost.

Yes, drag a row by its handle. The order carries through to every export, which is useful because models tend to fill fields in the order they are given.

This builds the contract — the schema describing what a valid document looks like. The Payload Generator builds one concrete example body that satisfies such a contract.