Validate JSON Schema Online: Test Your Schema Against Real Data

Q: How do I test a JSON Schema against real data?

Use an online JSON Schema validator: paste your schema in the schema panel and your sample JSON data in the data panel, then click validate. The validator reports whether the data passes and lists every rule that failed with the path to the offending value. To test thoroughly, check both valid data (confirm it passes) and invalid data (confirm it correctly rejects bad values). Jsonic's JSON Schema Validator runs entirely in your browser — no uploads. For automated testing, use Ajv in JavaScript or the jsonschema library in Python and write test cases that assert validation results.

Q: What online tools validate JSON Schema?

Jsonic's JSON Schema Validator validates JSON data against a schema with instant feedback in the browser. It supports JSON Schema draft-07 and shows each validation error with the path and rule that failed. Other online options include jsonschemavalidator.net and the JSON Schema website's online validator. For integrated development workflows, most API platforms like Postman and Insomnia include built-in JSON Schema validation for request and response contracts. VS Code also provides JSON Schema validation for files when a schema is configured in settings or declared with the "$schema" key.

Q: What JSON Schema errors are most common?

The most common JSON Schema validation errors are: missing required properties (a key listed in "required" is absent from the data), type mismatch (a string where a number is expected, or vice versa), enum violation (a value not in the allowed list), minimum/maximum violation (a number outside the allowed range), format error (an email address that is not a valid email format), pattern mismatch (a string that does not match the regex), additional property rejected (an extra key when "additionalProperties" is false), and minLength/maxLength violation (a string that is too short or too long). Validators report all of these with the property path to help locate the issue quickly.

Q: How do I fix a "required" validation error?

A "required" validation error means a property that is listed in the schema's "required" array is missing from the data. To fix it: add the missing property to your data with an appropriate value. For example, if the error says "must have required property 'email'" and your data is {"name": "Alice"}, add the email field: {"name": "Alice", "email": "alice@example.com"}. If the field should be optional, remove its name from the "required" array in the schema. If null should count as present, note that "required" only checks key existence — a null value will satisfy "required" but may fail a type check.

Q: What is the difference between Draft-04, Draft-07, and Draft-2020-12?

Draft-04 (2013) is the oldest widely supported version, establishing core keywords like "type", "properties", "required", "enum", "allOf", "anyOf", "oneOf". Draft-07 (2018) added "if/then/else" conditional validation, "$comment", "readOnly", "writeOnly", "contentMediaType", and changed how "exclusiveMinimum"/"exclusiveMaximum" work (from boolean to number). Draft 2020-12 (current stable) renamed "$defs" from "definitions", changed tuple validation to use "prefixItems" instead of an array in "items", and added "unevaluatedProperties" and "unevaluatedItems". Draft-07 remains the most widely supported in validator libraries.

Q: How do I validate a JSON Schema itself?

JSON Schema publishes meta-schemas — schemas that describe what a valid JSON Schema looks like. To validate your schema, run it through a validator using the appropriate meta-schema for your draft. In Ajv: ajv.validateSchema(yourSchema) returns true if the schema is structurally valid. Most validators also report errors when they encounter an invalid schema keyword or incorrect keyword value. VS Code validates JSON Schema files automatically when the file is associated with the meta-schema (set "$schema" to the meta-schema URL). You can also use online validators like Jsonic's JSON Schema Validator and paste your schema as the data against the meta-schema.

Last updated: May 11, 2026

A JSON Schema validator checks whether a JSON value matches a schema definition — verifying types, required fields, value ranges, string formats (email, uri, date-time), and array constraints. Paste your JSON and schema into Jsonic's JSON Schema Validator for an instant result — it uses Ajv 8, which supports JSON Schema Draft-07 and Draft 2020-12. Validation errors include the exact JSON Pointer path (/user/email) and a human-readable message for each violation. This guide covers writing schemas for common cases: required fields, optional fields with defaults, nested objects, enum values, and pattern-matched strings.

Paste your schema and data into Jsonic's JSON Schema Validator to see validation errors immediately.

Validate JSON Schema now

What JSON Schema validation checks

A JSON Schema validator checks a JSON value against a schema and reports each rule that fails. The most common checks are:

type — is the value the right type (string, number, boolean, array, object, null)?
required — are all required keys present?
properties — do object properties match their individual schemas?
enum — is the value one of the allowed values?
minimum / maximum — is a number within the allowed range?
minLength / maxLength — is a string within the allowed length?
pattern — does a string match the regex pattern?
format — does a string match a named format like email or date?
additionalProperties — are unexpected keys allowed?

Minimal schema: type and required fields

// Schema
{
  "type": "object",
  "required": ["id", "name"],
  "properties": {
    "id":   { "type": "integer" },
    "name": { "type": "string" }
  }
}

// ✅ Valid data
{ "id": 1, "name": "Alice" }

// ❌ Fails: name is missing
{ "id": 1 }

// ❌ Fails: id is a string, not integer
{ "id": "1", "name": "Alice" }

Enum: restrict to allowed values

{
  "type": "object",
  "properties": {
    "status": {
      "type": "string",
      "enum": ["active", "inactive", "pending"]
    }
  }
}

// ✅ Valid
{ "status": "active" }

// ❌ Fails: "banned" is not in the enum
{ "status": "banned" }

For more enum patterns, see the JSON Schema examples guide.

Nested object validation

{
  "type": "object",
  "required": ["user"],
  "properties": {
    "user": {
      "type": "object",
      "required": ["id", "email"],
      "properties": {
        "id":    { "type": "integer" },
        "email": { "type": "string", "format": "email" }
      }
    }
  }
}

// ✅ Valid
{ "user": { "id": 1, "email": "alice@example.com" } }

// ❌ Fails: email format invalid
{ "user": { "id": 1, "email": "not-an-email" } }

Array of objects

{
  "type": "array",
  "items": {
    "type": "object",
    "required": ["id", "name"],
    "properties": {
      "id":   { "type": "integer" },
      "name": { "type": "string" }
    }
  },
  "minItems": 1
}

// ✅ Valid
[{ "id": 1, "name": "Alice" }, { "id": 2, "name": "Bob" }]

// ❌ Fails: empty array violates minItems
[]

Block unexpected keys with additionalProperties

{
  "type": "object",
  "properties": {
    "name": { "type": "string" }
  },
  "additionalProperties": false
}

// ✅ Valid
{ "name": "Alice" }

// ❌ Fails: unknown is not in properties
{ "name": "Alice", "unknown": true }

This is useful for strict API contracts where unexpected fields should be rejected rather than silently ignored.

Using $ref to reuse schemas

{
  "$defs": {
    "Address": {
      "type": "object",
      "required": ["city", "country"],
      "properties": {
        "city":    { "type": "string" },
        "country": { "type": "string" }
      }
    }
  },
  "type": "object",
  "properties": {
    "billing":  { "$ref": "#/$defs/Address" },
    "shipping": { "$ref": "#/$defs/Address" }
  }
}

$ref lets you define a schema once and reuse it multiple times, keeping large schemas maintainable. See the JSON Schema tutorial for a full walkthrough.

How to validate a schema online

Open the JSON Schema Validator.
Paste your schema in the Schema panel.
Paste a sample JSON value in the Data panel.
The validator reports whether the data passes and lists every failed rule with the path.

Testing with both valid and invalid data is important: confirm that the schema accepts what it should and rejects what it should.

Test your schema now

Paste a schema and a JSON value into Jsonic's JSON Schema Validator. Errors show the exact path and rule that failed.

Open JSON Schema Validator

Frequently asked questions

How do I test a JSON Schema against real data?

Paste your schema and sample data into an online JSON Schema validator. Test both valid data (confirm it passes) and invalid data (confirm it rejects bad values). Jsonic's JSON Schema Validator runs entirely in your browser with instant feedback.

What online tools validate JSON Schema?

Jsonic's JSON Schema Validator provides instant validation with error paths. Other options include jsonschemavalidator.net and the official JSON Schema website validator. VS Code also validates schemas inline when $schema is declared in the file.

What JSON Schema errors are most common?

Most common errors: missing required properties, type mismatch (string vs number), enum violation, minimum/maximum out of range, format error (invalid email), pattern mismatch, additional property rejected, and minLength/maxLength violation.

How do I fix a "required" validation error?

Add the missing property to your data. If the error says must have required property 'email', add "email" to the object. If the field should be optional, remove it from the required array in the schema.

What is the difference between Draft-04, Draft-07, and Draft-2020-12?

Draft-04 established core keywords. Draft-07 added if/then/else and changed exclusiveMinimum/Maximum to numeric values. Draft 2020-12 renamed definitions to $defs, moved tuple validation to prefixItems, and added unevaluatedProperties.

How do I validate a JSON Schema itself?

Use a validator against the appropriate meta-schema for your draft. In Ajv: ajv.validateSchema(yourSchema). VS Code validates schemas automatically when $schema points to the meta-schema URL.