JSON Schema Validator

JSON Schema validation checks whether a JSON document follows rules written in a second JSON document, the schema: which keys must exist, what type each value has, which numbers or strings are allowed. Teams use it for API request and response contracts, configuration files, test assertions in CI, form payloads and OpenAPI components. Paste your data and schema above and every mismatch is listed with a readable path such as $.users[0].age. Your JSON and schema never leave your browser.

How do I validate JSON against a schema?

Paste your JSON data into the left box and your JSON Schema into the right box. Validation runs after you stop typing, or when you press Validate. A Valid result means the data matches the schema. Otherwise you get a list of errors, each with a readable path, the failing keyword and a plain-language message.

The draft is taken from the schema's $schema line. With none, Draft-07 is used and the result says so. The selector forces Draft-07, 2019-09 or 2020-12.

When developers validate JSON

Typical uses are checking a request or response against an API contract, catching configuration mistakes before a deploy, asserting in automated tests that a response keeps its shape, and screening form or webhook payloads before they reach business logic. If you do not have a schema yet, the JSON Schema Generator can draft one from a sample, and the JSON Formatter repairs data that fails to parse. To compare two payloads instead of checking one against rules, use Compare JSON.

How do I read the error paths?

Each error shows where the problem is in your data as a path starting at $, the root, such as $.users[0].age: the age of the first item in users. The keyword says which rule failed, for example type, required or minimum, and the parameters show the limit or the allowed values.

Hover a path, or tick Show raw pointers, to see the original JSON Pointer such as /users/0/age. Keys that are not simple names are quoted, like $["first name"]. Errors are sorted by path, and Jump to location selects the spot in your data. A required error points at the parent object, because a missing property has no position of its own.

Why does an external $ref not work?

This validator never fetches schemas from the network, so a $ref pointing to an http, https or file address cannot be resolved. That is deliberate: it keeps your schema and data private and results repeatable. Copy the referenced schema into your own under $defs and point to it with a local reference such as #/$defs/address.

A local reference that does not resolve, for example #/$defs/nope, gets a different message naming the reference, so you can tell a typo from a remote reference.

Why do I see schema warnings?

Ajv ignores keywords it does not know, so a typo such as requried would silently switch off a rule and every document would pass. The validator collects these cases in the collapsed Schema warnings list, for example unknown keyword "requried" is ignored. Check that list whenever a result is Valid but you expected errors.

Unknown format names, such as int64, are accepted without checking and listed there too.

Worked example: one schema, a passing document and a failing one

Every result below was copied from this validator, with the defaults.

Schema

{
  "type": "object",
  "properties": {
    "name": {
      "type": "string"
    },
    "age": {
      "type": "integer",
      "minimum": 0
    },
    "email": {
      "type": "string",
      "format": "email"
    }
  },
  "required": [
    "name",
    "email"
  ]
}

Passing document

{
  "name": "Ada",
  "age": 36,
  "email": "ada@example.com"
}

Result

✓ Valid - data matches the schema
Checked against Draft-07 with format checking on.
ℹ Notice: No $schema in the schema, so Draft-07 was used.

Failing document

{
  "name": "Bob",
  "age": -5,
  "email": "bob-at-example"
}

Error output (from Copy errors)

JSON Schema validation: 2 errors (Draft-07, format checking on)
1. $.age  [minimum]  must be >= 0  (comparison: >= · limit: 0)  pointer: /age
2. $.email  [format]  must match format "email"  (format: email)  pointer: /email

The age is below the minimum, and the email does not match the email format, so two errors are reported, each with its path.

How to use this validator

• Add data and schema by pasting each into its box, or click Load valid sample or Load invalid sample to see both outcomes.
• Pick a draft or leave Auto-detect on, which reads $schema and falls back to Draft-07.
• Keep Validate formats on to check values such as emails, URIs and dates; switch it off to ignore format entirely.
• Read the results: Valid, or a count of errors sorted by path. Use Jump to location on any row and Copy errors for a plain-text report.
• Format data or Format schema to re-indent either box.
• Large inputs: live validation pauses above about 1 MB, so press Validate. Anything slower than about 5 seconds is stopped with a clear message.

Can I generate a schema first, then validate with it?

Yes. The JSON Schema Generator drafts a schema from a sample and sends both documents here with one button. Treat the result as a starting point: the generator infers formats such as date-time or email from sample values, so review them. A date-time without a timezone offset, for example, passes the generator's guess but fails this validator's stricter format check. Our guide to JSON Schema explains the keywords, the Mock Data Generator can produce test records from a schema, and if an AI tool wrote your schema, see fixing AI-generated JSON.

Supported drafts and limitations

• Draft-07, 2019-09 and 2020-12 are supported. Draft-04 and Draft-06 are not, and a schema that declares them gets a clear message.
• External references are never fetched, for privacy. Inline them under $defs.
• Unknown keywords produce warnings and are ignored.
• Numbers are parsed as JavaScript numbers, so integers beyond 2^53 lose precision and 1.0 reads as 1.
• The list of known formats comes from ajv-formats.
• Jump to location works while the data is unchanged since the last validation.

Is my JSON uploaded anywhere?

No. Your JSON and schema never leave your browser, and nothing you paste is uploaded. Parsing and validation run in a background worker on your device, using a copy of the open-source Ajv library served from this site. The page uses Google Analytics only to count visits and button clicks, never your data.