name: json-schema-validator
description: Validate JSON data against JSON Schema specifications. Use for API validation, config file validation, or data quality checks.

JSON Schema Validator

Validate JSON documents against JSON Schema (Draft 7) specifications.

Features

• Schema Validation: Validate JSON against schema
• Error Details: Detailed validation error messages
• Batch Validation: Validate multiple files
• Schema Generation: Generate schema from examples
• Multiple Drafts: Support for Draft 4, 6, 7

Quick Start

from json_validator import JSONValidator

validator = JSONValidator()

# Validate data against schema
schema = {
    "type": "object",
    "properties": {
        "name": {"type": "string"},
        "age": {"type": "integer", "minimum": 0}
    },
    "required": ["name"]
}

data = {"name": "John", "age": 30}
result = validator.validate(data, schema)
print(f"Valid: {result['valid']}")

CLI Usage

# Validate JSON file against schema
python json_validator.py --data user.json --schema user_schema.json

# Validate with inline schema
python json_validator.py --data config.json --schema '{"type": "object"}'

# Generate schema from sample
python json_validator.py --generate sample.json --output schema.json

# Batch validate directory
python json_validator.py --data-dir ./configs/ --schema config_schema.json

API Reference

JSONValidator Class

class JSONValidator:
    def __init__(self, draft: str = "draft7")

    # Validation
    def validate(self, data: dict, schema: dict) -> dict
    def validate_file(self, data_path: str, schema_path: str) -> dict
    def validate_batch(self, data_files: list, schema: dict) -> list

    # Schema operations
    def generate_schema(self, data: dict) -> dict
    def check_schema(self, schema: dict) -> dict

Validation Result

{
    "valid": True,  # or False
    "errors": [],   # List of error details
    "path": "$",    # JSON path to data root
}

# With errors:
{
    "valid": False,
    "errors": [
        {
            "message": "'name' is a required property",
            "path": "$",
            "schema_path": "required"
        },
        {
            "message": "-5 is less than minimum 0",
            "path": "$.age",
            "schema_path": "properties.age.minimum"
        }
    ]
}

Schema Examples

Object Schema

schema = {
    "type": "object",
    "properties": {
        "id": {"type": "integer"},
        "name": {"type": "string", "minLength": 1},
        "email": {"type": "string", "format": "email"},
        "active": {"type": "boolean", "default": True}
    },
    "required": ["id", "name", "email"],
    "additionalProperties": False
}

Array Schema

schema = {
    "type": "array",
    "items": {
        "type": "object",
        "properties": {
            "id": {"type": "integer"},
            "value": {"type": "number"}
        }
    },
    "minItems": 1,
    "uniqueItems": True
}

Nested Schema

schema = {
    "type": "object",
    "properties": {
        "user": {
            "type": "object",
            "properties": {
                "name": {"type": "string"},
                "address": {
                    "type": "object",
                    "properties": {
                        "street": {"type": "string"},
                        "city": {"type": "string"}
                    }
                }
            }
        }
    }
}

Generate Schema from Data

validator = JSONValidator()

sample_data = {
    "name": "Product A",
    "price": 29.99,
    "tags": ["electronics", "sale"],
    "inStock": True
}

schema = validator.generate_schema(sample_data)
# Returns inferred schema based on data types

Supported Keywords

Type Validation

• type: string, number, integer, boolean, array, object, null
• enum: allowed values
• const: exact value

String Validation

• minLength, maxLength
• pattern: regex pattern
• format: email, uri, date, date-time, ipv4, ipv6, uuid

Number Validation

• minimum, maximum
• exclusiveMinimum, exclusiveMaximum
• multipleOf

Array Validation

• items: schema for items
• minItems, maxItems
• uniqueItems
• contains

Object Validation

• properties: property schemas
• required: required properties
• additionalProperties
• minProperties, maxProperties
• patternProperties

Error Handling

result = validator.validate(data, schema)

if not result['valid']:
    for error in result['errors']:
        print(f"Error at {error['path']}: {error['message']}")

Dependencies

• jsonschema>=4.20.0