JSON Schema Validator

Drafts 4 through 2020-12, picked from $schema

Validation runs on @hyperjump/json-schema 1.18.0, an open-source validator by Jason Desrosiers (Hyperjump) that is listed on json-schema.org's tools page. A copy is served from this site with its MIT license. It covers the newer keywords too, including $dynamicRef, unevaluatedProperties, unevaluatedItems, dependentSchemas and prefixItems.

The draft comes from your $schema value, so http://json-schema.org/draft-07/schema# runs as draft 7 even if the selector says something else. The page tells you when that happens. A schema without $schema uses the selector, and Auto means 2020-12. Your schema is also checked against its draft's meta-schema first, so a typo like "type": "objekt" is reported as a schema error instead of silently passing.

Test suite results for this validator

We ran the official JSON Schema Test Suite (commit 5571928, October 13, 2026) against the exact json-schema-engine.js file this page loads, through the same function the Validate button calls. Remote schemas the suite needs were registered locally, since this page never fetches. Required tests are the core of each spec. Optional tests cover behavior the spec leaves open, and format tests check format as an assertion.

What still fails in the required tests: a schema whose $id is a file: URI (4 tests per draft; the library refuses to register those), a $ref with a sibling $id in drafts 4, 6 and 7 (2 tests), and a base URI change inside a subschema in drafts 4, 6 and 7 (2 tests). In format tests, leap-second times such as 23:59:60Z are rejected (6 tests in draft 7 and later). In 2019-09 and 2020-12, most optional failures (14 of 24, and 14 of 22) come from the old dependencies keyword, which those drafts replaced with dependentRequired and dependentSchemas.

Reading an error: instance path and schema path

Every error shows two JSON Pointers. The first, in code, is where the problem is in your data. The second, in brackets, is the keyword in your schema that failed. With the schema above and the data {"name":"","age":-1,"nickname":"A"} you get four errors:

• / missing required property: email (schema: /required)
• /name must be at least 1 character long (schema: /properties/name/minLength)
• /age must be >= 0, got -1 (schema: /properties/age/minimum)
• /nickname is not allowed ("additionalProperties" is false here) (schema: /additionalProperties)

Fix them from the top. A missing required property often explains the errors below it. Click either path in the results and the validator selects that spot in the text box, which helps a lot in long files.

Worked example: checking an API response

Pick API response with $ref and $defs in the example menu above. The schema describes an order: an id like ord_7f3k9q2m, a status from a fixed list, a three-letter currency, and an items array where every line item is checked against one shared definition in $defs/lineItem. The response has five mistakes, and the validator reports each one:

1. /status must be one of ["pending","paid","shipped","refunded"]. The value is "Paid". enum compares exactly, so case matters. Fix the data, or list both spellings if your API really sends both.
2. /currency must match pattern "^[A-Z]{3}$". "usd" is lowercase. Patterns are case sensitive and JSON Schema has no case-insensitive flag, so write the character class you need, such as ^[A-Za-z]{3}$.
3. /items/1/qty must be integer, got string. The second item has "qty": "1". Quoted numbers are strings in JSON. This one is very common when data passes through a form or a CSV first.
4. /items/2/price must be > 0, got 0. The schema uses "exclusiveMinimum": 0, so zero itself is not allowed. Use "minimum": 0 if free items are fine.
5. /items/2/color is not allowed. lineItem sets "additionalProperties": false, so any key that is not listed is rejected. Add color to properties if it is a real field.

Notice the schema paths for items 3 to 5 start with /$defs/lineItem. The error happened inside the referenced definition, so that is where you edit the rule, and the fix applies to every item at once. The /items/1 and /items/2 parts of the instance path are array indexes, counted from zero.

Common error messages and what to do

What changed between drafts

Most schemas work the same in every draft, but these differences cause real bugs when a schema written for one draft is read as another. That is why the $schema line matters.

The array form of items is the change that bites most often. In 2020-12, "items": [{...}, {...}] is a schema error, and the same tuple is written with prefixItems. The Tuple with prefixItems example above shows the 2020-12 way.

Large files

Validation runs in your browser tab, so the limit is your device's memory. In our test on October 20, 2026, in desktop Chrome, a 5 MB file with 50,000 records took about 0.6 seconds from click to result, and a 10 MB file with 100,000 records about 2 seconds. Phones are slower. Above about 400 KB, the page stops checking on every keystroke and waits for the Validate button, so typing stays smooth. If there are thousands of errors, the first 200 are listed with a button to show the rest. Usually they are the same mistake repeated, so fix the first one and check again.

Where this validator stops

• No remote references. A $ref to another file or URL is reported as unresolvable. Bundle the referenced schemas into $defs first.
• No custom meta-schemas. $schema must be one of the five official drafts. Custom vocabularies and OpenAPI dialects are not available here.
• Draft 3 and older are not supported.
• One schema, one instance. To check many files at once, use one of the libraries in the code section below in your CI.

JSON Schema mistakes that pass silently

• additionalProperties defaults to allowed. Unknown keys pass unless you set "additionalProperties": false.
• Typos in keyword names. "requried" is an unknown keyword, so it is ignored and the rule never runs.
• integer vs number. 1.5 fails integer but passes number. 1.0 counts as an integer in draft 6 and later.
• Draft differences. definitions became $defs, array-form items became prefixItems in 2020-12, and exclusiveMinimum changed from a boolean in draft 4 to a number. The table above has the full list. Set $schema so every tool reads your schema the same way.
• Keywords next to $ref in drafts 4 to 7. In those drafts, {"$ref": "#/definitions/x", "maxLength": 5} ignores the maxLength. Wrap both in allOf, or move to 2019-09 or later.

Validate JSON Schema in JavaScript, Python and Go

The same schema and the bad instance {"age": -1} in each language. Every snippet reports the missing email and the negative age with their paths.

JavaScript: Ajv with the 2020-12 build

import Ajv2020 from "ajv/dist/2020.js"; // npm i ajv ajv-formats
import addFormats from "ajv-formats";

const schema = {
  $schema: "https://json-schema.org/draft/2020-12/schema",
  type: "object",
  required: ["email"],
  properties: { email: { type: "string", format: "email" }, age: { type: "integer", minimum: 0 } },
};

const ajv = new Ajv2020({ allErrors: true });
addFormats(ajv); // format is only checked when you add this
const validate = ajv.compile(schema);
if (!validate({ age: -1 })) {
  for (const e of validate.errors) console.log(e.instancePath || "/", e.message);
}

Python: jsonschema

from jsonschema import validators  # pip install jsonschema

schema = {
    "$schema": "https://json-schema.org/draft/2020-12/schema",
    "type": "object",
    "required": ["email"],
    "properties": {"email": {"type": "string", "format": "email"},
                   "age": {"type": "integer", "minimum": 0}},
}

cls = validators.validator_for(schema)  # picks the draft from $schema
cls.check_schema(schema)
v = cls(schema, format_checker=cls.FORMAT_CHECKER)
for err in v.iter_errors({"age": -1}):
    print(err.json_path, err.message)

Go: github.com/santhosh-tekuri/jsonschema/v6

package main

import (
	"fmt"
	"strings"

	"github.com/santhosh-tekuri/jsonschema/v6" // go get github.com/santhosh-tekuri/jsonschema/v6
)

const schemaJSON = `{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "type": "object",
  "required": ["email"],
  "properties": {"age": {"type": "integer", "minimum": 0}}
}`

func main() {
	schemaDoc, _ := jsonschema.UnmarshalJSON(strings.NewReader(schemaJSON))
	c := jsonschema.NewCompiler()
	if err := c.AddResource("schema.json", schemaDoc); err != nil {
		panic(err)
	}
	sch, err := c.Compile("schema.json")
	if err != nil {
		panic(err)
	}
	inst, _ := jsonschema.UnmarshalJSON(strings.NewReader(`{"age": -1}`))
	fmt.Println(sch.Validate(inst)) // nil when valid, otherwise every error with its path
}

Each snippet was run on October 14, 2026 with Ajv 8.20.0 with ajv-formats 3.0.1, jsonschema 4.26.0 and santhosh-tekuri/jsonschema v6.0.3.

JSON Schema specs and test suite

• JSON Schema specification: current and past drafts
• Draft 2020-12: Core
• Draft 2020-12: Validation: type, enum, minimum, format and the other assertion keywords
• Draft 2019-09
• Draft 7
• Draft 6 release notes
• Draft 4 core
• Official JSON Schema Test Suite: the tests behind the pass rates on this page
• Bowtie: compliance reports for many validators
• @hyperjump/json-schema: the validator this page runs
• Ajv documentation
• python-jsonschema documentation
• santhosh-tekuri/jsonschema (Go)

FAQ