jsonschema

jsonschema is a Rust crate for validating JSON documents against JSON Schema, supporting Draft 4, 6, 7, 2019-09, and 2020-12. It compiles a schema into a reusable Validator that can be run repeatedly against many instances, and also ships a #[jsonschema::validator] macro that generates a specialized validator at compile time for schemas known ahead of time, avoiding runtime compilation entirely for a further 3-13x speedup over the already-fast runtime path.

Beyond the core Rust API, the project is a monorepo of bindings and tools built on the same validation engine: a Python package (jsonschema-rs), a Ruby gem, a WebAssembly build with a hosted playground, and a standalone CLI crate. It supports custom keywords and format validators, blocking and non-blocking remote $ref resolution over network or file, and Structured Output v1 reports (flag/list/hierarchical), making it usable both as an embedded validation library and as a general-purpose schema-checking tool.

What You Get

• A Validator type built once from a schema (validator_for) and reused across many validate/is_valid/iter_errors calls
• A #[jsonschema::validator] macro (via the macros feature) that generates a specialized, compile-time validator from an inline or file-based schema
• Support for Draft 4, 6, 7, 2019-09, and 2020-12, with custom keyword and format validator hooks
• Blocking and non-blocking remote reference resolution over network or filesystem
• Structured Output v1 reports (flag/list/hierarchical) via the evaluate/iter_annotations API
• Official Python, Ruby, and WebAssembly bindings plus a standalone jsonschema-cli crate, all built on the same core crate

Common Use Cases

• Validating configuration files (e.g. Tauri or Apollo Router-style config validation) against a JSON Schema at startup
• Validating API request/response payloads in a Rust web service before further processing
• Using the compile-time #[jsonschema::validator] macro to eliminate runtime schema-compilation overhead in hot paths
• Validating CSV or tabular records against a schema with custom keyword validators (as used by the qsv CLI)
• Running ad-hoc schema validation from the command line via the jsonschema-cli crate without writing any Rust code

Under The Hood

Architecture - The workspace (Cargo.toml, members = ["crates/*"]) splits the core validation engine (crates/jsonschema) from jsonschema-referencing (reference resolution), jsonschema-regex, the proc-macro implementation (jsonschema-macros/jsonschema-macros-core), and per-language bindings (jsonschema-py, jsonschema-rb, jsonschema-wasm) plus jsonschema-cli. Each binding crate wraps the same core Validator rather than reimplementing validation logic, so drafts and keywords stay consistent across languages.

Tech Stack - Pure Rust (88.7% of the codebase) on top of serde/serde_json, with ahash for hashing; the crate’s default TLS provider is aws-lc-rs with an opt-in tls-ring feature for remote $ref fetching. MSRV is pinned at Rust 1.85.0, and workspace-wide Clippy pedantic lints are enabled with unsafe_code and unreachable_pub set to warn.

Code Quality - A dedicated jsonschema-testsuite crate plus jsonschema-testsuite-codegen generates tests from the official JSON Schema test suite, and a companion benchmark-suite crate tracks performance against valico, jsonschema_valid, and boon. Codecov is wired into CI, and the project publishes live spec-compliance results per draft via the Bowtie report.

API Design - The primary API is deliberately small: is_valid/validate for one-off checks, validator_for to build a reusable Validator, and iter_errors/evaluate for detailed or structured-output reporting. The optional #[jsonschema::validator] macro lets a schema known at compile time skip runtime compilation entirely while keeping the same is_valid/validate call shape, which the maintainers acknowledge was directly inspired by the Python jsonschema package’s API.