JSON Schema Validator

Was ist JSON Schema Validierung?

JSON Schema Validierung ist der Prozess der Überprüfung, ob ein JSON-Dokument einer Menge struktureller und inhaltlicher Einschränkungen entspricht, die in einem JSON Schema definiert sind. Das Schema selbst ist ein JSON-Dokument, das die erwartete Form Ihrer Daten beschreibt: welche Eigenschaften erforderlich sind, welche Typen sie haben müssen, die erlaubten Wertebereiche für Zahlen, String-Muster, Array-Längen und mehr. Die JSON Schema Spezifikation wird auf json-schema.org gepflegt und als Serie von IETF-Drafts veröffentlicht — Draft 7 und Draft 2020-12 sind die am weitesten verbreiteten.

Während eine einfache JSON-Validierung nur die Syntax prüft (sind die Klammern korrekt gesetzt? sind Strings in Anführungszeichen?), geht die Schema-Validierung weiter. Sie beantwortet Fragen wie: Enthält die Antwort dieser API ein "id"-Feld, das immer eine Ganzzahl ist? Ist das "status"-Feld einer von drei erlaubten Werten? Sind verschachtelte Objekte korrekt geformt? Diese Art der strukturellen Überprüfung findet Fehler, die Syntaxprüfungen vollständig übersehen — denn syntaktisch gültiges JSON kann für Ihre Anwendung semantisch trotzdem falsch sein.

JSON Schema wird in OpenAPI/Swagger-Definitionen, bei der Validierung von Konfigurationsdateien, bei der Formularvalidierung, in Datenbankdokument-Constraints und im automatisierten Testen eingesetzt. Tools wie Ajv (JavaScript), jsonschema (Python) und check-jsonschema (CLI) implementieren die Spezifikation, damit Sie Daten programmatisch validieren können. Dieser Online-Validator ermöglicht es Ihnen, Schema und Datendokument einzufügen und die Konformität sofort zu prüfen — ohne eine Bibliothek installieren zu müssen.

Warum einen Online JSON Schema Validator verwenden?

Schemas schreiben und Validierungsfehler manuell debuggen ist zeitaufwendig. Ein Online JSON Schema Validator gibt Ihnen sofortiges Feedback, ob Ihre Daten mit Ihrem Schema übereinstimmen — mit klaren Fehlermeldungen, die auf die genaue Eigenschaft zeigen, die fehlgeschlagen ist.

Anwendungsfälle für JSON Schema Validierung

JSON Schema Schlüsselwörter — Referenz

Ein JSON Schema wird aus Schlüsselwörtern aufgebaut, die jeweils eine Einschränkung für die zu validierenden Daten auferlegen. Die nachstehende Tabelle listet die am häufigsten verwendeten Schlüsselwörter in Draft 7 und späteren Versionen auf. Jedes Schlüsselwort kann mit anderen im selben Schema-Objekt kombiniert werden.

JSON Schema Draft-Vergleich: Draft 7 vs. 2019-09 vs. 2020-12

JSON Schema hat mehrere Draft-Versionen durchlaufen. Draft 7 (veröffentlicht 2018) ist in Tooling am weitesten verbreitet. Draft 2019-09 führte $defs (als Ersatz für definitions), unevaluatedProperties und $recursiveRef ein. Draft 2020-12 (die aktuelle stabile Version) ersetzte $recursiveRef durch $dynamicRef und führte prefixItems für Tupel-Validierung ein. Prüfen Sie bei der Wahl eines Drafts, ob Ihre Validierungsbibliothek ihn unterstützt. Ajv unterstützt alle drei Drafts. Die Python-Bibliothek jsonschema unterstützt Draft 2020-12 seit Version 4.0.

Code-Beispiele

Diese Beispiele zeigen, wie JSON programmatisch gegen ein Schema validiert wird. Jedes verwendet eine gut gepflegte Bibliothek für sein Sprach-Ökosystem.

import Ajv from 'ajv';

const ajv = new Ajv();

const schema = {
  type: 'object',
  properties: {
    name: { type: 'string', minLength: 1 },
    age: { type: 'integer', minimum: 0 },
    email: { type: 'string', format: 'email' }
  },
  required: ['name', 'email'],
  additionalProperties: false
};

const data = { name: 'Alice', age: 30, email: 'alice@example.com' };

const validate = ajv.compile(schema);
const valid = validate(data);
console.log(valid);          // → true
console.log(validate.errors); // → null

// Invalid data — missing required "email"
validate({ name: 'Bob', age: 25 });
console.log(validate.errors);
// → [{ instancePath: '', keyword: 'required', params: { missingProperty: 'email' } }]

from jsonschema import validate, ValidationError

schema = {
    "type": "object",
    "properties": {
        "name": {"type": "string", "minLength": 1},
        "age": {"type": "integer", "minimum": 0},
        "tags": {
            "type": "array",
            "items": {"type": "string"},
            "uniqueItems": True
        }
    },
    "required": ["name"]
}

# Valid data
validate(instance={"name": "Alice", "age": 30, "tags": ["admin"]}, schema=schema)
# → No exception raised

# Invalid data — wrong type for "age"
try:
    validate(instance={"name": "Alice", "age": "thirty"}, schema=schema)
except ValidationError as e:
    print(e.message)
    # → 'thirty' is not of type 'integer'
    print(e.json_path)
    # → $.age

package main

import (
    "fmt"
    "strings"
    "github.com/santhosh-tekuri/jsonschema/v5"
)

func main() {
    schemaJSON := `{
        "type": "object",
        "properties": {
            "id": { "type": "integer" },
            "status": { "enum": ["active", "inactive"] }
        },
        "required": ["id", "status"]
    }`

    compiler := jsonschema.NewCompiler()
    compiler.AddResource("schema.json", strings.NewReader(schemaJSON))
    schema, _ := compiler.Compile("schema.json")

    // Valid data
    data := map[string]interface{}{"id": 1, "status": "active"}
    err := schema.Validate(data)
    fmt.Println(err) // → <nil>

    // Invalid — missing "status"
    bad := map[string]interface{}{"id": 2}
    err = schema.Validate(bad)
    fmt.Println(err) // → validation failed: missing properties: 'status'
}

# Install via pip
pip install check-jsonschema

# Validate a file against a schema
check-jsonschema --schemafile schema.json data.json
# → ok -- validation done

# Validate against a remote schema (e.g., GitHub Actions workflow)
check-jsonschema --builtin-schema vendor.github-workflows my-workflow.yml

# Validate multiple files at once
check-jsonschema --schemafile schema.json file1.json file2.json file3.json

Häufig gestellte Fragen