Skip to main content

jsonschema-rs

Build Version Python versions License Supported Dialects

A high-performance JSON Schema validator for Python.

import jsonschema_rs

schema = {"maxLength": 5}
instance = "foo"

# One-off validation
try:
    jsonschema_rs.validate(schema, "incorrect")
except jsonschema_rs.ValidationError as exc:
    assert str(exc) == '''"incorrect" is longer than 5 characters

Failed validating "maxLength" in schema

On instance:
    "incorrect"'''

# Build & reuse (faster)
validator = jsonschema_rs.validator_for(schema)

# Iterate over errors
for error in validator.iter_errors(instance):
    print(f"Error: {error}")
    print(f"Location: {error.instance_path}")

# Boolean result
assert validator.is_valid(instance)

# Structured output (JSON Schema Output v1)
evaluation = validator.evaluate(instance)
for error in evaluation.errors():
    print(f"Error at {error['instanceLocation']}: {error['error']}")

⚠️ Upgrading from older versions? See the Migration Guide for breaking changes.

Migrating from jsonschema? See the jsonschema migration guide.

Highlights

  • 📚 Drafts 4, 6, 7, 2019-09 and 2020-12
  • 🔧 Custom keywords and format validators
  • ⚡ Compile-time validators for your own extension modules, via the Rust crate
  • 🌐 $ref resolution over HTTP and from files
  • 📦 Schema bundling into Compound Schema Documents, and $ref dereferencing
  • 🎨 Structured Output v1 reports (flag/list/hierarchical)
  • ✨ Meta-schema validation for schema documents, including custom metaschemas
  • 🧮 Experimental schema canonicalization

Supported drafts

  • Draft 2020-12
  • Draft 2019-09
  • Draft 7
  • Draft 6
  • Draft 4

Per-draft compliance results are on the Bowtie Report.

Playground

Try schemas in the browser with the WebAssembly playground.

Installation

pip install jsonschema-rs

Usage

Pass a schema as a JSON string to skip parsing it in Python:

import jsonschema_rs

validator = jsonschema_rs.validator_for('{"minimum": 42}')
...

validator_for detects the draft from $schema. To pick one yourself, use a draft-specific class:

import jsonschema_rs

# Automatic draft detection
validator = jsonschema_rs.validator_for({"minimum": 42})

# Draft-specific validators
validator = jsonschema_rs.Draft4Validator({"minimum": 42})
validator = jsonschema_rs.Draft6Validator({"minimum": 42})
validator = jsonschema_rs.Draft7Validator({"minimum": 42})
validator = jsonschema_rs.Draft201909Validator({"minimum": 42})
validator = jsonschema_rs.Draft202012Validator({"minimum": 42})

With a chosen draft (a draft-specific class or draft=), the $schema URI is not retrieved: pass a custom meta-schema in registry= so its $vocabulary applies.

jsonschema-rs ships validators for the standard format values. To add your own, pass a function that takes a str and returns a bool via formats. Drafts 2019-09 and 2020-12 treat format as an annotation, so set validate_formats=True to get it checked:

import jsonschema_rs

def is_currency(value):
    # The input value is always a string
    return len(value) == 3 and value.isascii()


validator = jsonschema_rs.validator_for(
    {"type": "string", "format": "currency"}, 
    formats={"currency": is_currency},
    validate_formats=True  # Important for Draft 2019-09 and 2020-12
)
validator.is_valid("USD")  # True
validator.is_valid("invalid")  # False

To check numbers, wrap the function in number_format; it receives an int, float or Decimal:

is_int32 = jsonschema_rs.number_format(lambda number: -(2**31) <= number < 2**31)
validator = jsonschema_rs.validator_for(
    {"format": "int32"}, formats={"int32": is_int32}, validate_formats=True
)
assert not validator.is_valid(2**31)

Validating JSON Text

When instances arrive as JSON text, such as request bodies or queue messages, JsonTextValidator validates the str or bytes directly, without building Python objects for them. On the benchmark documents this is 2.5-9.9x faster than json.loads followed by is_valid, and 1.3-2.3x faster than orjson.loads followed by is_valid. It takes the same arguments as validator_for, plus draft:

import jsonschema_rs

validator = jsonschema_rs.JsonTextValidator({"type": "object", "required": ["id"]})
validator.is_valid('{"id": 1}')  # True
validator.is_valid(b'{"name": "x"}')  # False

Text that is not a single JSON document raises ValueError, and a repeated key keeps its last value, as with json.loads. Unlike json.loads, it also raises for NaN and Infinity, which are not JSON, and for documents nested 128 levels deep or more. Custom keywords receive the instance as Python objects.

Custom Keywords

A custom keyword is a class. The validator builds one instance per occurrence of the keyword, passing the parent schema, the keyword value and its schema path. Its validate method rejects a value by raising any exception, whose message becomes the error message:

import jsonschema_rs

class DivisibleBy:
    def __init__(self, parent_schema, value, schema_path):
        self.divisor = value

    def validate(self, instance):
        if isinstance(instance, int) and instance % self.divisor != 0:
            raise ValueError(f"{instance} is not divisible by {self.divisor}")


validator = jsonschema_rs.validator_for(
    {"type": "integer", "divisibleBy": 3},
    keywords={"divisibleBy": DivisibleBy},
)
validator.is_valid(9)   # True
validator.is_valid(10)  # False

The resulting ValidationError keeps that exception as __cause__:

try:
    validator.validate(10)
except jsonschema_rs.ValidationError as e:
    print(type(e.__cause__))   # <class 'ValueError'>
    print(e.__cause__)         # original message

Other options:

  • validate_formats: check format regardless of the draft default.
  • ignore_unknown_formats: set to False to raise on a format value with no validator.
  • base_uri: base URI for relative $refs in the schema.
  • vocabularies: vocabularies your custom keywords implement.
import jsonschema_rs

validator = jsonschema_rs.Draft202012Validator(
    {"type": "string", "format": "date"},
    validate_formats=True,
    ignore_unknown_formats=False
)

# This will validate the "date" format
validator.is_valid("2023-05-17")  # True
validator.is_valid("not a date")  # False

# With ignore_unknown_formats=False, an unknown format raises an error
invalid_schema = {"type": "string", "format": "unknown"}
try:
    jsonschema_rs.Draft202012Validator(
        invalid_schema, validate_formats=True, ignore_unknown_formats=False
    )
except jsonschema_rs.ValidationError as exc:
    assert exc.message == (
        "Unknown format: 'unknown'. "
        "Adjust configuration to ignore unrecognized formats"
    )

Structured Output with evaluate

evaluate returns the JSON Schema Output v1 formats instead of a boolean:

import jsonschema_rs

schema = {
    "type": "array",
    "prefixItems": [{"type": "string"}],
    "items": {"type": "integer"},
}
evaluation = jsonschema_rs.evaluate(schema, ["hello", "oops"])
type_error = {"type": '"oops" is not of type "integer"'}

assert evaluation.flag() == {"valid": False}
assert evaluation.list() == {
    "valid": False,
    "details": [
        {
            "evaluationPath": "",
            "instanceLocation": "",
            "schemaLocation": "",
            "valid": False,
        },
        {
            "valid": True,
            "evaluationPath": "/type",
            "instanceLocation": "",
            "schemaLocation": "/type",
        },
        {
            "valid": False,
            "evaluationPath": "/items",
            "instanceLocation": "",
            "schemaLocation": "/items",
            "droppedAnnotations": True,
        },
        {
            "valid": False,
            "evaluationPath": "/items",
            "instanceLocation": "/1",
            "schemaLocation": "/items",
        },
        {
            "valid": False,
            "evaluationPath": "/items/type",
            "instanceLocation": "/1",
            "schemaLocation": "/items/type",
            "errors": type_error,
        },
        {
            "valid": True,
            "evaluationPath": "/prefixItems",
            "instanceLocation": "",
            "schemaLocation": "/prefixItems",
            "annotations": 0,
        },
        {
            "valid": True,
            "evaluationPath": "/prefixItems/0",
            "instanceLocation": "/0",
            "schemaLocation": "/prefixItems/0",
        },
        {
            "valid": True,
            "evaluationPath": "/prefixItems/0/type",
            "instanceLocation": "/0",
            "schemaLocation": "/prefixItems/0/type",
        },
    ],
}

hierarchical = evaluation.hierarchical()
assert hierarchical == {
    "valid": False,
    "evaluationPath": "",
    "instanceLocation": "",
    "schemaLocation": "",
    "details": [
        {
            "valid": True,
            "evaluationPath": "/type",
            "instanceLocation": "",
            "schemaLocation": "/type",
        },
        {
            "valid": False,
            "evaluationPath": "/items",
            "instanceLocation": "",
            "schemaLocation": "/items",
            "droppedAnnotations": True,
            "details": [
                {
                    "valid": False,
                    "evaluationPath": "/items",
                    "instanceLocation": "/1",
                    "schemaLocation": "/items",
                    "details": [
                        {
                            "valid": False,
                            "evaluationPath": "/items/type",
                            "instanceLocation": "/1",
                            "schemaLocation": "/items/type",
                            "errors": type_error,
                        }
                    ],
                }
            ],
        },
        {
            "valid": True,
            "evaluationPath": "/prefixItems",
            "instanceLocation": "",
            "schemaLocation": "/prefixItems",
            "annotations": 0,
            "details": [
                {
                    "valid": True,
                    "evaluationPath": "/prefixItems/0",
                    "instanceLocation": "/0",
                    "schemaLocation": "/prefixItems/0",
                    "details": [
                        {
                            "valid": True,
                            "evaluationPath": "/prefixItems/0/type",
                            "instanceLocation": "/0",
                            "schemaLocation": "/prefixItems/0/type",
                        }
                    ],
                }
            ],
        },
    ],
}

assert evaluation.errors() == [
    {
        "schemaLocation": "/items/type",
        "absoluteKeywordLocation": None,
        "instanceLocation": "/1",
        "error": '"oops" is not of type "integer"',
    }
]

# A failing schema produces no annotations
assert evaluation.annotations() == []

Arbitrary-Precision Numbers

Numbers keep their full precision on the way to Python:

  • Integers, regardless of size, are returned as regular int objects.
  • Floating-point literals that fit into IEEE-754 become Python floats.
  • Floating-point literals that don't fit in float (for example 1e10000 or extremely precise decimals) fall back to decimal.Decimal using their original JSON string representation.

So ValidationError.kind attributes can hold Decimal values:

from decimal import Decimal
from jsonschema_rs import ValidationError, validator_for

validator = validator_for('{"const": 1e10000}')
try:
    validator.validate(0)
except ValidationError as exc:
    assert exc.kind.expected_value == Decimal("1e10000")

Schema Bundling and Dereferencing

Produce a Compound Schema Document (Appendix B) by embedding all external $ref targets into a draft-appropriate container. The bundle accepts the same values as the original.

import jsonschema_rs

address_schema = {
    "$schema": "https://json-schema.org/draft/2020-12/schema",
    "$id": "https://example.com/address.json",
    "type": "object",
    "properties": {"street": {"type": "string"}, "city": {"type": "string"}},
    "required": ["street", "city"]
}

schema = {
    "$schema": "https://json-schema.org/draft/2020-12/schema",
    "type": "object",
    "properties": {"home": {"$ref": "https://example.com/address.json"}},
    "required": ["home"]
}

registry = jsonschema_rs.Registry(
    [("https://example.com/address.json", address_schema)]
)
bundled = jsonschema_rs.bundle(schema, registry=registry)

dereference instead replaces each $ref with the schema it points to, for consumers that do not resolve references. Circular references are left in place.

dereferenced = jsonschema_rs.dereference(schema, registry=registry)

Schema Canonicalization

Experimental: the canonicalization API may change in minor releases.

canonicalize reduces a schema to a normal form that accepts the same values. Many schemas that accept the same values reduce to equal CanonicalSchema objects, and a schema proven to accept nothing reduces to false:

import jsonschema_rs

canonical = jsonschema_rs.canonicalize({
    "allOf": [
        {"type": "integer", "minimum": 0},
        {"minimum": 10, "maximum": 100},
    ]
})
assert canonical.to_json_schema() == {
    "$schema": "https://json-schema.org/draft/2020-12/schema",
    "type": "integer", "minimum": 10, "maximum": 100,
}

# These two accept the same values and compare equal
same = jsonschema_rs.canonicalize(
    {"type": "integer", "maximum": 100, "minimum": 10}
)
assert canonical == same

# A schema no value can satisfy collapses
from jsonschema_rs.canonical import Satisfiability

empty = jsonschema_rs.canonicalize(
    {"type": "integer", "minimum": 10, "maximum": 5}
)
assert empty.satisfiability() == Satisfiability.NO

A schema the canonical form cannot model exactly comes back unchanged, with kind == CanonicalKind.RAW. Its view().reason names why canonicalization kept it raw, and view().pointer the subschema at fault when a single one is.

Canonical schemas combine like sets of values. Every emitted schema carries $schema; the comments below leave it out:

positive = jsonschema_rs.canonicalize({"type": "integer", "minimum": 0})
bounded = jsonschema_rs.canonicalize({"type": "integer", "maximum": 100})

# Every value both accept
positive.intersect(bounded).to_json_schema()
# {"type": "integer", "minimum": 0, "maximum": 100}

# Every value either accepts
positive.union(bounded).to_json_schema()
# {"type": "integer"}

# Every value `positive` accepts and `bounded` rejects
positive.subtract(bounded).to_json_schema()
# {"type": "integer", "minimum": 101}

# Every value `positive` rejects: other types, negative integers
# and non-integer numbers
positive.negate().to_json_schema()
# {"anyOf": [{"type": ["null", "boolean", "string", "array", "object"]},
#            {"type": "integer", "maximum": -1},
#            {"type": "number", "not": {"multipleOf": 1}}]}

# Containment.NO: `bounded` accepts negative integers, `positive` rejects them
positive.covers(bounded)
positive.satisfiability()  # Satisfiability.YES

Comparing two versions of a schema

subtract tells you what an edit did to a schema. old.subtract(new) accepts exactly the values old accepts and new rejects, so it accepts nothing when the edit lost nothing.

old = jsonschema_rs.canonicalize({"type": "string"})
new = jsonschema_rs.canonicalize({"type": "string", "maxLength": 50})

# What `new` stopped accepting, as a schema
assert old.subtract(new).to_json_schema() == {
    "$schema": "https://json-schema.org/draft/2020-12/schema",
    "type": "string", "minLength": 51,
}
# Nothing is accepted that was not accepted before, so the change only narrows
assert new.subtract(old).satisfiability() == Satisfiability.NO

The direction to check depends on who sends the value:

  • For a request schema, check old.subtract(new). It accepts the payloads existing callers send that the new schema rejects.
  • For a response schema, check new.subtract(old). It accepts the values the new schema lets a server return that callers never agreed to read.

Satisfiability.NO on the difference proves the edit safe in that direction. UNKNOWN means the canonicalizer could not decide, and proves nothing either way. Read it as the answer that keeps you safe:

  • satisfiability(): only Satisfiability.NO proves a schema accepts nothing. Treat UNKNOWN like YES.
  • a.covers(b): only Containment.YES proves a accepts every value b accepts. Treat UNKNOWN like NO.

Containment, Satisfiability, Distinctness, CanonicalKind, UnsatisfiableReason, Cause and the exceptions below live in jsonschema_rs.canonical.

The set operations raise IncompatibleOperands when the operands differ in draft, format assertion or regular-expression engine, or resolve # or one external resource to different schemas. They raise UnsupportedOperand when an operand is RAW, and UnsupportedResult when the canonical form cannot express the result exactly. All three subclass CanonicalizationError.

Finding the dead subschemas of a document

find_unsatisfiable walks a whole document and reports each subschema that accepts no value, with the keywords at fault and their pointers:

from jsonschema_rs.canonical import UnsatisfiableReason, find_unsatisfiable

reasons = find_unsatisfiable({
    "properties": {
        "tag": {"type": "string", "minLength": 5, "maxLength": 2},
        "name": {"type": "string"},
    }
})

match reasons["/properties/tag"]:
    case UnsatisfiableReason.Conflict(causes):
        assert [(cause.pointer, cause.keywords) for cause in causes] == [
            ("/properties/tag", ["type"]),
            ("/properties/tag", ["minLength", "maxLength"]),
        ]

# A live subschema is not reported
assert "/properties/name" not in reasons

A reason is Literal (written as false), Empty (one part accepts nothing by itself) or Conflict (each part accepts values, together they accept none). A missing pointer does not prove that subschema satisfiable. For a document the canonical form cannot model, find_unsatisfiable reports nothing, the same way satisfiability() answers UNKNOWN.

Meta-Schema Validation

jsonschema_rs.meta checks a schema against the meta-schema of its draft:

import jsonschema_rs

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

# Validate schema (draft is auto-detected)
assert jsonschema_rs.meta.is_valid(schema)
jsonschema_rs.meta.validate(schema)  # No error raised

# Invalid schema
invalid_schema = {
    "minimum": "not_a_number"  # "minimum" must be a number
}

try:
    jsonschema_rs.meta.validate(invalid_schema)
except jsonschema_rs.ValidationError as exc:
    assert 'is not of type "number"' in str(exc)

Regular Expression Configuration

pattern_options picks the regex engine for pattern and patternProperties and sets its limits:

import jsonschema_rs
from jsonschema_rs import FancyRegexOptions, RegexOptions

# Default fancy-regex engine with backtracking limits
# (supports advanced features but needs protection against DoS)
validator = jsonschema_rs.validator_for(
    {"type": "string", "pattern": "^(a+)+$"},
    pattern_options=FancyRegexOptions(backtrack_limit=10_000)
)

# Standard regex engine for guaranteed linear-time matching
# (prevents regex DoS attacks but supports fewer features)
validator = jsonschema_rs.validator_for(
    {"type": "string", "pattern": "^a+$"},
    pattern_options=RegexOptions()
)

# Both engines support memory usage configuration
validator = jsonschema_rs.validator_for(
    {"type": "string", "pattern": "^a+$"},
    pattern_options=RegexOptions(
        size_limit=1024 * 1024,   # Maximum compiled pattern size
        dfa_size_limit=10240      # Maximum DFA cache size
    )
)

# Patterns in the engine's own syntax instead of ECMA 262:
# `\d` matches every Unicode decimal digit, as in the Rust `regex` crate
validator = jsonschema_rs.validator_for(
    {"type": "string", "pattern": r"^\d+$"},
    pattern_options=RegexOptions(syntax="engine")
)
assert validator.is_valid("٣")
  • FancyRegexOptions: default engine, supports lookaround and backreferences

    • backtrack_limit: Maximum backtracking steps
    • size_limit: Maximum compiled regex size in bytes
    • dfa_size_limit: Maximum DFA cache size in bytes
  • RegexOptions: matches in linear time, no lookaround or backreferences

    • size_limit: Maximum compiled regex size in bytes
    • dfa_size_limit: Maximum DFA cache size in bytes

Both take syntax: "ecma262" (default) translates patterns for the engine, "engine" passes them to it unchanged. Use "engine" for schemas whose patterns are written for the Rust regex or fancy-regex crate, such as the ones Pydantic generates.

If you validate against schemas from untrusted sources, use RegexOptions: a crafted pattern cannot make it backtrack.

Email Format Configuration

email_options makes {"format": "email"} stricter or looser than the spec default:

import jsonschema_rs
from jsonschema_rs import EmailOptions

# Require a top-level domain (reject "user@localhost")
validator = jsonschema_rs.validator_for(
    {"format": "email", "type": "string"},
    validate_formats=True,
    email_options=EmailOptions(require_tld=True)
)
validator.is_valid("user@localhost")     # False
validator.is_valid("user@example.com")   # True

# Disallow IP address literals and display names
validator = jsonschema_rs.validator_for(
    {"format": "email", "type": "string"},
    validate_formats=True,
    email_options=EmailOptions(
        allow_domain_literal=False,  # Reject "user@[127.0.0.1]"
        allow_display_text=False     # Reject "Name <user@example.com>"
    )
)

# Require at least 3 domain segments, e.g. user@sub.example.com
validator = jsonschema_rs.validator_for(
    {"format": "email", "type": "string"},
    validate_formats=True,
    email_options=EmailOptions(minimum_sub_domains=3),
)
  • require_tld: Require a top-level domain (e.g., reject "user@localhost") (default: False)
  • allow_domain_literal: Allow IP address literals like "user@[127.0.0.1]" (default: True)
  • allow_display_text: Allow display names like "Name user@example.com" (default: True)
  • minimum_sub_domains: Minimum number of domain segments required

External References

By default, jsonschema-rs fetches external $ref targets over HTTP and from the local file system. Pass a retriever to load them yourself. This one serves schemas from a dict:

import jsonschema_rs

def retrieve(uri: str):
    schemas = {
        "https://example.com/person.json": {
            "type": "object",
            "properties": {
                "name": {"type": "string"},
                "age": {"type": "integer"}
            },
            "required": ["name", "age"]
        }
    }
    if uri not in schemas:
        raise KeyError(f"Schema not found: {uri}")
    return schemas[uri]

schema = {
    "$ref": "https://example.com/person.json"
}

validator = jsonschema_rs.validator_for(schema, retriever=retrieve)

# This is valid
validator.is_valid({
    "name": "Alice",
    "age": 30
})

# This is invalid (missing "age")
validator.is_valid({
    "name": "Bob"
})  # False

For schemas from untrusted sources, pass offline=True. The validator then refuses to fetch any $ref target, so a schema cannot reach your network or file system. Schemas held in a Registry still resolve:

try:
    jsonschema_rs.validator_for(
        {"$ref": "https://example.com/other.json"}, offline=True
    )
except jsonschema_rs.ValidationError as exc:
    assert "Retrieval is disabled" in str(exc)

bundle, dereference and canonicalize take offline too.

Schema Registry

A Registry holds schemas by URI, so a validator resolves $refs to them without fetching anything:

import jsonschema_rs

# Create a registry with schemas
registry = jsonschema_rs.Registry([
    ("https://example.com/address.json", {
        "type": "object",
        "properties": {
            "street": {"type": "string"},
            "city": {"type": "string"}
        }
    }),
    ("https://example.com/person.json", {
        "type": "object",
        "properties": {
            "name": {"type": "string"},
            "address": {"$ref": "https://example.com/address.json"}
        }
    })
])

# Use the registry with any validator
validator = jsonschema_rs.validator_for(
    {"$ref": "https://example.com/person.json"},
    registry=registry
)

# Validate instances
assert validator.is_valid({
    "name": "John",
    "address": {"street": "Main St", "city": "Boston"}
})

Registry also takes a default draft and a retriever for URIs it does not hold:

import jsonschema_rs

registry = jsonschema_rs.Registry(
    resources=[
        (
            "https://example.com/address.json",
            {}
        )
    ],  # Your schemas
    draft=jsonschema_rs.Draft202012,  # Optional
    retriever=lambda uri: {}  # Optional
)

Error Handling

A ValidationError carries the message, the instance and schema paths, and a kind with keyword-specific details:

import jsonschema_rs

schema = {"type": "string", "maxLength": 5}

try:
    jsonschema_rs.validate(schema, "too long")
except jsonschema_rs.ValidationError as error:
    # Basic error information
    print(error.message)       # '"too long" is longer than 5 characters'
    print(error.instance_path) # Location in the instance that failed
    print(error.schema_path)   # Location in the schema that failed

    # Detailed error information via `kind`
    if isinstance(error.kind, jsonschema_rs.ValidationErrorKind.MaxLength):
        assert error.kind.limit == 5
        print(f"Exceeded maximum length of {error.kind.limit}")

The type stubs list every error kind and its attributes.

Error Kind Properties

kind also has generic accessors:

for error in jsonschema_rs.iter_errors({"minimum": 5}, 3):
    print(error.kind.name)      # "minimum"
    print(error.kind.value)     # 5
    print(error.kind.as_dict()) # {"limit": 5}

Each kind is a class you can match on:

for error in jsonschema_rs.iter_errors({"minimum": 5}, 3):
    match error.kind:
        case jsonschema_rs.ValidationErrorKind.Minimum(limit=limit):
            print(f"Value below {limit}")
        case jsonschema_rs.ValidationErrorKind.Type(types=types):
            print(f"Expected one of {types}")

Error Message Masking

Pass mask to replace instance values in error messages with a placeholder:

import jsonschema_rs

schema = {
    "type": "object",
    "properties": {
        "password": {"type": "string", "minLength": 8},
        "api_key": {"type": "string", "pattern": "^[A-Z0-9]{32}$"}
    }
}

# Replace instance values with "[REDACTED]"
validator = jsonschema_rs.validator_for(schema, mask="[REDACTED]")

try:
    validator.validate({
        "password": "123",
        "api_key": "secret_key_123"
    })
except jsonschema_rs.ValidationError as exc:
    assert str(exc) == '''[REDACTED] is shorter than 8 characters

Failed validating "minLength" in schema["properties"]["password"]

On instance["password"]:
    [REDACTED]'''

Performance

Compared with other Python validators:

  • 215-15,699x faster than jsonschema for complex schemas and large instances
  • 12-2,623x faster than fastjsonschema on CPython, except validate on the invalid Fast instance (x0.87)

Full results and methodology are in BENCHMARKS.md.

Compile-Time Validators

If you ship your own extension module and know the schema at build time, the Rust crate's #[jsonschema::validator(..., backend = Pyo3)] macro compiles it into a validator that reads Python objects directly, so nothing is parsed or compiled when your module is imported, and validation runs up to 3.0x faster than with a validator built at run time. See the macro documentation.

This is not available from the jsonschema-rs package on PyPI, which takes its schemas at run time. A complete extension with its build and test commands lives in examples/pyo3-extension.

Python support

jsonschema-rs supports CPython 3.10 through 3.14 and PyPy 3.10+.

Pre-built wheels are available for:

  • Linux: x86_64, i686, aarch64 (glibc and musl)
  • macOS: x86_64, aarch64, universal2
  • Windows: x64, x86, arm64

Troubleshooting

If a source build on Linux fails with linking errors (e.g., undefined symbols from ring), use the mold linker:

RUSTFLAGS="-C link-arg=-fuse-ld=mold" \
  pip install jsonschema-rs --no-binary :all:

Acknowledgements

The API design draws on the Python jsonschema package. Thanks to its maintainers and contributors.

Support

Ask questions and suggest improvements in GitHub Discussions.

Sponsorship

If you find jsonschema-rs useful, please consider sponsoring its development.

Contributing

Ways to help:

See CONTRIBUTING.md for more details.

License

Licensed under MIT License.

Metadata

Release files for jsonschema-rs 0.63.0

For a detailed explanation of source distributions (sdists) and built distributions (wheels), please see the package formats documentation.

Source distribution (sdist)

Source distribution for jsonschema-rs 0.63.0
File Size Uploaded Provenance Actions
jsonschema_rs-0.63.0.tar.gz 3.2 MB Without provenance Details for jsonschema_rs-0.63.0.tar.gz

Built distributions (wheels)

Table of built distributions (wheels) for jsonschema-rs 0.63.0
File Actions
jsonschema_rs-0.63.0-pp311-pypy311_pp80-win_amd64.whl PyPy 3.11 PyPy 3.11 8.0 Windows x86-64 Details for jsonschema_rs-0.63.0-pp311-pypy311_pp80-win_amd64.whl
jsonschema_rs-0.63.0-pp311-pypy311_pp80-macosx_10_12_x86_64.whl PyPy 3.11 PyPy 3.11 8.0 macOS 10.12+ x86-64 Details for jsonschema_rs-0.63.0-pp311-pypy311_pp80-macosx_10_12_x86_64.whl
jsonschema_rs-0.63.0-pp311-pypy311_pp73-manylinux_2_28_aarch64.whl PyPy 3.11 PyPy 3.11 7.3 Linux glibc 2.28+ ARM64 Details for jsonschema_rs-0.63.0-pp311-pypy311_pp73-manylinux_2_28_aarch64.whl
jsonschema_rs-0.63.0-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl PyPy 3.11 PyPy 3.11 7.3 Linux glibc 2.17+ x86-64 Details for jsonschema_rs-0.63.0-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl
jsonschema_rs-0.63.0-cp315-cp315t-win_arm64.whl CPython 3.15 CPython 3.15 free-threading Windows ARM64 Details for jsonschema_rs-0.63.0-cp315-cp315t-win_arm64.whl
jsonschema_rs-0.63.0-cp315-cp315t-win_amd64.whl CPython 3.15 CPython 3.15 free-threading Windows x86-64 Details for jsonschema_rs-0.63.0-cp315-cp315t-win_amd64.whl
jsonschema_rs-0.63.0-cp315-cp315t-musllinux_1_2_x86_64.whl CPython 3.15 CPython 3.15 free-threading Linux musl 1.2+ x86-64 Details for jsonschema_rs-0.63.0-cp315-cp315t-musllinux_1_2_x86_64.whl
jsonschema_rs-0.63.0-cp315-cp315t-musllinux_1_2_aarch64.whl CPython 3.15 CPython 3.15 free-threading Linux musl 1.2+ ARM64 Details for jsonschema_rs-0.63.0-cp315-cp315t-musllinux_1_2_aarch64.whl
jsonschema_rs-0.63.0-cp315-cp315t-manylinux_2_28_aarch64.whl CPython 3.15 CPython 3.15 free-threading Linux glibc 2.28+ ARM64 Details for jsonschema_rs-0.63.0-cp315-cp315t-manylinux_2_28_aarch64.whl
jsonschema_rs-0.63.0-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl CPython 3.15 CPython 3.15 free-threading Linux glibc 2.17+ x86-64 Details for jsonschema_rs-0.63.0-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl
jsonschema_rs-0.63.0-cp315-cp315t-macosx_11_0_arm64.whl CPython 3.15 CPython 3.15 free-threading macOS 11.0+ ARM64 Details for jsonschema_rs-0.63.0-cp315-cp315t-macosx_11_0_arm64.whl
jsonschema_rs-0.63.0-cp315-cp315t-macosx_10_12_x86_64.whl CPython 3.15 CPython 3.15 free-threading macOS 10.12+ x86-64 Details for jsonschema_rs-0.63.0-cp315-cp315t-macosx_10_12_x86_64.whl
jsonschema_rs-0.63.0-cp314-cp314t-win_arm64.whl CPython 3.14 CPython 3.14 free-threading Windows ARM64 Details for jsonschema_rs-0.63.0-cp314-cp314t-win_arm64.whl
jsonschema_rs-0.63.0-cp314-cp314t-win_amd64.whl CPython 3.14 CPython 3.14 free-threading Windows x86-64 Details for jsonschema_rs-0.63.0-cp314-cp314t-win_amd64.whl
jsonschema_rs-0.63.0-cp314-cp314t-musllinux_1_2_x86_64.whl CPython 3.14 CPython 3.14 free-threading Linux musl 1.2+ x86-64 Details for jsonschema_rs-0.63.0-cp314-cp314t-musllinux_1_2_x86_64.whl
jsonschema_rs-0.63.0-cp314-cp314t-musllinux_1_2_aarch64.whl CPython 3.14 CPython 3.14 free-threading Linux musl 1.2+ ARM64 Details for jsonschema_rs-0.63.0-cp314-cp314t-musllinux_1_2_aarch64.whl
jsonschema_rs-0.63.0-cp314-cp314t-manylinux_2_28_aarch64.whl CPython 3.14 CPython 3.14 free-threading Linux glibc 2.28+ ARM64 Details for jsonschema_rs-0.63.0-cp314-cp314t-manylinux_2_28_aarch64.whl
jsonschema_rs-0.63.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl CPython 3.14 CPython 3.14 free-threading Linux glibc 2.17+ x86-64 Details for jsonschema_rs-0.63.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl
jsonschema_rs-0.63.0-cp314-cp314t-macosx_11_0_arm64.whl CPython 3.14 CPython 3.14 free-threading macOS 11.0+ ARM64 Details for jsonschema_rs-0.63.0-cp314-cp314t-macosx_11_0_arm64.whl
jsonschema_rs-0.63.0-cp314-cp314t-macosx_10_12_x86_64.whl CPython 3.14 CPython 3.14 free-threading macOS 10.12+ x86-64 Details for jsonschema_rs-0.63.0-cp314-cp314t-macosx_10_12_x86_64.whl
jsonschema_rs-0.63.0-cp310-abi3-win_arm64.whl CPython 3.10 abi3 Windows ARM64 Details for jsonschema_rs-0.63.0-cp310-abi3-win_arm64.whl
jsonschema_rs-0.63.0-cp310-abi3-win_amd64.whl CPython 3.10 abi3 Windows x86-64 Details for jsonschema_rs-0.63.0-cp310-abi3-win_amd64.whl
jsonschema_rs-0.63.0-cp310-abi3-win32.whl CPython 3.10 abi3 Windows x86-32 Details for jsonschema_rs-0.63.0-cp310-abi3-win32.whl
jsonschema_rs-0.63.0-cp310-abi3-musllinux_1_2_x86_64.whl CPython 3.10 abi3 Linux musl 1.2+ x86-64 Details for jsonschema_rs-0.63.0-cp310-abi3-musllinux_1_2_x86_64.whl
jsonschema_rs-0.63.0-cp310-abi3-musllinux_1_2_aarch64.whl CPython 3.10 abi3 Linux musl 1.2+ ARM64 Details for jsonschema_rs-0.63.0-cp310-abi3-musllinux_1_2_aarch64.whl
jsonschema_rs-0.63.0-cp310-abi3-manylinux_2_28_aarch64.whl CPython 3.10 abi3 Linux glibc 2.28+ ARM64 Details for jsonschema_rs-0.63.0-cp310-abi3-manylinux_2_28_aarch64.whl
jsonschema_rs-0.63.0-cp310-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl CPython 3.10 abi3 Linux glibc 2.17+ x86-64 Details for jsonschema_rs-0.63.0-cp310-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl
jsonschema_rs-0.63.0-cp310-abi3-manylinux2014_i686.manylinux_2_17_i686.whl CPython 3.10 abi3 Linux glibc 2.17+ x86-32 Details for jsonschema_rs-0.63.0-cp310-abi3-manylinux2014_i686.manylinux_2_17_i686.whl
jsonschema_rs-0.63.0-cp310-abi3-macosx_11_0_arm64.whl CPython 3.10 abi3 macOS 11.0+ ARM64 Details for jsonschema_rs-0.63.0-cp310-abi3-macosx_11_0_arm64.whl
jsonschema_rs-0.63.0-cp310-abi3-macosx_10_12_x86_64.whl CPython 3.10 abi3 macOS 10.12+ x86-64 Details for jsonschema_rs-0.63.0-cp310-abi3-macosx_10_12_x86_64.whl

Total release size: 200.3 MB

Release files / jsonschema_rs-0.63.0.tar.gz

Download URL jsonschema_rs-0.63.0.tar.gz
Size 3.2 MB
Tags Source
SHA-256 checksum
How to use checksums
075fd1882e4c9b6518a2ff7ed781f50c728bf78c7dbfa34b3cbfc29abaa8cd99
BLAKE2b-256 checksum
How to use checksums
4ce6e4e174bb12a079eff6ad65847015f99f919f547e34b5995b0baa6ddeb2c6
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/7.0.0 CPython/3.13.16

Release files / jsonschema_rs-0.63.0-pp311-pypy311_pp80-win_amd64.whl

Download URL jsonschema_rs-0.63.0-pp311-pypy311_pp80-win_amd64.whl
Size 6.9 MB
Tags PyPy 3.11 PyPy 3.11 8.0 Windows x86-64
SHA-256 checksum
How to use checksums
30c989d84038d2b2a4f66d335b04950bcf0c6cd4a416a6b8272c815e2c11407e
BLAKE2b-256 checksum
How to use checksums
66324322401b41258e27a65d89e84a6f53e6c20e673e24aa2bcc6ead4f962136
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/7.0.0 CPython/3.13.16

Release files / jsonschema_rs-0.63.0-pp311-pypy311_pp80-macosx_10_12_x86_64.whl

Download URL jsonschema_rs-0.63.0-pp311-pypy311_pp80-macosx_10_12_x86_64.whl
Size 6.6 MB
Tags PyPy 3.11 PyPy 3.11 8.0 macOS 10.12+ x86-64
SHA-256 checksum
How to use checksums
70f3c2822fde6d8feec56a73f969a9a23813bf88339819373cef97cda879fc9a
BLAKE2b-256 checksum
How to use checksums
9c9a18a59abdc2fcadf27718a1057f8f30cdb3582ade9855268348ea827036a0
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/7.0.0 CPython/3.13.16

Release files / jsonschema_rs-0.63.0-pp311-pypy311_pp73-manylinux_2_28_aarch64.whl

Download URL jsonschema_rs-0.63.0-pp311-pypy311_pp73-manylinux_2_28_aarch64.whl
Size 6.2 MB
Tags Linux glibc 2.28+ ARM64 PyPy 3.11 PyPy 3.11 7.3
SHA-256 checksum
How to use checksums
b75fb004e3804fb455a106eaffe4651d1eeb227ba7fea9a10ebfd3c5d599015e
BLAKE2b-256 checksum
How to use checksums
45d46e0ea033b9fc1c43d293ac6dfc62d731af3b338c5ec72bca4acfc97dcfa2
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/7.0.0 CPython/3.13.16

Release files / jsonschema_rs-0.63.0-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl

Download URL jsonschema_rs-0.63.0-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl
Size 6.8 MB
Tags Linux glibc 2.17+ x86-64 PyPy 3.11 PyPy 3.11 7.3
SHA-256 checksum
How to use checksums
097d5e8c2f973460314c96a0b1d77dd9823fc0ea0d20827a16f82c9f4c722bda
BLAKE2b-256 checksum
How to use checksums
09294c62f0bf22d70b9b865c1497cf0127fbdd0e62a7bf268a83875fafac9d99
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/7.0.0 CPython/3.13.16

Release files / jsonschema_rs-0.63.0-cp315-cp315t-win_arm64.whl

Download URL jsonschema_rs-0.63.0-cp315-cp315t-win_arm64.whl
Size 6.5 MB
Tags CPython 3.15 CPython 3.15 free-threading Windows ARM64
SHA-256 checksum
How to use checksums
1a3cde67c6c5acb476a9a98e16efdaa89c18eda37f889273eac0fe0931aee906
BLAKE2b-256 checksum
How to use checksums
2017a139e3e67bc70fbe9baf06c145de0794b89fc5a5e3466180ca4410863231
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/7.0.0 CPython/3.13.16

Release files / jsonschema_rs-0.63.0-cp315-cp315t-win_amd64.whl

Download URL jsonschema_rs-0.63.0-cp315-cp315t-win_amd64.whl
Size 7.0 MB
Tags CPython 3.15 CPython 3.15 free-threading Windows x86-64
SHA-256 checksum
How to use checksums
0468bbd56fe20fca3cbbc571868924ad6686bac308602a436b653480ee345b50
BLAKE2b-256 checksum
How to use checksums
d3644a50bdc984edfa282873370705626b676148f509f2a25e2fd43c7d5060a1
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/7.0.0 CPython/3.13.16

Release files / jsonschema_rs-0.63.0-cp315-cp315t-musllinux_1_2_x86_64.whl

Download URL jsonschema_rs-0.63.0-cp315-cp315t-musllinux_1_2_x86_64.whl
Size 7.1 MB
Tags CPython 3.15 CPython 3.15 free-threading Linux musl 1.2+ x86-64
SHA-256 checksum
How to use checksums
dfebe5d90e43704aaef81000c5d2744d47a23fecfea2c4ca8a85433463f1c27e
BLAKE2b-256 checksum
How to use checksums
d9b1e1fbae1f749c07257d7cb3e56ed6ea808b5ce76b74507ce6ec38b3c36704
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/7.0.0 CPython/3.13.16

Release files / jsonschema_rs-0.63.0-cp315-cp315t-musllinux_1_2_aarch64.whl

Download URL jsonschema_rs-0.63.0-cp315-cp315t-musllinux_1_2_aarch64.whl
Size 6.4 MB
Tags CPython 3.15 CPython 3.15 free-threading Linux musl 1.2+ ARM64
SHA-256 checksum
How to use checksums
e8aacf5bf0493556a06aa04ebc9ce165cf04e41eac8a5071ade71f385b2a76e3
BLAKE2b-256 checksum
How to use checksums
b137a99f9b0078c1d70e88f7baceddb04eb3d5280dd66055fca4f9663fa2c488
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/7.0.0 CPython/3.13.16

Release files / jsonschema_rs-0.63.0-cp315-cp315t-manylinux_2_28_aarch64.whl

Download URL jsonschema_rs-0.63.0-cp315-cp315t-manylinux_2_28_aarch64.whl
Size 6.3 MB
Tags CPython 3.15 CPython 3.15 free-threading Linux glibc 2.28+ ARM64
SHA-256 checksum
How to use checksums
c0a449e36a6a951ad38f0d91402d66f264f30b17a724f51cf468e65be70536a3
BLAKE2b-256 checksum
How to use checksums
71363433f0c90594e1e9fd6d7ac8022494aa374111854e2dd7aa807c57e87dab
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/7.0.0 CPython/3.13.16

Release files / jsonschema_rs-0.63.0-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl

Download URL jsonschema_rs-0.63.0-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl
Size 6.8 MB
Tags CPython 3.15 CPython 3.15 free-threading Linux glibc 2.17+ x86-64
SHA-256 checksum
How to use checksums
717fe7a8787408e30d2b762f781a2971ffd7cf831853a1e964d65dcf03197039
BLAKE2b-256 checksum
How to use checksums
f951d6e5aacbb848a1a36b7ae3f65b4978d415b12d20fc25bf470c4cfe6b4a72
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/7.0.0 CPython/3.13.16

Release files / jsonschema_rs-0.63.0-cp315-cp315t-macosx_11_0_arm64.whl

Download URL jsonschema_rs-0.63.0-cp315-cp315t-macosx_11_0_arm64.whl
Size 6.1 MB
Tags CPython 3.15 CPython 3.15 free-threading macOS 11.0+ ARM64
SHA-256 checksum
How to use checksums
546582beb147ac65e880e1675a7ef1a9aa3ea36e10a61899fd8043734e01aab7
BLAKE2b-256 checksum
How to use checksums
ce028cd5ae36945a6232246026739de00014d9b60004a7a03b2b4800fa46bb26
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/7.0.0 CPython/3.13.16

Release files / jsonschema_rs-0.63.0-cp315-cp315t-macosx_10_12_x86_64.whl

Download URL jsonschema_rs-0.63.0-cp315-cp315t-macosx_10_12_x86_64.whl
Size 6.7 MB
Tags CPython 3.15 CPython 3.15 free-threading macOS 10.12+ x86-64
SHA-256 checksum
How to use checksums
346c61dd0b16859dc48d2c96357dceffcd45dd6ea958d2c38f18a0badc09bd47
BLAKE2b-256 checksum
How to use checksums
cf5c44e0035867a4804bc755a88749853da18adc73503e0d113ad428764066c9
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/7.0.0 CPython/3.13.16

Release files / jsonschema_rs-0.63.0-cp314-cp314t-win_arm64.whl

Download URL jsonschema_rs-0.63.0-cp314-cp314t-win_arm64.whl
Size 6.5 MB
Tags CPython 3.14 CPython 3.14 free-threading Windows ARM64
SHA-256 checksum
How to use checksums
d6bab8b856f4c274340b055f56d35239dd610f50793675ba6eaad9f5e4ad8ac4
BLAKE2b-256 checksum
How to use checksums
9055c92f98c101bae92c68b196e0499300c3c0ed1c259ebd8a7132b1072ebc1f
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/7.0.0 CPython/3.13.16

Release files / jsonschema_rs-0.63.0-cp314-cp314t-win_amd64.whl

Download URL jsonschema_rs-0.63.0-cp314-cp314t-win_amd64.whl
Size 7.0 MB
Tags CPython 3.14 CPython 3.14 free-threading Windows x86-64
SHA-256 checksum
How to use checksums
5e587f403889c257931a7172882a35f597a1831b8ae63381af80c5e1506d6c2d
BLAKE2b-256 checksum
How to use checksums
9292d83051bdd951655db38ee550d38502a1bc27a3007436735424f923c9159d
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/7.0.0 CPython/3.13.16

Release files / jsonschema_rs-0.63.0-cp314-cp314t-musllinux_1_2_x86_64.whl

Download URL jsonschema_rs-0.63.0-cp314-cp314t-musllinux_1_2_x86_64.whl
Size 7.1 MB
Tags CPython 3.14 CPython 3.14 free-threading Linux musl 1.2+ x86-64
SHA-256 checksum
How to use checksums
7714f3056bfbc4afeff3fc7fbe4a6ad361f4b097224f40ccd408cd72b295c0f0
BLAKE2b-256 checksum
How to use checksums
c2d92ea1f36a058be837f9f025289062d28a6b0af93aae4bc9d45b257490cd66
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/7.0.0 CPython/3.13.16

Release files / jsonschema_rs-0.63.0-cp314-cp314t-musllinux_1_2_aarch64.whl

Download URL jsonschema_rs-0.63.0-cp314-cp314t-musllinux_1_2_aarch64.whl
Size 6.4 MB
Tags CPython 3.14 CPython 3.14 free-threading Linux musl 1.2+ ARM64
SHA-256 checksum
How to use checksums
3d2e5f533e1348b42188ff42fb223f96cffbd3f79b39b4b45bbbfd07d1ff901a
BLAKE2b-256 checksum
How to use checksums
35cd29cf083abe4c465f15d4418a4a65d39f28f13d17002b63de10b9d44863a0
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/7.0.0 CPython/3.13.16

Release files / jsonschema_rs-0.63.0-cp314-cp314t-manylinux_2_28_aarch64.whl

Download URL jsonschema_rs-0.63.0-cp314-cp314t-manylinux_2_28_aarch64.whl
Size 6.3 MB
Tags CPython 3.14 CPython 3.14 free-threading Linux glibc 2.28+ ARM64
SHA-256 checksum
How to use checksums
f64ef53575ada41a0cecc677759e0d65073c5413bd85e8e342204a743e3ab1a1
BLAKE2b-256 checksum
How to use checksums
eeca8ffe851707d0c2ffc0d620c210c81ffcb069012e047b411a5e1b0f060f3c
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/7.0.0 CPython/3.13.16

Release files / jsonschema_rs-0.63.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl

Download URL jsonschema_rs-0.63.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl
Size 6.8 MB
Tags CPython 3.14 CPython 3.14 free-threading Linux glibc 2.17+ x86-64
SHA-256 checksum
How to use checksums
ca6a192e37ac1e012d1b4b96ddcd7d0fe22d0aa94c9a82698c02fe4eea734d31
BLAKE2b-256 checksum
How to use checksums
153c0c0fe3ce0d4cf032a6a83015931bc5b8f772400fb4a546261578f493b700
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/7.0.0 CPython/3.13.16

Release files / jsonschema_rs-0.63.0-cp314-cp314t-macosx_11_0_arm64.whl

Download URL jsonschema_rs-0.63.0-cp314-cp314t-macosx_11_0_arm64.whl
Size 6.1 MB
Tags CPython 3.14 CPython 3.14 free-threading macOS 11.0+ ARM64
SHA-256 checksum
How to use checksums
84cfb01adaf1d0ac590ca24f06dd50d2208699b7b17fa92b5fb02c10093ce408
BLAKE2b-256 checksum
How to use checksums
592bdf9f527deaf5a78f66059ba961fdc3e5d4e744f7f36058f642c21eb540be
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/7.0.0 CPython/3.13.16

Release files / jsonschema_rs-0.63.0-cp314-cp314t-macosx_10_12_x86_64.whl

Download URL jsonschema_rs-0.63.0-cp314-cp314t-macosx_10_12_x86_64.whl
Size 6.7 MB
Tags CPython 3.14 CPython 3.14 free-threading macOS 10.12+ x86-64
SHA-256 checksum
How to use checksums
6f5d3695733375896e2643c2b55abd31d202a1413fcc8fe23ea3978a71a7cbf3
BLAKE2b-256 checksum
How to use checksums
6765a9649a189174e0d49cc4ec460b7fafc6f3fc746d77da0cbf30b0176f8404
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/7.0.0 CPython/3.13.16

Release files / jsonschema_rs-0.63.0-cp310-abi3-win_arm64.whl

Download URL jsonschema_rs-0.63.0-cp310-abi3-win_arm64.whl
Size 6.4 MB
Tags CPython 3.10 Windows ARM64 abi3
SHA-256 checksum
How to use checksums
3cf1cada1be21b61c4fa5ae63610c6121b47f3d5f54936297181435aa01b1628
BLAKE2b-256 checksum
How to use checksums
5334693b00914560933b6508b45ce65bd1828054ab35d37b731faf0f40e337a7
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/7.0.0 CPython/3.13.16

Release files / jsonschema_rs-0.63.0-cp310-abi3-win_amd64.whl

Download URL jsonschema_rs-0.63.0-cp310-abi3-win_amd64.whl
Size 6.9 MB
Tags CPython 3.10 Windows x86-64 abi3
SHA-256 checksum
How to use checksums
23f03877d32a17a12a804704df0d6ccba9220c4757ccc75011bb8a3d9641914e
BLAKE2b-256 checksum
How to use checksums
9c990c3421382bd2ce870666a5d48c49bb95983e561355e12af39321ba760605
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/7.0.0 CPython/3.13.16

Release files / jsonschema_rs-0.63.0-cp310-abi3-win32.whl

Download URL jsonschema_rs-0.63.0-cp310-abi3-win32.whl
Size 6.0 MB
Tags CPython 3.10 Windows x86-32 abi3
SHA-256 checksum
How to use checksums
1cc4e9ed0d000b5850eb8699dd3943f8ebcb4e3854cef2f3c1a75ef7233f7371
BLAKE2b-256 checksum
How to use checksums
8a3432c8367eaf5a03a0db82094bd78662b1942b842be685c7723d9b14d4547c
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/7.0.0 CPython/3.13.16

Release files / jsonschema_rs-0.63.0-cp310-abi3-musllinux_1_2_x86_64.whl

Download URL jsonschema_rs-0.63.0-cp310-abi3-musllinux_1_2_x86_64.whl
Size 7.0 MB
Tags CPython 3.10 Linux musl 1.2+ x86-64 abi3
SHA-256 checksum
How to use checksums
f2f511d52ebcb3810c88738a1c34c16abe4b362d8cd882b2422bf1b45f3b476b
BLAKE2b-256 checksum
How to use checksums
45ca3e95373d26b40c0ae31f48dda325fa9cf999cd04094051adc0eb19f2456b
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/7.0.0 CPython/3.13.16

Release files / jsonschema_rs-0.63.0-cp310-abi3-musllinux_1_2_aarch64.whl

Download URL jsonschema_rs-0.63.0-cp310-abi3-musllinux_1_2_aarch64.whl
Size 6.4 MB
Tags CPython 3.10 Linux musl 1.2+ ARM64 abi3
SHA-256 checksum
How to use checksums
558b986bd0010f8d27ca8fdc82497d40daf83bed781e6dfd9a6cb4796f122ebe
BLAKE2b-256 checksum
How to use checksums
71875750bef7f7751b047236d366cb9bdc423d1317bfed6050abb88ce9310e96
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/7.0.0 CPython/3.13.16

Release files / jsonschema_rs-0.63.0-cp310-abi3-manylinux_2_28_aarch64.whl

Download URL jsonschema_rs-0.63.0-cp310-abi3-manylinux_2_28_aarch64.whl
Size 6.2 MB
Tags CPython 3.10 Linux glibc 2.28+ ARM64 abi3
SHA-256 checksum
How to use checksums
f9a170051f686333cc3d793880a4cb096fcfb425e40962db8d56431476d28ac4
BLAKE2b-256 checksum
How to use checksums
6af5ad69db53ad212354b81449fbdcb7a50bd8945b50e21c62c67b7b6a3d61dc
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/7.0.0 CPython/3.13.16

Release files / jsonschema_rs-0.63.0-cp310-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl

Download URL jsonschema_rs-0.63.0-cp310-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl
Size 6.8 MB
Tags CPython 3.10 Linux glibc 2.17+ x86-64 abi3
SHA-256 checksum
How to use checksums
168351168848ea712873807545c250ce9d0d76714f9ee7fbef09af866d10ce50
BLAKE2b-256 checksum
How to use checksums
31a3672fd8789fe6843d876476ce988885707e6d5a8cb87abec3485fbd6854e1
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/7.0.0 CPython/3.13.16

Release files / jsonschema_rs-0.63.0-cp310-abi3-manylinux2014_i686.manylinux_2_17_i686.whl

Download URL jsonschema_rs-0.63.0-cp310-abi3-manylinux2014_i686.manylinux_2_17_i686.whl
Size 6.6 MB
Tags CPython 3.10 Linux glibc 2.17+ x86-32 abi3
SHA-256 checksum
How to use checksums
c33272f65d2c400636e502c406e9684baf27ff815c0b2cde246c4a1221982117
BLAKE2b-256 checksum
How to use checksums
120662fbb0b26a53fe7c033c431742e75b7d0264ac46a5d555c2b61e7fd11981
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/7.0.0 CPython/3.13.16

Release files / jsonschema_rs-0.63.0-cp310-abi3-macosx_11_0_arm64.whl

Download URL jsonschema_rs-0.63.0-cp310-abi3-macosx_11_0_arm64.whl
Size 6.1 MB
Tags CPython 3.10 abi3 macOS 11.0+ ARM64
SHA-256 checksum
How to use checksums
90fb53dbcec10cc08d00d172a6686925c24cb507b977bff8f0fdad4185dc6183
BLAKE2b-256 checksum
How to use checksums
d256bc0f47582fea16450dba50b462ce0af50b92b34a5f95a1f96e8398736974
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/7.0.0 CPython/3.13.16

Release files / jsonschema_rs-0.63.0-cp310-abi3-macosx_10_12_x86_64.whl

Download URL jsonschema_rs-0.63.0-cp310-abi3-macosx_10_12_x86_64.whl
Size 6.6 MB
Tags CPython 3.10 abi3 macOS 10.12+ x86-64
SHA-256 checksum
How to use checksums
65a0cee222245b53a083fd6c5a0bb378b6316568b97273abfc0deb6dc05c8526
BLAKE2b-256 checksum
How to use checksums
fdff2aadff3c22c376d4fa0d647d9315da47ceff038c77051a1ed858654cdd1d
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/7.0.0 CPython/3.13.16

Security for jsonschema-rs 0.63.0

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

No provenance found

None of the files in this release were uploaded with provenance metadata.

A note on package security

PyPI is a repository for distributing packages, not a service for auditing them. While third-party security researchers and our staff do their best to detect and remove malicious packages, PyPI cannot guarantee the quality, security or suitability of any given package.

To learn more about protecting yourself from malicious actors, visit our package security documentation.

Release history Release notifications | RSS feed

This release

0.63.0 This release

31 release files No provenance

Anthropic, PBC Visionary sponsor Bloomberg Visionary sponsor Hudson River Trading Visionary sponsor Meta Visionary sponsor NVIDIA Visionary sponsor Microsoft Sustainability sponsor Depot Continuous Integration AWS Cloud computing and Security Sponsor Datadog Monitoring Fastly CDN Google Download Analytics Sentry Error logging StatusPage Status page