JSON to JSON Schema Generator

JSON Schema is a standard for describing the structure of JSON data: which fields exist, their types, and allowed values. A schema lets you validate payloads automatically, document APIs, and generate code or forms. This tool infers a schema from sample JSON so you do not have to write it by hand.

Paste representative JSON into the converter. It maps each value to a schema type, nests object shapes under properties, describes array elements under items, and lists observed keys as required. Review the output: relax required fields that are optional and add constraints like formats or numeric bounds.

integer accepts only whole numbers (36), while number accepts any numeric value including fractions (9.99) and integers. Since every integer is a valid number, use integer when fractions are invalid (counts, ages) and number when they are allowed (prices, measurements).

required lists the object properties that must be present for the data to be valid. If a required key is missing, validation fails. Inferred schemas mark every observed key required; you should remove the ones that are genuinely optional in your domain.

Use a validator library: Ajv for JavaScript, jsonschema or python-jsonschema for Python, or an online validator. Load the schema once, then call validate(data, schema). Validators return a boolean plus a list of errors pinpointing exactly which keyword failed and where.

$schema declares which JSON Schema dialect the document follows, for example https://json-schema.org/draft/2020-12/schema for the current 2020-12 version. Always declare it so validators interpret newer keywords correctly; 2020-12 is the recommended default for new schemas.

Set additionalProperties: false on the object to reject any key not listed in properties. This catches typos like 'emial' instead of 'email'. Leave it true (the default) for extensible formats where unknown fields are acceptable.

anyOf passes if at least one subschema matches, oneOf passes if exactly one matches, allOf passes only if every subschema matches. Use anyOf for flexible unions, oneOf for exclusive alternatives (with careful design, since overlapping schemas cause failures), and allOf to compose constraints.

Describe elements with items: {"type": "array", "items": {"type": "string"}}. Bound the length with minItems and maxItems, forbid duplicates with uniqueItems: true, and require at least one element with minItems: 1. For tuples (fixed positions), use prefixItems with a list of schemas.

$ref is a JSON pointer to another schema, letting you reuse definitions: {"$ref": "#/$defs/address"}. Put shared shapes in $defs once instead of duplicating them across properties. Refs keep large schemas maintainable and consistent.

Add format: email, date-time, uri, uuid, ipv4, and similar semantic hints to string schemas. Note that format is annotation-only by default in many validators (it does not fail validation unless format assertion is enabled); pair it with pattern when you need enforcement.

Pass a list of types: {"type": ["string", "null"]} accepts either a string or null. This is the standard way to model nullable fields. In older drafts the same was written with anyOf; the type array is the modern concise form.

Nest schemas recursively: an object property's schema contains its own properties, required, and so on, to any depth. For deeply shared nested shapes, define them once under $defs and reference them with $ref from each location.

enum restricts a value to an explicit list: {"enum": ["red", "green", "blue"]}. Anything outside the list fails validation. Use it for statuses, categories, and any closed set of allowed values; combine with type for clarity.

No. Schema generation runs entirely in your browser; your JSON is never uploaded to any server. The generated schema is yours to copy into your project or API documentation.