JSON Schema Validator

What is a JSON Schema Validator?

// A 5-line schema that catches three real bugs
const schema = {
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "type": "object",
  "properties": {
    "id":    { "type": "integer", "minimum": 1 },
    "email": { "type": "string", "format": "email" },
    "age":   { "type": "integer", "minimum": 0, "maximum": 150 }
  },
  "required": ["id", "email"],
  "additionalProperties": false
};

// Three bugs the schema catches:
const bad = { "id": "42", "age": 200 };
//   /id   → type: expected integer, got string
//   /email → required: missing
//   /age   → maximum: 200 > 150

// In Node:        new Ajv().compile(schema)(bad)  // false; ajv.errors has the paths
// In Python:      jsonschema.validate(bad, schema)
// In the browser: this tool — same errors, same paths, no install

Key Features

Examples

{
  "id": 42,
  "email": "alice@example.com",
  "age": 30
}

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

{
  "id": "42",
  "age": 200
}

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

{
  "type": "order.created",
  "data": { "orderId": "ORD-001234", "totalUsd": 49.99 }
}

{
  "oneOf": [
    {
      "properties": {
        "type": { "const": "order.created" },
        "data": {
          "type": "object",
          "properties": {
            "orderId": { "type": "string", "pattern": "^ORD-[0-9]{6}$" },
            "totalUsd": { "type": "number", "minimum": 0 }
          },
          "required": ["orderId", "totalUsd"]
        }
      },
      "required": ["type", "data"]
    },
    {
      "properties": {
        "type": { "const": "order.refunded" },
        "data": { "type": "object", "required": ["refundId"] }
      },
      "required": ["type", "data"]
    }
  ]
}

[
  { "sku": "A1", "qty": 3 },
  { "sku": "B2", "qty": 5 },
  { "sku": "A1", "qty": 3 }
]

{
  "type": "array",
  "minItems": 1,
  "uniqueItems": true,
  "items": {
    "type": "object",
    "properties": {
      "sku": { "type": "string", "pattern": "^[A-Z][0-9]+$" },
      "qty": { "type": "integer", "minimum": 1 }
    },
    "required": ["sku", "qty"]
  }
}

How to Use

1. 1

   Paste your JSON Schema

   Drop your schema into the right panel. The validator auto-detects the draft from the $schema URI if present; otherwise pick Draft 2020-12, 2019-09, or Draft-07 from the toolbar.

2. 2

   Paste your JSON data

   Drop the JSON document you want to check into the left panel. Validation runs as you type; large inputs (>200 KB) switch to a manual Validate button to keep typing snappy.

3. 3

   Read the error list

   Each error has a JSON Pointer path, a keyword, and a one-line message. Click an error to jump to the location in your data, fix it, and watch the count drop in real time.

Common JSON Schema Pitfalls

{ "qty": 1.0 }   schema: { "type": "integer" }   → error: not an integer

{ "qty": 1 }     schema: { "type": "integer" }   → valid

{ "properties": { "name": { "type": "string", "required": true } } }

{ "properties": { "name": { "type": "string" } }, "required": ["name"] }

{ "properties": { "id": { "type": "integer" } } }   accepts: { "id": 1, "foo": "bar", "x": null }

{ "properties": { "id": { "type": "integer" } }, "additionalProperties": false }

{ "type": "string", "nullable": true }   in 2020-12: nullable is just an unknown keyword

{ "type": ["string", "null"] }   in 2020-12: explicitly allows null

pattern: "[A-Z]+"   accepts: "helloX"   (because X matches)

pattern: "^[A-Z]+$"   accepts only: "HELLO"

oneOf: [ { type: "string" }, { type: "string", maxLength: 10 } ]   on: "hi"   → error: matches both

anyOf: [ { type: "string" }, { type: "string", maxLength: 10 } ]   on: "hi"   → valid

Common Use Cases

API Request Validation

Paste a request body and your endpoint's schema before deploying. Catch 400 responses your tests didn't cover — missing required fields, wrong types, out-of-range numbers.

Webhook Payload Verification

Vendor sent a payload your handler rejects? Validate the actual payload against your schema, then against the vendor's published schema. The diff between the two is your bug.

Config File Linting

package.json, tsconfig.json, helm values.yaml — every config file has a public schema. Paste the schema, paste the config, find the typo. Skip the trial-and-error.

OpenAPI Component Testing

Lift a schema component from an OpenAPI 3.1 document, paste it here, validate sample payloads. Faster than spinning up a mock server, deterministic, no SDK needed.

Form-Submission Pre-Flight

Paste a sample form payload before wiring frontend validation. Confirm the schema rejects what you expect, accepts what you expect, then ship the same schema to client and server.

Data-Pipeline Contract Check

ETL output drifted? Paste a sample row and the downstream schema. Pinpoint which producer changed and which keys broke before the pipeline retries 10,000 records.

Technical Details

Draft 2020-12 Compliant

Implements the published Draft 2020-12 spec — keywords, type system, format vocabulary. Cross-checked against Ajv 8.x and ajv-formats output.

JSON Pointer Error Paths

Errors use RFC 6901 JSON Pointer (/user/email/0). Every keyword failure points to a single resolvable location in the data — no ambiguity, no string-search.

Internal $ref Resolution

Resolves $ref pointers within a single document (#/$defs/foo, #/properties/bar). Cycles detected and reported. External HTTP $refs disabled for privacy.

Best Practices

Always Set additionalProperties: false

On input contracts (request bodies, config files, queue messages), unknown keys are usually bugs — typos, accidental fields, or attacker probing. Reject them by default.

Use $defs for Reusable Subschemas

Inline the same shape twice and they drift. Move shared definitions to $defs and reference with $ref — one source of truth, every change applies everywhere.

Validate Before Business Logic

Run schema validation right after JSON.parse, before touching the parsed structure. Type narrowing, defaulting, and persistence all assume the contract holds — make sure it does.

Frequently Asked Questions