JSON Schema Generator

JSON Schema is a declarative vocabulary for annotating and validating JSON documents, defined across multiple IETF drafts (Draft 4 / 6 / 7 / 2019-09 / 2020-12). The latest is Draft 2020-12, which defines seven primitive types (string, number, integer, boolean, array, object, null), an open-ended format vocabulary (email, uri, date-time, uuid, ipv4, hostname, ...), and dozens of constraint keywords: pattern (regex), minimum/maximum/exclusiveMinimum/exclusiveMaximum (number range), minLength/maxLength (string length), minItems/maxItems/uniqueItems (array constraints), required (object-level required array), additionalProperties (whether extra fields are allowed), enum and const (allowed values), and $ref (subschema reuse). The page generates Draft 2020-12 output by default, with the older Draft-07 (still the most common in production schemas) selectable from the dropdown. The generator's inference is a single pass over the user-supplied JSON, building a schema object recursively. The map at the heart of the inference is: integer (Number.isInteger and no fractional part) -> {type: 'integer'}, float -> {type: 'number'}, string -> {type: 'string'}, boolean -> {type: 'boolean'}, array -> {type: 'array', items: <recurse on the first element>} or {type: 'array', prefixItems: [...]} for tuples in Draft 2020-12, object -> {type: 'object', properties: <recurse on each key>}, null -> {type: 'null'}. For arrays of mixed element types the generator emits a oneOf subschema covering each observed type. For multiple sample objects, the generator compares them to assemble the required list: a key is required if it appears in every sample, optional if any sample omits it. Patterns and constraints are inferred when samples cluster: if all numbers in a field fall in [1, 100], the generator emits {type: 'integer', minimum: 1, maximum: 100}; if a string field is always a UUID, the generator tags it with format: 'uuid' and emits a pattern: '^[0-9a-f]{8}-...' regex. The enum heuristic fires when a string field takes ≤10 distinct values across the samples (e.g. role: 'admin' | 'editor' | 'viewer' all observed), in which case the generator emits an enum array. Deeply nested objects and recursive structures are extracted into a $defs section (Draft 2020-12; the older $definitions is the Draft-07 keyword) and referenced via $ref. Recursive structures — e.g. a tree node with a 'children' field of type tree node — get a stub $ref pointing to the parent's $defs entry, which the validator resolves at validation time. The generator picks the right ref-vs-inline trade-off automatically: shallow schemas stay inline, deep ones get broken into definitions to keep the output readable. Generated schemas are deterministic for a given input: the same JSON samples always produce the same schema, and the generator is implemented in pure JavaScript with no remote calls.

• Type inference rules: integer numbers -> integer, floating-point -> number, strings -> string, booleans -> boolean, arrays -> array + items, objects -> object + properties. JSON null -> type: null (Draft 6+) or type: 'null' string.
• Required field detection: comparing all sample objects, fields present in every object are treated as required and added to the required array; missing ones are optional. Single-sample input leaves required: [] since the heuristic needs at least two samples.
• Enum inference heuristic: when a field takes a small finite set of distinct string values across samples (cardinality <= 10), it is auto-recognised as an enum constraint. Larger cardinalities stay as plain string type.
• Auto-detected format: based on string signatures, fields are tagged with format hints like email, uri, date-time, uuid for documentation and validation. The format keyword is informational in Draft 2020-12 - validators can choose to enforce or ignore it.
• Nested $ref extraction: deeply nested objects are extracted into internal $defs (Draft 2020-12 keyword; the older $definitions is from Draft 7) and referenced via $ref, keeping the Schema from getting too verbose. Recursive structures get a stub $ref pointing to the parent's $defs entry.
• Constraint expansion: beyond basic types, you can also add minimum/maximum (number range), minLength/maxLength (string length), pattern (regex), and similar constraints. The generator emits these when input samples cluster on specific values.
• Draft selection: 2020-12 (the latest) is the default and uses $defs; 2019-09 uses $defs as well; Draft-07 uses $definitions and is what most existing tools still emit. Draft 6 introduced strict-required semantics where required fields are listed in the parent's required array rather than as a sibling property.
• Composition keywords (Draft 2019-09+): allOf (must match all subschemas), anyOf (at least one), oneOf (exactly one), not (must not match). The generator picks oneOf when sample values fit two disjoint subschemas (e.g. integer vs string).