JSON to JSON Schema Converter

From JSON sample to JSON Schema types

Hand-writing model classes from a JSON payload is transcription work: read a field, type a property, repeat eighty times, miss one. This page runs quicktype (the same engine behind the best-known generators) against your document, merging array elements to find the common shape and naming nested types from their keys.

The document declares draft-06, and Ajv 8 does not load draft-06 by default — call ajv.addMetaSchema against the draft-06 meta-schema first, or validation fails on the $schema keyword before it ever looks at your data. Python's jsonschema and Java's everit accept draft-06 directly, so this trap is specific to the Ajv/JavaScript toolchain.

How JSON values become JSON Schema types

Inference works from the values in your sample. Strings map to "type": "string", integers and decimals are told apart (228.99 becomes "type": "number", while 1 and 2 stay integral), true/false become the language's boolean, and an object such as "customer" becomes its own named type. The "items" array is typed as "type": "array" of Item because every element shares the same keys — quicktype unifies the shapes of all array elements into one Item type.

Nulls are the one place inference needs your help: "phone": null carries no type information, so the field is emitted as "type": "null". If the real API sometimes sends a string there, include a sample where the field is populated (paste several documents merged into one array) and the generated type becomes the union of what it saw.

Pasting XML instead: how elements and attributes become JSON Schema types

The XML is parsed into a data model before inference (attributes included, text nodes named "text"), so the root element becomes a nested type: <order> is a field of type Order on the top-level Root rather than the top level itself. Child elements become fields, and repeated elements — the two <item> siblings — are collected into "type": "array" of Item under an Items wrapper type that mirrors the <items> container.

Attributes and element text are typed differently, and this matters: element text is type-inferred, so <total>228.99</total> becomes "type": "number", while attribute values are kept as they were written — qty="1" and price="149.99" stay "type": "string" in JSON Schema. Prefer element text for numeric data you want typed, or cast attribute values after decoding. One more trap: a single <item> would not be recognized as a list, so make sure repeated elements appear at least twice in the sample.

Annotations, nulls and nested arrays in the generated JSON Schema

The document declares draft-06 in $schema and its top level is nothing but a $ref pointing at #/definitions/Root — every type, the root included, lives under definitions with a title matching its name. Each object sets additionalProperties to false, so unknown keys fail validation, and lists every property the sample exhibited in an alphabetically sorted required array. Those two defaults are deliberately strict: loosen them by deleting names from required or flipping additionalProperties to true before validating payloads that legitimately carry extra fields.

A property sampled only as null validates as type null and is still listed in required — the schema insists the key be present and empty. Merge a document where the field carries a value and it widens into an anyOf of the observed types plus a null branch, which is the shape you actually want for a nullable field. A property missing from one of the merged samples simply drops out of required while keeping its type, so optional and nullable stay distinguishable — a distinction most hand-written schemas blur.

Nested objects are never inlined: each becomes its own entry under definitions and is referenced with a $ref, so the schema stays flat and the definitions are reusable from other schemas. Arrays are type array with an items subschema pointing at the element's $ref, which is why one Item definition covers every element. A single-element array still produces a full definition, but an empty array degrades to an empty items object that matches anything at all — replace empty arrays in the sample before trusting the result.