Open-source alternatives to Hapijs Joi

Superstruct is a JavaScript and TypeScript data validation library used to verify that data structures match defined shapes and types. It functions as a composable schema builder and a TypeScript schema validator, ensuring that runtime data checks remain synchronized with static type definitions. The library features a data coercion engine that transforms input values or injects default values before the validation process is executed. It enables the creation of complex validation rules by nesting, merging, or omitting properties from existing structures. Its capabilities cover the validatio

Ajv is a high-performance data validation framework that compiles JSON schemas into optimized, standalone JavaScript functions. By transforming declarative schema definitions into executable code, it eliminates runtime interpretation overhead and provides a secure, efficient way to enforce data integrity across both browser and server environments. The library distinguishes itself through its focus on performance and type safety. It employs advanced compilation techniques, including abstract syntax tree optimization and function caching, to ensure rapid validation. Beyond standard checks, it

Elysia is a high-performance TypeScript web framework designed for building type-safe backend services. It provides a modular, plugin-based architecture that allows developers to compose server logic, middleware, and validation schemas into scalable application instances. By leveraging native web standards, the framework ensures portability across diverse JavaScript runtimes, including Node.js, Deno, and various edge computing environments. The framework distinguishes itself through its focus on end-to-end type safety, automatically synchronizing request and response definitions between the s

Joi is a JavaScript data validation library used to define schemas that ensure the structure and data types of objects remain consistent. It functions as a schema-based validator and object schema definition tool, preventing invalid information from entering an application by checking data against predefined constraints and rules. The library employs a chainable fluent interface and a constraint-based validation engine to build complex validation pipelines. It utilizes recursive tree traversal to validate nested data structures and a type-coercion pipeline to transform input values into the t

v8n is a JavaScript data validation library used to verify that values, objects, and arrays meet specific criteria. It functions as a schema-based validator and an asynchronous validation engine, utilizing a fluent API to construct sequences of chainable rules and constraints. The framework is distinguished by its ability to execute promises and network requests during the validation process to determine if a value is valid. It allows for the creation of reusable validation schemas and provides a customizable rule framework where users can define their own logic and configure how error result

Ajv is a JSON Schema validator and schema compilation engine used to verify that JavaScript objects conform to specific JSON Schema definitions. It functions as a data coercer and localization tool, allowing for the application of default values and the translation of validation error messages into different languages. The project converts declarative JSON Schema definitions into optimized JavaScript functions to increase validation speed. It supports the extension of validation logic through custom keywords and the generation of standalone validation code that executes without external depen

Pandera is a data pipeline validation framework and statistical type validation tool. It functions as a library for defining and enforcing schemas on datasets to ensure data quality and consistency, specifically providing validation capabilities for Pandas dataframes. The project includes a schema inference tool that automates setup by analyzing existing dataset samples to generate validation schemas. It also serves as a synthetic data generator, creating artificial datasets based on predefined schemas to verify data-producing functions. The framework covers data engineering quality assuranc

AWS Powertools for Python is a utility framework designed for building production-ready Python functions on AWS Lambda. It provides a comprehensive suite of tools for observability, event parsing, routing, and idempotency management to streamline the development of serverless applications. The project distinguishes itself through specialized capabilities for event-driven architectures and AI agent orchestration. It enables the implementation of AI agents by exposing functions as tools via OpenAPI schemas and managing conversation states. Additionally, it features an idempotency library that p

This library provides a comprehensive system for defining data schemas and enforcing structural integrity within JavaScript applications. It enables developers to construct declarative rules for complex, nested objects, ensuring that data conforms to expected types and constraints before it is processed or stored. By integrating directly with the Meteor framework, it serves as a central tool for maintaining consistent data structures across collections and remote procedure calls. The project distinguishes itself through its deep integration with reactive data systems, allowing validation stat

Zod is a TypeScript-first schema declaration and validation library designed to ensure end-to-end data integrity. It functions as a runtime type guard, allowing developers to define complex data structures through a declarative, chainable syntax. By using these schema definitions, the library automatically derives static TypeScript types, eliminating the need for manual type duplication and ensuring that runtime data matches expected application contracts. The library distinguishes itself through functional schema composition, which enables the creation of hierarchical structures by nesting a

Dry-validation is a Ruby library designed for defining type-safe schemas and complex validation rules to verify and sanitize input data structures. It provides a formal framework for constructing modular validation logic, ensuring that incoming information meets specific business requirements and data formats before it is processed by an application. The library utilizes a domain-specific language to declare validation rules, which are then parsed into executable objects. It distinguishes itself through a macro-driven system that bundles common validation logic into reusable shortcuts, alongs

ozzo-validation is a programmable data validation library for Go that verifies structs, maps, and primitive types using a declarative, rule-based approach. It functions as an interface-based validator, allowing for the recursive checking of nested data structures and custom types without the use of struct tags. The framework distinguishes itself as a context-aware validation engine, supporting the propagation of request-scoped data to rules that depend on external state. It provides extensive extensibility through custom rule definitions and the ability to override default failure text with l

This project is a Python implementation of the JSON Schema specification, providing a library for verifying that data instances conform to defined schemas. It serves as a data validation framework capable of validating both the data itself and the schemas against official meta-schemas to ensure structural correctness. The library features a schema reference resolver that maps URIs to definitions, enabling the resolution of internal and remote references for modular schema management. It is designed for extensibility, allowing for the definition of custom keywords, custom type-checking logic,

Eve is a REST API framework that maps database collections to web resources through declarative configuration files. It functions as a database-to-API mapper, automatically exposing data as RESTful endpoints with built-in support for CRUD operations and schema-based request validation. The project distinguishes itself through a HATEOAS API engine that generates hypermedia links and resource schemas for dynamic client discovery. It also includes an automated Swagger documentation generator that produces interactive specifications for client SDK generation and testing. The framework provides a

Pydantic is a data validation library and parsing framework for Python. It functions as a type-based schema validator that uses standard Python type annotations to ensure input data conforms to predefined structural schemas. The project provides capabilities for parsing raw data into typed objects through automatic type conversion and validation. This includes the serialization of data and the validation of data structures to enforce correctness. The framework covers several application areas, including the verification of API requests and the management of application configurations. It all

TypeBox is a JSON schema generator and TypeScript data validator. It functions as a type builder that creates compliant JSON schema definitions while providing a mechanism for synchronizing runtime validation logic with compile-time types. The project allows for the automatic derivation of static TypeScript interfaces from schema definitions to eliminate redundant type declarations. It converts complex type constructs into schema fragments and resolves static types to maintain consistency between data shapes and code. The system covers runtime type checking and data validation through the us

async-validator is a JavaScript schema validation library and asynchronous data validation engine. It verifies complex object structures and nested arrays by applying recursive rules and non-blocking, promise-based execution to ensure data integrity. The library functions as both an object constraint validator and a data transformation pipeline. It allows for the sanitization, coercion, and formatting of input values through a sequence of functions that run before and after the primary validation process. The engine covers a range of capabilities including recursive nested validation, the en

This project is a Java library designed to validate JSON documents against defined schema specifications. It functions as a standards-compliant engine that ensures data integrity by checking structural compliance and enforcing business rules within Java applications. The library distinguishes itself through its flexible validation strategies, allowing developers to inject custom logic and pattern-matching engines to handle specialized data formats. It supports configurable execution modes, enabling users to either halt validation immediately upon the first error or collect all violations for

JSON Editor is a schema-driven UI framework and web-based editor used to generate interactive forms and validate JSON data. It translates JSON Schema specifications into a hierarchy of HTML form elements, allowing users to manipulate complex JSON structures through a structured interface rather than raw text. The framework differentiates itself through a plugin-based extension system that supports custom resolver functions and the integration of specialized editors, such as WYSIWYG, Markdown, and syntax-highlighted code editors. It employs recursive schema resolution to handle nested definiti

This project is a JSON Schema validation library and framework used to verify that data instances conform to declarative definitions. It functions as a validation engine that enforces structural constraints and data types, while also serving as a meta-validator to ensure schema definitions themselves are syntactically correct against official meta-schemas. The library is designed for extensibility, allowing users to define custom validation logic by mapping schema keywords to specialized callable functions. It includes a registry-based reference resolver for managing internal and external URI

Grav is a flat-file content management system that eliminates the need for a traditional database by storing site content and configuration in human-readable Markdown and YAML files. Built as a modular PHP web framework, it uses a hierarchical page routing system where the physical directory structure directly determines the site's URL paths. The platform is distinguished by its event-driven plugin architecture and a command-line interface that prioritizes system administration, deployment, and maintenance tasks. It utilizes a blueprint-driven system to generate administrative forms from stru

Virtus is a Ruby attribute management and data coercion library used to define object schemas with typed attributes. It functions as a tool for transforming nested JSON structures and complex input formats into structured internal Ruby data types. The project provides a framework for creating value objects that are compared by their attribute values rather than memory identity. It allows for the mapping of complex external data into domain objects and supports the implementation of custom coercion logic to ensure data consistency. The library covers data modeling through schema-driven attrib

Snowplow is a behavioral event data pipeline and customer data infrastructure designed to capture user interactions and transform them into structured events for real-time analysis and long-term storage. It functions as a customer data platform that gathers user signals and enriches them with metadata to create a unified view of customer behavior. The system operates as an event schema validation engine to enforce strict data contracts on incoming streams, preventing data corruption. It further serves as a real-time event router and an event-driven automation platform, triggering proactive bu

Ecto is an Elixir database toolkit that maps database rows to Elixir structs and validates data changes through changesets before persistence. It provides a language-integrated query syntax for composing database queries, building them incrementally and securely with compile-time expansion into safe SQL. The toolkit connects to multiple database backends including PostgreSQL, MySQL, MSSQL, SQLite3, ClickHouse, and ETS through a pluggable adapter interface. It supports eager and lazy preloading of associated records to eliminate N+1 query problems, and can store nested data structures as embed

Arktype is a TypeScript runtime validation library and schema orchestrator. It synchronizes TypeScript types with runtime data validation, allowing users to define type-safe schemas that ensure unknown data adheres to specific structures during application execution. The project distinguishes itself by using set-theory type analysis to determine intersections and subtype compatibility, alongside JIT-compiled validation functions for optimized performance. It supports advanced type modeling through branded type constraints, recursive alias resolution, and the ability to generate runtime valida

This project is a general-purpose PHP utility library offering a collection of helper classes and functions for string manipulation, array and collection processing, data validation, filesystem operations, and image processing. It provides foundational toolkits designed to handle common development tasks through standardized APIs. The library is distinguished by specialized subsystems for programmatic HTML generation and secure element construction, runtime code reflection, and object-oriented utilities such as virtual property management and event callback triggers. It also includes cryptogr

CUE is a constraint-based configuration language designed for data validation, schema definition, and code generation. At its core, it unifies types and values into a single concept, enabling compile-time validation that catches structural and value errors before runtime. The language treats data and constraints as the same thing, allowing a single definition to serve as both a schema and concrete configuration data. CUE distinguishes itself through its constraint-based unification engine, which combines multiple configuration sources into a single coherent result by merging their constraints