JSON Schema Validator

Was ist ein 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

Hauptfunktionen

Beispiele

{
  "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"]
  }
}

Anleitung

1. 1

   JSON Schema einfügen

   Schema in das rechte Panel einfügen. Der Validator erkennt den Draft automatisch über die $schema-URI, sofern vorhanden; andernfalls Draft 2020-12, 2019-09 oder Draft-07 in der Toolbar wählen.

2. 2

   JSON-Daten einfügen

   Das zu prüfende JSON-Dokument in das linke Panel einfügen. Die Validierung läuft während der Eingabe; bei großen Eingaben (>200 KB) wird auf einen manuellen Validate-Button umgeschaltet, damit das Tippen flüssig bleibt.

3. 3

   Fehlerliste lesen

   Jeder Fehler hat einen JSON Pointer-Pfad, ein Keyword und eine einzeilige Nachricht. Auf einen Fehler klicken, um zur Stelle in den Daten zu springen, korrigieren und die Anzahl in Echtzeit sinken sehen.

Häufige JSON Schema-Fallstricke

{ "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

Anwendungsfälle

API-Request-Validierung

Einen Request-Body und das Schema Ihres Endpunkts vor dem Deploy einfügen. Fangen Sie 400-Antworten ab, die Ihre Tests nicht abdeckten — fehlende required-Felder, falsche Typen, Zahlen außerhalb des Bereichs.

Webhook-Payload-Verifizierung

Hat der Anbieter eine Payload geschickt, die Ihr Handler ablehnt? Validieren Sie die tatsächliche Payload gegen Ihr Schema, dann gegen das veröffentlichte Schema des Anbieters. Die Differenz zwischen beiden ist Ihr Bug.

Konfigurationsdatei-Linting

package.json, tsconfig.json, helm values.yaml — jede Konfigurationsdatei hat ein öffentliches Schema. Schema einfügen, Konfiguration einfügen, Tippfehler finden. Ohne Trial-and-Error.

OpenAPI-Komponententest

Eine Schema-Komponente aus einem OpenAPI 3.1-Dokument extrahieren, hier einfügen, Beispiel-Payloads validieren. Schneller als ein Mock-Server, deterministisch, kein SDK nötig.

Formular-Submission-Preflight

Eine Beispiel-Formular-Payload einfügen, bevor Sie die Frontend-Validierung verdrahten. Bestätigen, dass das Schema ablehnt, was Sie erwarten, und akzeptiert, was Sie erwarten — und dann dasselbe Schema an Client und Server ausliefern.

Datenpipeline-Vertragsprüfung

Ist die ETL-Ausgabe gedriftet? Eine Beispielzeile und das nachgelagerte Schema einfügen. Ermitteln Sie, welcher Producer sich geändert hat und welche Schlüssel kaputt sind, bevor die Pipeline 10.000 Datensätze erneut versucht.

Technische Details

Draft 2020-12-konform

Implementiert die veröffentlichte Draft 2020-12-Spezifikation — Keywords, Typsystem, format-Vokabular. Querverglichen mit Ajv 8.x und ajv-formats-Ausgabe.

JSON Pointer-Fehlerpfade

Fehler verwenden RFC 6901 JSON Pointer (/user/email/0). Jeder Keyword-Fehler verweist auf eine einzige auflösbare Stelle in den Daten — keine Mehrdeutigkeit, keine String-Suche.

Interne $ref-Auflösung

Löst $ref-Pointer innerhalb eines einzelnen Dokuments auf (#/$defs/foo, #/properties/bar). Zyklen werden erkannt und gemeldet. Externe HTTP-$refs aus Datenschutzgründen deaktiviert.

Best Practices

Immer additionalProperties: false setzen

Bei Eingabeverträgen (Request-Bodies, Konfigurationsdateien, Queue-Nachrichten) sind unbekannte Schlüssel meist Bugs — Tippfehler, versehentliche Felder oder Angreifer-Sondierung. Standardmäßig ablehnen.

$defs für wiederverwendbare Subschemata nutzen

Dieselbe Form zweimal inline und sie driften auseinander. Geteilte Definitionen in $defs verschieben und mit $ref referenzieren — eine einzige Wahrheitsquelle, jede Änderung wirkt überall.

Vor der Geschäftslogik validieren

Schema-Validierung direkt nach JSON.parse ausführen, bevor die geparste Struktur angefasst wird. Type-Narrowing, Defaults und Persistenz setzen alle voraus, dass der Vertrag hält — stellen Sie das sicher.

Häufig gestellte Fragen