JSON Schema Generator

What is JSON Schema?

JSON Schema is a vocabulary that allows you to validate, annotate, and describe JSON data. It defines the structure, types, and constraints that JSON documents must follow.

This tool analyzes your sample JSON and generates a schema that matches its structure. You can then use this schema to validate other JSON documents.

How It Works

1. Paste sample JSON — Provide a representative example
2. Configure options — Set title, required fields, format detection
3. Generate — Get a JSON Schema (draft 2020-12)
4. Validate — Use the schema to validate other data

Generated Schema Features

Type inference

The generator detects JSON types and maps them to schema types:

Format detection

When enabled, the generator recognizes common string formats:

• email — user@example.com
• uri — https://example.com
• date-time — 2024-01-15T10:30:00Z
• date — 2024-01-15
• time — 10:30:00
• uuid — 550e8400-e29b-41d4-a716-446655440000
• ipv4 — 192.168.1.1

Example

From this JSON:

{
  "name": "John",
  "email": "john@example.com",
  "age": 30
}

Generates this schema:

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "title": "Generated Schema",
  "type": "object",
  "properties": {
    "name": { "type": "string" },
    "email": { "type": "string", "format": "email" },
    "age": { "type": "integer" }
  },
  "required": ["name", "email", "age"]
}

Options Explained

Mark all required

When enabled, all non-null properties are added to the required array. Disable this for schemas where most fields are optional.

Detect formats

Automatically adds format keywords for recognized patterns like emails and dates. Validators can use these for stricter validation.

Include examples

Adds examples arrays with values from your sample data. Useful for documentation and API specifications.

Using the Generated Schema

Validate with our tool

Copy the schema and paste it into our JSON Schema Validator to validate other JSON documents.

JavaScript validation

import Ajv from 'ajv';

const ajv = new Ajv();
const validate = ajv.compile(schema);

const valid = validate(data);
if (!valid) console.log(validate.errors);

Python validation

from jsonschema import validate, ValidationError

try:
    validate(instance=data, schema=schema)
except ValidationError as e:
    print(e.message)

Limitations

• Single sample — Schema is based on one example; edge cases may not be covered
• No constraints — Doesn't infer min/max, patterns, or enums
• Array type from first element — Mixed-type arrays need manual adjustment

After generating, review and enhance the schema with additional constraints based on your requirements.

Related Tools

• JSON Schema Validator — Validate JSON against schema
• JSON Validator — Basic JSON validation
• JSON to TypeScript — Generate TS interfaces
• JSON to Python — Generate Python dataclasses

Frequently Asked Questions

What JSON Schema version is generated?

The generator outputs JSON Schema draft 2020-12, the latest version. It's compatible with most modern validators.

How do I add custom validation rules?

Edit the generated schema manually. Add minimum, maximum,pattern, enum, or other constraints as needed.

Can I generate from multiple samples?

Currently, the generator uses a single sample. For complex schemas with optional fields, create a sample that includes all possible fields, then manually mark optional ones.

Common Mistakes & Pro Tips

• Generated schemas are a starting point — Inference can only describe the one sample you gave it. It cannot know which fields are truly required, what the allowed enum values are, or what string formats apply. Treat the output as a scaffold and hand-tune it before using it for real validation.
• Required vs optional is a guess — From a single example the generator typically marks every present field as required (or, alternately, none). If your real data has optional fields, edit the "required" array; feeding multiple representative samples, where supported, gives a better picture of which keys are always present.
• Arrays are inferred from element samples — The element schema is derived from the items present in your sample array. An empty array yields no item constraints, and a heterogeneous array may collapse to a loose type or an "anyOf". Verify the inferred "items" schema covers every variant your data can actually contain.
• No enums, patterns, or ranges by default — Inference produces broad types like "string" or "number" without "enum", "pattern", "minimum", or "format". A status field becomes a plain string, not an enum of allowed values. Add these constraints manually to make the schema actually enforce your business rules.
• Null values widen the type — If a sampled field is null, the generator may infer "type": "null" or omit a useful type, which then rejects real non-null values. Decide whether the field is nullable and, if so, use a union like "type": ["string", "null"] rather than leaving it as null-only.