Paste any JSON document and get a valid JSON Schema (draft-07) generated instantly. The schema infers types, detects integers vs floats, handles nested objects and arrays, and marks all present keys as required.

JSON Schema is a vocabulary for describing the structure of JSON data. It lets you define what fields are expected, what types they should be, and which are required. Schemas are used for:

• Validation — reject payloads that don't match the expected shape
• Documentation — self-describing contracts for APIs
• Code generation — tools like QuickType generate TypeScript types from JSON Schema
• Form generation — libraries like react-jsonschema-form render UIs from schemas

A generated schema is a starting point — you'll usually refine it by adding constraints like minLength, minimum, enum, and format.

Here is a simple JSON document and the schema this tool generates from it:

Input JSON:

{
  "id": 1,
  "name": "Alice",
  "email": "alice@example.com",
  "active": true,
  "roles": ["admin", "editor"]
}

Generated Schema:

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "id":     { "type": "integer" },
    "name":   { "type": "string" },
    "email":  { "type": "string" },
    "active": { "type": "boolean" },
    "roles":  { "type": "array", "items": { "type": "string" } }
  },
  "required": ["id", "name", "email", "active", "roles"]
}

Key fields:

• $schema — declares which draft of the spec this schema follows
• type — the JSON type: object, array, string, number, integer, boolean, null
• properties — defines the schema for each key in an object
• required — lists keys that must be present for the document to be valid
• items — defines the schema for elements inside an array

The generated schema captures types and structure. Most real schemas also need constraints.

String constraints:

{ "type": "string", "minLength": 1, "maxLength": 255 }
{ "type": "string", "format": "email" }
{ "type": "string", "format": "date-time" }
{ "type": "string", "pattern": "^[A-Z]{2}[0-9]{6}$" }

Number constraints:

{ "type": "integer", "minimum": 1, "maximum": 100 }
{ "type": "number",  "exclusiveMinimum": 0 }

Enum — restrict to a fixed set of values:

{ "type": "string", "enum": ["admin", "editor", "viewer"] }

To make a field optional, remove it from the required array. A field absent from required may be missing; if present, it must still match its schema.

Nullable fields use a type array:

{ "type": ["string", "null"] }

Common format values: email, uri, date, date-time, time, uuid, ipv4, ipv6.

AJV is the dominant JSON Schema validator for Node.js — used by hundreds of thousands of packages:

const Ajv = require("ajv");
const ajv = new Ajv();
const valid = ajv.validate(schema, data);

FastAPI (Python) uses Pydantic models internally. Pydantic generates JSON Schema automatically, which FastAPI exposes as the OpenAPI documentation for every endpoint.

OpenAPI 3.x uses a JSON Schema subset to define request bodies, response payloads, and query parameters. The schema behind every Swagger UI you've seen is JSON Schema.

VS Code resolves JSON Schema for thousands of config files — package.json, tsconfig.json, .eslintrc — from the SchemaStore. That's where the IntelliSense and inline validation comes from.

Libraries like react-jsonschema-form and jsonforms render complete forms directly from a JSON Schema: inputs, labels, validation, conditionals — no custom UI code required.