Schema Validation and Data Sanitization Libraries for JavaScript
ajv, joi, jsonschema, validator, and yup are tools used to ensure data integrity in JavaScript applications. ajv and jsonschema focus on strict JSON Schema compliance, ideal for API contracts and configuration files. joi and yup provide flexible object schema validation, with yup tailored for React forms. validator specializes in string sanitization and checks, such as emails or URLs, without handling complex object structures. Together, they cover the spectrum from simple string checks to deep object graph validation.
Npm Package Weekly Downloads Trend
Github Stars Ranking
Stat Detail
Schema Validation and Data Sanitization Libraries for JavaScript
When building robust JavaScript applications, ensuring data integrity is critical. Whether you are handling API responses, user inputs, or configuration files, you need tools to verify that data matches expected shapes. ajv, joi, jsonschema, validator, and yup each approach this problem differently. Let's compare how they handle rule definition, execution, and integration.
📝 Defining Validation Rules
The way you define rules varies significantly between JSON Schema standards and fluent APIs.
ajv uses standard JSON Schema objects.
- You define a schema using standard keywords like
typeandproperties. - This ensures compatibility with other tools that understand JSON Schema.
// ajv: JSON Schema definition
const schema = {
type: "object",
properties: {
email: { type: "string", format: "email" }
},
required: ["email"]
};
joi uses a chainable fluent API.
- You build schemas by chaining methods like
.object()and.string(). - This offers high readability and complex rule combinations.
// joi: Fluent schema definition
const schema = Joi.object({
email: Joi.string().email().required()
});
jsonschema also uses standard JSON Schema objects.
- Similar to
ajv, it relies on the official specification. - The structure is identical, but the underlying engine differs.
// jsonschema: JSON Schema definition
const schema = {
type: "object",
properties: {
email: { type: "string", format: "email" }
},
required: ["email"]
};
validator does not use schemas.
- It provides standalone functions for specific string checks.
- You call functions directly on the string value.
// validator: Direct function call
const isValid = validator.isEmail("test@example.com");
yup uses a chainable API similar to joi.
- It is designed to be lightweight and work well with JavaScript objects.
- The syntax is concise and supports asynchronous rules.
// yup: Fluent schema definition
const schema = yup.object({
email: yup.string().email().required()
});
▶️ Running Validation
Execution models differ between synchronous checks, compiled functions, and promises.
ajv compiles schemas into functions for speed.
- You compile the schema once, then call the function repeatedly.
- This is highly efficient for validating many records.
// ajv: Compile and validate
const ajv = new Ajv();
const validate = ajv.compile(schema);
const valid = validate(data);
joi validates synchronously by default.
- You call
.validate()on the schema object. - It returns an object containing either an error or the validated value.
// joi: Validate synchronously
const { error, value } = schema.validate(data);
jsonschema validates synchronously.
- You pass the data and schema to a main function.
- It returns a result object indicating success or failure.
// jsonschema: Validate function
const result = validator.validate(data, schema);
validator executes immediately.
- Functions return boolean values or sanitized strings.
- There is no compilation step or schema object.
// validator: Immediate check
const isValid = validator.isURL("https://example.com");
yup validates asynchronously.
- The
.validate()method returns a Promise. - This allows for async rules, such as checking database uniqueness.
// yup: Validate asynchronously
try {
await schema.validate(data);
} catch (err) {
// Handle error
}
❌ Error Handling
How errors are reported impacts how you build user feedback or logging systems.
ajv stores errors on the instance.
- After validation, you check the
errorsproperty. - Errors are detailed and follow JSON Schema standards.
// ajv: Check errors array
if (!valid) {
console.log(ajv.errors);
}
joi returns errors in the result object.
- The
errorproperty contains a structured message. - You can customize error messages easily during schema definition.
// joi: Check error property
if (error) {
console.log(error.details);
}
jsonschema returns errors in the result.
- The
errorsarray lists all validation failures. - It provides clear pointers to where data failed.
// jsonschema: Check result errors
if (!result.valid) {
console.log(result.errors);
}
validator returns booleans or throws.
- Most functions return
falseon failure. - Some functions throw errors if input is invalid type.
// validator: Check boolean result
if (!isValid) {
console.log("Invalid input");
}
yup throws errors or returns them in Promise rejection.
- Errors are formatted for easy consumption in UI forms.
- You can catch them using try/catch blocks.
// yup: Catch validation error
try {
await schema.validate(data);
} catch (err) {
console.log(err.errors);
}
⚛️ React Integration
Frontend frameworks often require specific validation behaviors.
ajv has no built-in React support.
- You must manually connect validation results to form state.
- Best used for validating API responses before updating state.
// ajv: Manual integration
useEffect(() => {
const valid = validate(apiData);
if (!valid) setError(ajv.errors);
}, [apiData]);
joi has no built-in React support.
- Often used in backend APIs serving React frontends.
- Can be used in frontend but lacks form helpers.
// joi: Manual integration
const { error } = schema.validate(formData);
setFormError(error ? error.message : null);
jsonschema has no built-in React support.
- Similar to
ajv, it requires manual wiring. - Rarely used directly in modern React form flows.
// jsonschema: Manual integration
const res = validator.validate(formData, schema);
setErrors(res.errors);
validator has no built-in React support.
- Used for individual field checks within change handlers.
- Common in custom input components for sanitization.
// validator: Field check
const handleChange = (e) => {
if (validator.isEmail(e.target.value)) { /*...*/ }
};
yup integrates deeply with React form libraries.
- Works out-of-the-box with Formik and React Hook Form.
- Handles field-level errors and touch states automatically.
// yup: Formik integration
<Formik validationSchema={schema} onSubmit={...}>
{/* Form fields */}
</Formik>
🌱 Similarities: Shared Ground
While the differences are clear, these libraries share core goals around data safety.
1. 🛡️ Data Integrity Focus
- All tools aim to prevent invalid data from propagating.
- They reduce runtime errors by catching issues early.
// Shared goal: Prevent bad data
if (!isValid) { throw new Error("Bad Data"); }
2. 🔧 Customizable Rules
- Each allows defining specific constraints (length, format, type).
- Developers can enforce business logic through validation.
// Shared concept: Custom constraint
// All support checking minimum length or specific patterns
3. 📦 NPM Ecosystem
- All are installed via npm and work in Node.js environments.
- They support TypeScript definitions for better developer experience.
// Shared installation
// npm install <package-name>
📊 Summary: Key Differences
| Feature | ajv | joi | jsonschema | validator | yup |
|---|---|---|---|---|---|
| Schema Type | JSON Schema | Fluent API | JSON Schema | String Functions | Fluent API |
| Execution | Compiled Function | Synchronous | Synchronous | Immediate | Asynchronous |
| React Ready | ❌ Manual | ❌ Manual | ❌ Manual | ❌ Manual | ✅ Built-in |
| Best For | Performance/Standards | Complex Objects | Simple JSON Schema | String Checks | React Forms |
| Error Output | Instance Property | Result Object | Result Object | Boolean | Promise Rejection |
💡 The Big Picture
ajv is like a high-performance engine 🏎️ — built for speed and strict adherence to JSON Schema standards. Ideal for backend services, API validation, and large-scale data processing where performance is critical.
joi is like a precision toolkit 🧰 — offers deep control over object structures with a verbose but powerful API. Best for Node.js services validating complex request payloads.
jsonschema is like a reference implementation 📖 — provides a pure JS version of the JSON Schema spec. Suitable for simple needs where adding a heavier dependency like Ajv is not desired.
validator is like a utility knife 🔪 — focused strictly on string checks and sanitization. Use it for quick email or URL checks without the overhead of a schema engine.
yup is like a form assistant 🤝 — designed to work seamlessly with React forms. Perfect for frontend developers who need async validation and tight integration with form state.
Final Thought: Despite their differences, all five libraries serve the same mission — keep your data clean and your application stable. Choose based on where your validation happens (frontend vs backend) and what shape your data takes (strings vs objects vs JSON Schema).
How to Choose: ajv vs joi vs jsonschema vs validator vs yup
- ajv:
Choose
ajvwhen you need high-performance validation against standard JSON Schema definitions. It is ideal for backend services, API gateways, or any scenario where strict compliance with a formal schema specification is required. Its compilation model offers speed benefits for validating large volumes of data repeatedly. Use this when performance and standardization matter more than developer-friendly syntax. - joi:
Choose
joifor complex object validation where you want a rich, chainable API to define rules. It works well in Node.js backend services to validate incoming request payloads before they reach your business logic. The schema definitions are verbose but very explicit about data types and constraints. It is suitable for projects that need robust validation outside of the React ecosystem. - jsonschema:
Choose
jsonschemaif you require a pure JavaScript implementation of JSON Schema without additional dependencies. It is useful for environments where minimizing external code is critical, though it is generally slower thanajv. This package is stable but sees less active development compared to modern alternatives. Consider it for simple use cases where Ajv might be overkill. - validator:
Choose
validatorwhen you only need to check or sanitize individual strings, such as emails, URLs, or credit card numbers. It does not handle object schemas, so it is best paired with other tools for full payload validation. This library is lightweight and focused solely on string utility functions. Use it for quick checks where importing a full schema engine is unnecessary. - yup:
Choose
yupif you are building React forms and need integration with libraries like Formik or React Hook Form. It supports asynchronous validation and transforms data seamlessly during the validation process. The API is concise and designed to work well with component state. It is the preferred choice for frontend form validation where user experience is a priority.
Popular Comparisons
README for ajv
Ajv JSON schema validator
The fastest JSON validator for Node.js and browser.
Supports JSON Schema draft-04/06/07/2019-09/2020-12 (draft-04 support requires ajv-draft-04 package) and JSON Type Definition RFC8927.
Ajv sponsors
Contributing
More than 100 people contributed to Ajv, and we would love to have you join the development. We welcome implementing new features that will benefit many users and ideas to improve our documentation.
Please review Contributing guidelines and Code components.
Documentation
All documentation is available on the Ajv website.
Some useful site links:
- Getting started
- JSON Schema vs JSON Type Definition
- API reference
- Strict mode
- Standalone validation code
- Security considerations
- Command line interface
- Frequently Asked Questions
Please sponsor Ajv development
Since I asked to support Ajv development 40 people and 6 organizations contributed via GitHub and OpenCollective - this support helped receiving the MOSS grant!
Your continuing support is very important - the funds will be used to develop and maintain Ajv once the next major version is released.
Please sponsor Ajv via:
- GitHub sponsors page (GitHub will match it)
- Ajv Open Collective
Thank you.
Open Collective sponsors
Performance
Ajv generates code to turn JSON Schemas into super-fast validation functions that are efficient for v8 optimization.
Currently Ajv is the fastest and the most standard compliant validator according to these benchmarks:
- json-schema-benchmark - 50% faster than the second place
- jsck benchmark - 20-190% faster
- z-schema benchmark
- themis benchmark
Performance of different validators by json-schema-benchmark:
Features
- Ajv implements JSON Schema draft-06/07/2019-09/2020-12 standards (draft-04 is supported in v6):
- all validation keywords (see JSON Schema validation keywords)
- OpenAPI extensions:
- NEW: keyword discriminator.
- keyword nullable.
- full support of remote references (remote schemas have to be added with
addSchemaor compiled to be available) - support of recursive references between schemas
- correct string lengths for strings with unicode pairs
- JSON Schema formats (with ajv-formats plugin).
- validates schemas against meta-schema
- NEW: supports JSON Type Definition:
- all keywords (see JSON Type Definition schema forms)
- meta-schema for JTD schemas
- "union" keyword and user-defined keywords (can be used inside "metadata" member of the schema)
- supports browsers and Node.js 18.x - current
- asynchronous loading of referenced schemas during compilation
- "All errors" validation mode with option allErrors
- error messages with parameters describing error reasons to allow error message generation
- i18n error messages support with ajv-i18n package
- removing-additional-properties
- assigning defaults to missing properties and items
- coercing data to the types specified in
typekeywords - user-defined keywords
- additional extension keywords with ajv-keywords package
- $data reference to use values from the validated data as values for the schema keywords
- asynchronous validation of user-defined formats and keywords
Install
To install version 8:
npm install ajv
Getting started
Try it in the Node.js REPL: https://runkit.com/npm/ajv
In JavaScript:
// or ESM/TypeScript import
import Ajv from "ajv"
// Node.js require:
const Ajv = require("ajv")
const ajv = new Ajv() // options can be passed, e.g. {allErrors: true}
const schema = {
type: "object",
properties: {
foo: {type: "integer"},
bar: {type: "string"},
},
required: ["foo"],
additionalProperties: false,
}
const data = {
foo: 1,
bar: "abc",
}
const validate = ajv.compile(schema)
const valid = validate(data)
if (!valid) console.log(validate.errors)
Learn how to use Ajv and see more examples in the Guide: getting started
Changes history
See https://github.com/ajv-validator/ajv/releases
Please note: Changes in version 8.0.0
Code of conduct
Please review and follow the Code of conduct.
Please report any unacceptable behaviour to ajv.validator@gmail.com - it will be reviewed by the project team.
Security contact
To report a security vulnerability, please use the Tidelift security contact. Tidelift will coordinate the fix and disclosure. Please do NOT report security vulnerabilities via GitHub issues.
Open-source software support
Ajv is a part of Tidelift subscription - it provides a centralised support to open-source software users, in addition to the support provided by software maintainers.