Specification Release v2.4.1

Architectural rigor for JSON schemas.

Stop drafting data contracts in unstructured text editors. SchemaInterface provides deterministic modeling, instant validation, and precise version control for engineering teams operating at scale.

Open Editor Read Specification

99.9% Validation Accuracy

<10ms Evaluation Time

Draft 2020-12 Full Compliance

user_profile.schema.json

"$schema": "https://json-schema.org/draft/2020-12/schema",
"type": "object",
"properties": {
  "uuid": {
    "type": "string",
    "format": "uuid"
  },
  "role": {
    "type": "string",
    "enum": ["admin", "user"]
  }
},
"required": ["uuid", "role"]

Data consistency is not a byproduct of good intentions. It is the result of explicit contracts, rigorously enforced. We built SchemaInterface because ambiguity in payloads costs engineering teams thousands of hours in debugging.

— The Infrastructure Team

Deterministic Validation

No unpredictable edge cases. Our engine evaluates schemas exactly against the specified draft standard, highlighting structural flaws before they reach production endpoints.

Read the methodology

Type-Safe Generation

Export your JSON schemas directly to TypeScript interfaces, Rust structs, or Go types. Maintain a single source of truth that cascades to your entire stack automatically.

Explore type generator

Diff & Regression Analysis

Compare schema versions structurally, not textually. Identify breaking changes—like a widened requirement or narrowed enum—before they break downstream consumers.

Try the diff tool

Live Evaluation Matrix

Input raw JSON payloads. See immediate structural validation against strict definitions. No server round-trip required.

Full Workspace

Interactive validation requires JavaScript. Visit the Validation Tool for form-based fallback.

Input Payload

Validation Result

Valid

Evaluation complete in 2ms.
Matched schema: UserState
Constraint: "status" enum satisfied.

Specification Guides

Stop guessing how oneOf and anyOf differ. Our guides break down the JSON Schema specification with concrete examples, edge cases, and performance implications.

Browse all guides

01 // Advanced Modeling

Modeling Polymorphism

Correct usage of discriminator properties, oneOf constraints, and implications for code generation tools.

02 // Ecosystem

OpenAPI 3.1 Compat

Navigating the convergence of OpenAPI and JSON Schema, and what it means for your API gateways.

03 // Architecture

Schema Composition ($ref)

Structuring repositories for reuse without creating cyclic dependencies or unmanageable reference chains.

04 // Security

Regex DoS Prevention

Auditing pattern constraints in schemas to prevent catastrophic backtracking attacks on validation endpoints.

Draft Compliance Matrix

SchemaInterface implements full specification compliance across multiple drafts, verified against the official JSON Schema Test Suite.

Feature / Specification	Draft 4	Draft 7	Draft 2019-09	Draft 2020-12
Base Validation	100%	100%	100%	100%
Format Evaluation	Partial	100%	100%	100%
Dynamic Refs ($dynamicRef)	N/A	N/A	Supported	Optimized
Vocabulary Extension	N/A	N/A	Supported	Supported

* Test suite executed at build 4910a. Figures updated 2024-03-15.

Stop shipping fragile integrations.

Begin defining explicit contracts for your APIs, events, and configurations today. No account required for local tools.

Launch Editor Enterprise Licensing

Adopted by teams that require certainty.

When deploying configuration changes to thousands of nodes, a typo in a JSON payload is catastrophic. Leading infrastructure teams use SchemaInterface to validate state before it propagates.

"SchemaInterface caught a subtle regex DoS vulnerability in our incoming webhook schema that bypassed our previous validation pipeline."

— Lead Architect, FinTech Infrastructure

GLOBEX

A.I.M.

SYS_CORP

Massive

Zero-Overhead Integration

Compile schemas to WebAssembly for edge execution, or distribute them via our Enterprise Registry. No heavy JVM dependencies.

CLI Validation

$ schemaint validate \\
    --schema ./contracts/user.json \\
    --payload ./events/new_user.json

✓ Valid against Draft 2020-12 (2ms)

CI/CD Enforcement

name: Contract Check
steps:
  - uses: schemaint/action@v2
    with:
      registry: https://internal.reg
      strict: true
      fail-on-warning: true

Edge Execution

import { Validator } from '@schemaint/wasm';

const v = new Validator(wasmBinary);
v.compile(schemaData);

export default (req) => {
  return v.evaluate(req.body);
};

Common Inquiries

How does this compare to Ajv?

Ajv is a fast compiler for Node.js. SchemaInterface is a polyglot infrastructure tool designed for cross-language consistency (Rust, Go, Wasm) and strict specification compliance over loose matching.

Can I use the web tools without an account?

Yes. All tools under /tools execute client-side. No data is sent to our servers, ensuring your proprietary schemas remain private.

Do you support OpenAPI 3.0 schemas?

We support OpenAPI 3.1 (which natively utilizes JSON Schema Draft 2020-12). We provide migration utilities for OpenAPI 3.0 schemas. Read our compatibility guide.

What is the performance overhead?

Pre-compiled schemas validate payloads in under 10 microseconds. Compilation of complex schemas with multiple remote `$ref` resolutions takes roughly 2-5ms.

Read the full documentation →

The Contract Lifecycle

From definition to deployment, enforce structure at every boundary.

Author

Define schema in YAML/JSON using our local editor with instant linting.

Verify

CI pipeline runs schema-diff to ensure no breaking changes are merged.

Enforce

API Gateways drop invalid payloads before they reach downstream services.

Air-Gapped Ready

Enterprise deployments do not require outbound internet access. Our binaries and schema registries can operate entirely within secure VPCs, meeting strict compliance requirements for financial and healthcare institutions.

Review Security Posture

Engineering Resources

View All

Validations / Day

Telemetry Sent

<2ms

Avg P99 Latency

100%

Draft 20-12 Pass

Ready to formalize your data contracts?

Start Editor Read Documentation

Engine Specifications

Supported Drafts

Draft 2020-12
Draft 2019-09
Draft 7
Draft 4 (Partial)

Output Formats

Basic Flag
List Format
Hierarchical Node
SARIF (WIP)

Security

Bounded Ref Resolution
ReDoS Protected Patterns
Zero Network Calls (Default)

Ecosystem Targets

x86_64 / ARM64 Binaries
WebAssembly (Wasm)
Rust Crate