Minimalistic validation library. Designed to be as little verbose as possible.

Usage no npm install needed!

<script type="module">
  import validateMini from '';



Minimalistic validation library. Designed to be as little verbose as possible.


Import the module

const { validate } = require("validate-mini");

Define a validation schema

const schema = {
    firstName: /[A-Z][a-z]{2,20}/,
    lastName: /[A-Z][a-z]{2,20}/,

Execute the validate() function, supplying your schema and the object to validate.

const validationResult = validate(schema, request.body);

The resulting object contains an isValid Boolean property. It indicates whether a validation error has been found or not, and messages for all properties that failed.

// No validation error
{ isValid: true }

// Validation errors
    isValid: false,
    firstName: "Invalid format",
    lastName: "Invalid format"

Supported validation rules

Specific String, Number or Boolean

To validate against specific String, Number or Boolean values:

const schema = {
    acceptTerms: true,
    verificationText: "I accept",
    rejectionCount: 0


To validate against a RegExp:

const schema = {
    age: /^[1-9]{1, 2}$/


For added flexibility, functions can be used for custom validation. Functions should either return a Boolean, or an object with an isValid Boolean property.

const moment = require("moment");

const schema = {
    dob: value => moment().diff(moment(value), "years") >= 18

Functions take at least one argument as parameter. This parameter represents the value of the corresponding property on the object to validate.

Checking against other properties

Functions can also take a second argument, representing the whole object being validated. This allows checking several properties in one function.

const schema = {
    password: /[A-Z]{8,24}/,
    confirmPassword: (value, input) => value === input.password,


To apply validation rules on Array items:

const schema = {
    aliases: [
        // use any rule you want: RegExp, func, etc


Rules can be combined to form complex objects:

const schema = {
    user: {
        name: /[A-Z][a-z]{2,20}/,
        id: /[a-f0-9]{8}/,
        options: {
            // ...


The library comes with a handful of built-in functions to help defining simple validation schemes.

To access the util functions:

const { validate, is, utils } = require("validate-mini");

const schema = {
    products: is.array,
    accept: is.boolean,
    amount: is.number,
    someObjecT: is.object,
    description: is.string,
    // Validate min and max length of Number value
    freeText: utils.length(0, 255),
    // List of acceptable values (enum like)
    status: utils.oneOf("success", "failure", "pending", "canceled"),
    // Validate min and max of Number value
    amount: utils.range(0, 100),

Note: When possible, avoid using, as it creates new functions on every call. Use the functions instead.

Optional properties

By default, all rules require matching input. To mark rules as optional, use the optional(<rule>) function together with any rule you like.

const { validate, optional, utils } = require("validate-mini");

const schema = {
    middleName: optional(

Chain several rules

Apply a sequence of rule using the pipe(<rules>) function:

const { validate, pipe } = require("validate-mini");

const schema = {
    password: pipe(/[A-Za-z]/, /[0-9]/, /.{8,255}/)