JSON Schema

https://json-schema.org/understanding-json-schema/
Admin
JSON Schema is a vocabulary for validating JSON data structures, providing comprehensive tools for...
Tokens:27,054
Snippets:247
Trust Score:9.9
Update:1 week ago
Show doc for...
Tokens:
Raw
### allOf data examples

Source: https://json-schema.org/understanding-json-schema/reference/combining

Data examples for the allOf schema: "short" is valid, "too long" is invalid.

```json
"short"
```

```json
"too long"
```

--------------------------------

### Valid data example

Source: https://json-schema.org/understanding-json-schema/reference/const

Example data that satisfies the const constraint.

```json
{ "country": "United States of America" }
```

--------------------------------

### Illogical allOf data examples

Source: https://json-schema.org/understanding-json-schema/reference/combining

Data examples for the illogical schema: "No way" and -1 are both invalid.

```json
"No way"
```

```json
-1
```

--------------------------------

### anyOf data examples

Source: https://json-schema.org/understanding-json-schema/reference/combining

Data examples for the anyOf schema: "short" and 12 are valid, "too long" and -5 are invalid.

```json
"short"
```

```json
"too long"
```

```json
12
```

```json
-5
```

--------------------------------

### Disallowed circular $ref example

Source: https://json-schema.org/understanding-json-schema/structuring

An example of two `$ref` keywords referring to each other, which is explicitly disallowed because it could cause an infinite loop in the resolver.

```json
{ "$defs": { "alice": { "$ref": "#/$defs/bob" }, "bob": { "$ref": "#/$defs/alice" } }}
```

--------------------------------

### not data examples

Source: https://json-schema.org/understanding-json-schema/reference/combining

Data examples for the not schema: 42 and {"key":"value"} are valid, "I am a string" is invalid.

```json
42
```

```json
{ "key": "value" }
```

```json
"I am a string"
```

--------------------------------

### Invalid data example

Source: https://json-schema.org/understanding-json-schema/reference/const

Example data that does not satisfy the const constraint.

```json
{ "country": "Canada" }
```

--------------------------------

### Multiple of 0.01 data examples

Source: https://json-schema.org/understanding-json-schema/reference/numeric

Examples of valid and invalid data for the multipleOf 0.01 schema. 4.02 is valid, while 4.021 is invalid.

```json
4.02
```

```json
4.021
```

--------------------------------

### JSON array example

Source: https://json-schema.org/understanding-json-schema/about

Shows a JSON array with string elements.

```json
[ "first", "second", "third" ]
```

--------------------------------

### Multiple of 10 data examples

Source: https://json-schema.org/understanding-json-schema/reference/numeric

Examples of valid and invalid data for the multipleOf 10 schema. 0, 10, and 20 are valid, while 23 is invalid.

```json
0
```

```json
10
```

```json
20
```

```json
23
```

--------------------------------

### JSON object example

Source: https://json-schema.org/understanding-json-schema/about

Shows a simple JSON object with key-value pairs.

```json
{ "key1": "value1", "key2": "value2" }
```

--------------------------------

### JSON string example

Source: https://json-schema.org/understanding-json-schema/about

Shows a JSON string value.

```json
"This is a string"
```

--------------------------------

### oneOf data examples

Source: https://json-schema.org/understanding-json-schema/reference/combining

Data examples for the oneOf schema: 10 and 9 are valid, 2 is invalid (not a multiple of either), 15 is invalid (multiple of both).

```json
10
```

```json
9
```

```json
2
```

```json
15
```

--------------------------------

### JSON number example

Source: https://json-schema.org/understanding-json-schema/about

Shows a JSON number value.

```json
423.1415926
```

--------------------------------

### Integer type data examples

Source: https://json-schema.org/understanding-json-schema/reference/numeric

Examples of valid and invalid data for the integer type. 42 and -1 are valid, 1.0 is valid (zero fractional part), 3.1415926 is rejected, and "42" is rejected.

```json
42
```

```json
-1
```

```json
1.0
```

```json
3.1415926
```

```json
"42"
```

--------------------------------

### JSON null example

Source: https://json-schema.org/understanding-json-schema/about

Shows the JSON null value.

```json
null
```

--------------------------------

### JSON boolean example

Source: https://json-schema.org/understanding-json-schema/about

Shows JSON boolean values.

```json
true false
```

--------------------------------

### true schema accepts any valid JSON

Source: https://json-schema.org/understanding-json-schema/basics

Using true in place of an empty object represents a schema that matches anything. The example shows the schema and three valid data examples.

```json
true
```

```json
42
```

```json
"I'm a string"
```

```json
{ "an": [ "arbitrarily", "nested" ], "data": "structure" }
```

--------------------------------

### allOf schema example

Source: https://json-schema.org/understanding-json-schema/reference/combining

Schema using allOf to require validation against all subschemas. The data must be a string and have maxLength 5.

```json
{ "allOf": [ { "type": "string" }, { "maxLength": 5 } ]}
```

--------------------------------

### Number type data examples

Source: https://json-schema.org/understanding-json-schema/reference/numeric

Examples of valid and invalid data for the number type. 42, -1, 5.0, and 2.99792458e8 are valid, while "42" is rejected.

```json
42
```

```json
-1
```

```json
5.0
```

```json
2.99792458e8
```

```json
"42"
```

--------------------------------

### Range data examples

Source: https://json-schema.org/understanding-json-schema/reference/numeric

Examples of valid and invalid data for the range schema. -1 is invalid, 0 is valid (minimum inclusive), 10 and 99 are valid, 100 is invalid (exclusiveMaximum exclusive), and 101 is invalid.

```json
-1
```

```json
0
```

```json
10
```

```json
99
```

```json
100
```

```json
101
```

--------------------------------

### Empty object is valid

Source: https://json-schema.org/understanding-json-schema/reference/object

Example of an empty object, which is valid by default because properties are optional.

```json
{ }
```

--------------------------------

### not schema example

Source: https://json-schema.org/understanding-json-schema/reference/combining

Schema using not to validate anything that is not a string.

```json
{ "not": { "type": "string" } }
```

--------------------------------

### Empty schema accepts any valid JSON

Source: https://json-schema.org/understanding-json-schema/basics

An empty object is a valid JSON Schema that accepts any valid JSON document. The example shows the schema and three valid data examples.

```json
{}
```

```json
42
```

```json
"I'm a string"
```

```json
{ "an": [ "arbitrarily", "nested" ], "data": "structure" }
```

--------------------------------

### Object with numeric values

Source: https://json-schema.org/understanding-json-schema/reference/object

Example of a JSON object with numeric values, demonstrating that values can be any JSON type.

```json
{ "Sun": 1.9891e30, "Jupiter": 1.8986e27, "Saturn": 5.6846e26, "Neptune": 10.243e25, "Uranus": 8.6810e25, "Earth": 5.9736e24, "Venus": 4.8685e24, "Mars": 6.4185e23, "Mercury": 3.3022e23, "Moon": 7.349e22, "Pluto": 1.25e22}
```

--------------------------------

### Pattern for strings starting and ending with double curly braces

Source: https://json-schema.org/understanding-json-schema/reference/regular_expressions

Checks that the string starts with {{ and ends with }} and allows multiline strings. The pattern uses a character class to match any character including newlines.

```json
{ "type": "string", "pattern": "^\\{\\{(.|[\
\
])*\\}\\}$",}
```

```json
"{{ foo\nbar }}"
```

```json
"{ foo }"
```

--------------------------------

### false schema always invalidates documents

Source: https://json-schema.org/understanding-json-schema/basics

Using false as a schema matches nothing, so documents for this schema will always be invalid. The example shows the schema and a data example that will always fail.

```json
false
```

```json
"Resistance is futile... This will always fail!!!"
```

--------------------------------

### anyOf schema example

Source: https://json-schema.org/understanding-json-schema/reference/combining

Schema using anyOf to require validation against at least one subschema. Accepts a string with maxLength 5 or a non-negative number.

```json
{ "anyOf": [ { "type": "string", "maxLength": 5 }, { "type": "number", "minimum": 0 } ]}
```

--------------------------------

### Illogical allOf schema example

Source: https://json-schema.org/understanding-json-schema/reference/combining

Schema using allOf with contradictory types (string and number) that validates nothing.

```json
{ "allOf": [ { "type": "string" }, { "type": "number" } ]}
```

--------------------------------

### dependentSchemas example: conditional billing_address requirement

Source: https://json-schema.org/understanding-json-schema/reference/conditionals

Schema requires billing_address when credit_card is present. The data examples show valid and invalid instances: the first has both credit_card and billing_address, the second lacks billing_address (fails), and the third has billing_address without credit_card (passes).

```json
{ "type": "object", "properties": { "name": { "type": "string" }, "credit_card": { "type": "number" } }, "required": ["name"], "dependentSchemas": { "credit_card": { "properties": { "billing_address": { "type": "string" } }, "required": ["billing_address"] } } }
```

```json
{ "name": "John Doe", "credit_card": 5555555555555555, "billing_address": "555 Debtor's Lane" }
```

```json
{ "name": "John Doe", "credit_card": 5555555555555555 }
```

```json
{ "name": "John Doe", "billing_address": "555 Debtor's Lane" }
```

--------------------------------

### Valid address data

Source: https://json-schema.org/understanding-json-schema/reference/object

Example of an address object that matches the schema, with correct types for each property.

```json
{ "number": 1600, "street_name": "Pennsylvania", "street_type": "Avenue" }
```

--------------------------------

### String type schema and data examples

Source: https://json-schema.org/understanding-json-schema/reference/string

The schema defines a string type. The data examples show valid and invalid strings: "Déjà vu", "", and "42" are valid strings, while 42 is not a string.

```json
{ "type": "string" }
```

```json
"Déjà vu"
```

```json
""
```

```json
"42"
```

```json
42
```

--------------------------------

### Valid object data

Source: https://json-schema.org/understanding-json-schema/reference/object

Example of a JSON object with string keys and values, which is valid against the basic object schema.

```json
{ "key": "value", "another_key": "another_value"}
```

--------------------------------

### Address data with additional property

Source: https://json-schema.org/understanding-json-schema/reference/object

Example of an address object with an extra property `direction`. By default, additional properties are valid.

```json
{ "number": 1600, "street_name": "Pennsylvania", "street_type": "Avenue", "direction": "NW" }
```

--------------------------------

### Invalid object with non-string keys

Source: https://json-schema.org/understanding-json-schema/reference/object

Example of invalid JSON because keys are numbers, not strings. This is not a valid JSON object.

```json
{ 0.01: "cm", 1: "m", 1000: "km"}
```

--------------------------------

### Invalid data: string is not an object

Source: https://json-schema.org/understanding-json-schema/reference/object

Example of data that is not an object, so it fails validation against a schema with `type: "object"`.

```json
"Not an object"
```

--------------------------------

### Using type as a single string

Source: https://json-schema.org/understanding-json-schema/reference/type

The `type` keyword as a single string specifies that the instance data must match that exact type. The example shows a schema requiring a number, with valid data `42` and `42.0`, and invalid data `"42"`.

```json
{ "type": "number" }
```

```json
42
```

```json
42.0
```

```json
"42"
```

--------------------------------

### Invalid data with 0 for extended enum

Source: https://json-schema.org/understanding-json-schema/reference/enum

Example data with color 0, which is not in the enum and therefore invalid.

```json
{ "color": 0 }
```

--------------------------------

### Data for recursive schema (royal family tree)

Source: https://json-schema.org/understanding-json-schema/structuring

Example data that matches the recursive `person` schema, showing a snippet of the British royal family tree. Demonstrates how nested `children` arrays are validated against the recursive schema.

```json
{ "name": "Elizabeth", "children": [ { "name": "Charles", "children": [ { "name": "William", "children": [ { "name": "George" }, { "name": "Charlotte" } ] }, { "name": "Harry" } ] } ] }
```

--------------------------------

### Valid data with number for shape enum

Source: https://json-schema.org/understanding-json-schema/reference/enum

Example data with shape 1, which is valid because 1 is included in the enum.

```json
{ "shape": 1 }
```

--------------------------------

### oneOf schema example

Source: https://json-schema.org/understanding-json-schema/reference/combining

Schema using oneOf to require validation against exactly one subschema. Accepts a number that is a multiple of 5 or 3, but not both.

```json
{ "oneOf": [ { "type": "number", "multipleOf": 5 }, { "type": "number", "multipleOf": 3 } ]}
```

--------------------------------

### Valid data for street light colors

Source: https://json-schema.org/understanding-json-schema/reference/enum

Example data with color "red", which is valid according to the basic enum schema.

```json
{ "color": "red" }
```

--------------------------------

### Using type as an array of strings

Source: https://json-schema.org/understanding-json-schema/reference/type

When `type` is an array, the instance data is valid if it matches any of the listed types. The example shows a schema accepting `number` or `string`, with valid data `42` and `"Life, the universe, and everything"`, and invalid data `["Life", "the universe", "and everything"]`.

```json
{ "type": ["number", "string"] }
```

```json
42
```

```json
"Life, the universe, and everything"
```

```json
["Life", "the universe", "and everything"]
```

--------------------------------

### Invalid data: array is not an object

Source: https://json-schema.org/understanding-json-schema/reference/object

Example of data that is an array, not an object, so it fails validation against a schema with `type: "object"`.

```json
["An", "array", "not", "an", "object"]
```

--------------------------------

### Meta-data keyword units

Source: https://json-schema.org/understanding-json-schema/reference/schema

Meta-data keyword example: adds a 'units' keyword to a number schema. Data 42 passes, data "42" fails because the type is number.

```json
{ "type": "number", "units": "kg"}
```

```json
42
```

```json
"42"
```

--------------------------------

### Invalid data for street light colors

Source: https://json-schema.org/understanding-json-schema/reference/enum

Example data with color "blue", which is not in the enum and therefore invalid.

```json
{ "color": "blue" }
```

--------------------------------

### Valid data with string for shape enum

Source: https://json-schema.org/understanding-json-schema/reference/enum

Example data with shape "circle", which is valid according to the mixed-type enum schema.

```json
{ "shape": "circle" }
```

--------------------------------

### Invalid data with string for shape enum

Source: https://json-schema.org/understanding-json-schema/reference/enum

Example data with shape "triangle", which is not in the enum and therefore invalid.

```json
{ "shape": "triangle" }
```

--------------------------------

### Valid data with null for extended enum

Source: https://json-schema.org/understanding-json-schema/reference/enum

Example data with color null, which is valid because null is included in the extended enum.

```json
{ "color": null }
```

--------------------------------

### Valid data with number 42 for extended enum

Source: https://json-schema.org/understanding-json-schema/reference/enum

Example data with color 42, which is valid because 42 is included in the extended enum.

```json
{ "color": 42 }
```

--------------------------------

### Address data missing optional property

Source: https://json-schema.org/understanding-json-schema/reference/object

Example of an address object missing the `street_type` property. By default, missing properties are valid.

```json
{ "number": 1600, "street_name": "Pennsylvania" }
```

--------------------------------

### Valid data with null for shape enum

Source: https://json-schema.org/understanding-json-schema/reference/enum

Example data with shape null, which is valid because null is included in the enum.

```json
{ "shape": null }
```

--------------------------------

### Declaring $schema for draft 2020-12

Source: https://json-schema.org/understanding-json-schema/basics

The $schema keyword declares which version of the JSON Schema specification the schema is written to. This example uses the 2020-12 draft URI.

```json
{ "$schema": "https://json-schema.org/draft/2020-12/schema" }
```

--------------------------------

### Invalid address data with wrong type

Source: https://json-schema.org/understanding-json-schema/reference/object

Example of an address object where `number` is a string instead of a number, making it invalid against the schema.

```json
{ "number": "1600", "street_name": "Pennsylvania", "street_type": "Avenue" }
```

--------------------------------

### String length constraints with minLength and maxLength

Source: https://json-schema.org/understanding-json-schema/reference/string

The schema uses minLength and maxLength to constrain string length to between 2 and 3 characters. Data examples show that "A" is invalid (too short), "AB" and "ABC" are valid, and "ABCD" is invalid (too long).

```json
{ "type": "string", "minLength": 2, "maxLength": 3}
```

```json
"A"
```

```json
"AB"
```

```json
"ABC"
```

```json
"ABCD"
```

--------------------------------

### type keyword restricts to string

Source: https://json-schema.org/understanding-json-schema/basics

The type keyword restricts the schema to a specific type. This example shows a schema that only accepts strings, with a valid string and an invalid number.

```json
{ "type": "string" }
```

```json
"I'm a string"
```

```json
42
```

--------------------------------

### dependentRequired: bidirectional dependencies between credit_card and billing_address

Source: https://json-schema.org/understanding-json-schema/reference/conditionals

Defines bidirectional dependencies between credit_card and billing_address. Data examples show that missing either property is invalid: credit_card without billing_address and billing_address without credit_card.

```json
{ "type": "object",
  "properties": { "name": { "type": "string" }, "credit_card": { "type": "number" }, "billing_address": { "type": "string" } },
  "required": ["name"],
  "dependentRequired": { "credit_card": ["billing_address"], "billing_address": ["credit_card"] }
}
```

```json
{ "name": "John Doe", "credit_card": 5555555555555555
}
```

```json
{ "name": "John Doe", "billing_address": "555 Debtor's Lane"
}
```

--------------------------------

### Declaring $id as unique identifier

Source: https://json-schema.org/understanding-json-schema/basics

The $id property provides a unique identifier for the schema. Set it to a URL at a domain you control, as shown in this example.

```json
{ "$id": "http://yourdomain.com/schemas/myschema.json" }
```

--------------------------------

### Validate country-specific postal codes using if-then-else in allOf

Source: https://json-schema.org/understanding-json-schema/reference/conditionals

Using if-then-else with allOf to validate postal codes for multiple countries. The if schemas include the required keyword to ensure only the applicable country's then schema applies; without it, all then schemas would apply when country is absent. The first if schema omits required to act as a default for the USA. Data examples verify both valid and invalid postal codes.

```json
{ "type": "object", "properties": { "street_address": { "type": "string" }, "country": { "default": "United States of America", "enum": ["United States of America", "Canada", "Netherlands"] } }, "allOf": [ { "if": { "properties": { "country": { "const": "United States of America" } } }, "then": { "properties": { "postal_code": { "pattern": "[0-9]{5}(-[0-9]{4})?" } } } }, { "if": { "properties": { "country": { "const": "Canada" } }, "required": ["country"] }, "then": { "properties": { "postal_code": { "pattern": "[A-Z][0-9][A-Z] [0-9][A-Z][0-9]" } } } }, { "if": { "properties": { "country": { "const": "Netherlands" } }, "required": ["country"] }, "then": { "properties": { "postal_code": { "pattern": "[0-9]{4} [A-Z]{2}" } } } } ]}
```

```json
{ "street_address": "1600 Pennsylvania Avenue NW", "country": "United States of America", "postal_code": "20500"}
```

```json
{ "street_address": "1600 Pennsylvania Avenue NW", "postal_code": "20500"}
```

```json
{ "street_address": "24 Sussex Drive", "country": "Canada", "postal_code": "K1M 1M4"}
```

```json
{ "street_address": "Adriaan Goekooplaan", "country": "Netherlands", "postal_code": "2517 JX"}
```

```json
{ "street_address": "24 Sussex Drive", "country": "Canada", "postal_code": "10000"}
```

```json
{ "street_address": "1600 Pennsylvania Avenue NW", "postal_code": "K1M 1M4"}
```

--------------------------------

### dependentRequired: conditional requirement of credit_card and billing_address

Source: https://json-schema.org/understanding-json-schema/reference/conditionals

Demonstrates the dependentRequired keyword: if credit_card is present, billing_address must also be present. Data examples show valid (both present, neither present, only billing_address) and invalid (credit_card without billing_address) cases.

```json
{ "type": "object",
  "properties": { "name": { "type": "string" }, "credit_card": { "type": "number" }, "billing_address": { "type": "string" } },
  "required": ["name"],
  "dependentRequired": { "credit_card": ["billing_address"] }
}
```

```json
{ "name": "John Doe", "credit_card": 5555555555555555, "billing_address": "555 Debtor's Lane"
}
```

```json
{ "name": "John Doe", "credit_card": 5555555555555555
}
```

```json
{ "name": "John Doe"
}
```

```json
{ "name": "John Doe", "billing_address": "555 Debtor's Lane"
}
```

--------------------------------

### if-then-else schema for US and Canada postal codes

Source: https://json-schema.org/understanding-json-schema/reference/conditionals

Schema uses if to check country, then applies US zipcode pattern or else Canadian postal code pattern. The data examples show valid and invalid instances: US address with valid zipcode, US address without country (defaults to US), Canadian address with valid postal code, Canadian address with invalid postal code, and US address with Canadian postal code (fails).

```json
{ "type": "object", "properties": { "street_address": { "type": "string" }, "country": { "default": "United States of America", "enum": ["United States of America", "Canada"] } }, "if": { "properties": { "country": { "const": "United States of America" } } }, "then": { "properties": { "postal_code": { "pattern": "[0-9]{5}(-[0-9]{4})?" } } }, "else": { "properties": { "postal_code": { "pattern": "[A-Z][0-9][A-Z] [0-9][A-Z][0-9]" } } } }
```

```json
{ "street_address": "1600 Pennsylvania Avenue NW", "country": "United States of America", "postal_code": "20500" }
```

```json
{ "street_address": "1600 Pennsylvania Avenue NW", "postal_code": "20500" }
```

```json
{ "street_address": "24 Sussex Drive", "country": "Canada", "postal_code": "K1M 1M4" }
```

```json
{ "street_address": "24 Sussex Drive", "country": "Canada", "postal_code": "10000" }
```

```json
{ "street_address": "1600 Pennsylvania Avenue NW", "postal_code": "K1M 1M4" }
```

--------------------------------

### Schema with allOf and additionalProperties: false

Source: https://json-schema.org/understanding-json-schema/reference/object

This schema attempts to extend an address schema with a 'type' property using allOf, but additionalProperties: false in the base schema causes the extension to fail.

```json
{ "allOf": [ { "type": "object", "properties": { "street_address": { "type": "string" }, "city": { "type": "string" }, "state": { "type": "string" } }, "required": ["street_address", "city", "state"], "additionalProperties": false } ],  
"properties": { "type": { "enum": [ "residential", "business" ] } }, "required": ["type"]}  
```

--------------------------------

### Schema with const keyword

Source: https://json-schema.org/understanding-json-schema/reference/const

Defines a property 'country' that must equal the string 'United States of America'.

```json
{ "properties": { "country": { "const": "United States of America" } }}
```

--------------------------------

### Schema with properties keyword

Source: https://json-schema.org/understanding-json-schema/reference/object

Schema for an address object with properties `number`, `street_name`, and `street_type`. The `properties` keyword defines schemas for each property.

```json
{ "type": "object", "properties": { "number": { "type": "number" }, "street_name": { "type": "string" }, "street_type": { "enum": ["Street", "Avenue", "Boulevard"] } }}
```

--------------------------------

### Simple person JSON record

Source: https://json-schema.org/understanding-json-schema/about

A simple JSON representation of a person with name, birthday, and address as strings.

```json
{ "name": "George Washington", "birthday": "February 22, 1732", "address": "Mount Vernon, Virginia, United States"}
```

--------------------------------

### Workaround schema with additionalProperties in extending schema

Source: https://json-schema.org/understanding-json-schema/reference/object

This schema moves additionalProperties to the extending schema and redeclares the properties from the extended schema, allowing the extension to work.

```json
{ "allOf": [ { "type": "object", "properties": { "street_address": { "type": "string" }, "city": { "type": "string" }, "state": { "type": "string" } }, "required": ["street_address", "city", "state"] } ],  
"properties": { "street_address": true, "city": true, "state": true, "type": { "enum": [ "residential", "business" ] } }, "required": ["type"], "additionalProperties": false}  
```

--------------------------------

### Basic enum schema for street light colors

Source: https://json-schema.org/understanding-json-schema/reference/enum

Schema using enum to restrict the color property to "red", "amber", or "green". The enum array must have at least one element and each element must be unique.

```json
{ "properties": { "color": { "enum": ["red", "amber", "green"] } }}
```

--------------------------------

### Range schema with minimum and exclusiveMaximum

Source: https://json-schema.org/understanding-json-schema/reference/numeric

Schema that specifies a range from 0 (inclusive) to 100 (exclusive) using minimum and exclusiveMaximum.

```json
{ "type": "number", "minimum": 0, "exclusiveMaximum": 100}
```

--------------------------------

### Factoring schemas - factored oneOf

Source: https://json-schema.org/understanding-json-schema/reference/combining

Equivalent schema with common type factored out.

```json
{ "type": "number", "oneOf": [ { "multipleOf": 5 }, { "multipleOf": 3 } ]}
```

--------------------------------

### Basic object schema

Source: https://json-schema.org/understanding-json-schema/reference/object

Schema that validates any JSON object. The `type` keyword is set to "object".

```json
{ "type": "object" }
```

--------------------------------

### Compound Schema Document with embedded address schema

Source: https://json-schema.org/understanding-json-schema/structuring

A Compound Schema Document that bundles the customer schema and the address schema into a single document using `$id` in a subschema. The address schema is embedded at `/$defs/address` and uses Draft 7 while the customer schema uses Draft 2020-12. References like `$ref: "/schemas/address"` remain unchanged from the unbundled version.

```json
{ "$id": "https://example.com/schemas/customer", "$schema": "https://json-schema.org/draft/2020-12/schema", "type": "object", "properties": { "first_name": { "type": "string" }, "last_name": { "type": "string" }, "shipping_address": { "$ref": "/schemas/address" }, "billing_address": { "$ref": "/schemas/address" } }, "required": ["first_name", "last_name", "shipping_address", "billing_address"], "$defs": { "address": { "$id": "https://example.com/schemas/address", "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "street_address": { "type": "string" }, "city": { "type": "string" }, "state": { "$ref": "#/definitions/state" } }, "required": ["street_address", "city", "state"], "definitions": { "state": { "enum": ["CA", "NY", "... etc ..."] } } } }}
```

--------------------------------

### Multiple of 0.01 schema

Source: https://json-schema.org/understanding-json-schema/reference/numeric

Schema that restricts numbers to multiples of 0.01 using a floating point multipleOf value.

```json
{ "type": "number", "multipleOf" : 0.01}
```

--------------------------------

### JSON Schema fragment for person record

Source: https://json-schema.org/understanding-json-schema/about

A JSON Schema that describes the structure of the formal person record, specifying types and properties.

```json
{ "type": "object", "properties": { "first_name": { "type": "string" }, "last_name": { "type": "string" }, "birthday": { "type": "string", "format": "date" }, "address": { "type": "object", "properties": { "street_address": { "type": "string" }, "city": { "type": "string" }, "state": { "type": "string" }, "country": { "type" : "string" } } } }}
```

--------------------------------

### Formal person JSON record

Source: https://json-schema.org/understanding-json-schema/about

A more formal JSON representation of a person with separate first_name, last_name, birthday, and an address object.

```json
{ "first_name": "George", "last_name": "Washington", "birthday": "1732-02-22", "address": { "street_address": "3200 Mount Vernon Memorial Highway", "city": "Mount Vernon", "state": "Virginia", "country": "United States" }}
```

--------------------------------

### Custom keyword requiredProperties

Source: https://json-schema.org/understanding-json-schema/reference/schema

Least interoperable custom keyword: requiredProperties applies other schemas. Data { "foo": "bar" } passes, {} passes because requiredProperties is not understood, { "foo": 42 } passes because the validator doesn't understand the keyword.

```json
{ "type": "object", "requiredProperties": { "foo": { "type": "string" } }}
```

```json
{ "foo": "bar" }
```

```json
{}
```

```json
{ "foo": 42 }
```

--------------------------------

### Multiple of 10 schema

Source: https://json-schema.org/understanding-json-schema/reference/numeric

Schema that restricts numbers to multiples of 10 using the multipleOf keyword.

```json
{ "type": "number", "multipleOf" : 10}
```

--------------------------------

### Integer type schema

Source: https://json-schema.org/understanding-json-schema/reference/numeric

Schema that validates any integer value. In JSON, numbers with a zero fractional part (e.g., 1.0) are considered integers, while floating point numbers and strings are rejected.

```json
{ "type": "integer" }
```

--------------------------------

### Extended enum schema with null and number

Source: https://json-schema.org/understanding-json-schema/reference/enum

Schema extending the enum to include null (representing an "off" state) and the number 42, allowing multiple data types without explicitly setting a type.

```json
{ "properties": { "color": { "enum": ["red", "amber", "green", null, 42] } }}
```

--------------------------------

### Invalid data for workaround schema

Source: https://json-schema.org/understanding-json-schema/reference/object

This data object includes an extra property 'something that doesn't belong', which is not allowed by additionalProperties: false, causing validation to fail.

```json
{ "street_address": "1600 Pennsylvania Avenue NW", "city": "Washington", "state": "DC", "type": "business", "something that doesn't belong": "hi!"}  
```

--------------------------------

### Recursive schema with $ref: "#"

Source: https://json-schema.org/understanding-json-schema/structuring

A recursive schema that refers to itself using `$ref: "#"`. The `children` property is an array of items that are also `person` instances, allowing nested structures of arbitrary depth.

```json
{ "type": "object", "properties": { "name": { "type": "string" }, "children": { "type": "array", "items": { "$ref": "#" } } }}
```

--------------------------------

### Number type schema

Source: https://json-schema.org/understanding-json-schema/reference/numeric

Schema that validates any numeric type, either integers or floating point numbers.

```json
{ "type": "number" }
```

--------------------------------

### Draft 4 range schema with boolean exclusiveMaximum

Source: https://json-schema.org/understanding-json-schema/reference/numeric

Schema using the Draft 4 convention where exclusiveMaximum is a boolean indicating whether maximum is exclusive. Here, maximum is 100 and exclusiveMaximum is true, so values must be less than 100.

```json
{ "type": "number", "minimum": 0, "maximum": 100, "exclusiveMaximum": true}
```

--------------------------------

### Data failing additionalProperties

Source: https://json-schema.org/understanding-json-schema/reference/object

This data object includes 'type', which is considered additional by the schema's additionalProperties: false, causing validation to fail.

```json
{ "street_address": "1600 Pennsylvania Avenue NW", "city": "Washington", "state": "DC", "type": "business"}  
```

--------------------------------

### Data failing required

Source: https://json-schema.org/understanding-json-schema/reference/object

This data object omits 'type', which is required by the extending schema, causing validation to fail.

```json
{ "street_address": "1600 Pennsylvania Avenue NW", "city": "Washington", "state": "DC"}  
```

--------------------------------

### Telephone number pattern with optional area code

Source: https://json-schema.org/understanding-json-schema/reference/regular_expressions

Matches a simple North American telephone number with an optional area code. The pattern uses escaped parentheses for the area code and a greedy quantifier for the optional group.

```json
{ "type": "string", "pattern": "^(\\([0-9]{3}\\))?[0-9]{3}-[0-9]{4}$"}
```

```json
"555-1212"
```

```json
"(888)555-1212"
```

```json
"(888)555-1212 ext. 532"
```

```json
"(800)FLOWERS"
```

--------------------------------

### Mixed-type enum schema for shape

Source: https://json-schema.org/understanding-json-schema/reference/enum

Schema using enum to restrict the shape property to a mix of strings, a number, and null: "circle", "square", 1, and null.

```json
{ "properties": { "shape": { "enum": ["circle", "square", 1, null] } }}
```

--------------------------------

### Custom keyword isEven

Source: https://json-schema.org/understanding-json-schema/reference/schema

Custom keyword that doesn't affect validation: isEven. Data 2 validates, data 3 passes because the validator doesn't understand isEven, data "3" fails because type is integer.

```json
{ "type": "integer", "isEven": true}
```

```json
2
```

```json
3
```

```json
"3"
```
Tokens:
Raw