Valid8

Form Validation Made Easy

Valid8 is a powerful, flexible form validation library for React applications. Build forms faster with less code and better user experience.

Simple, Powerful Validation

Valid8 provides a simple, intuitive API for validating forms. Write less code and get more done.

  • ✓
    Type-safe validation

    Built on TypeScript for complete type safety

  • ✓
    Framework agnostic

    Works with any UI framework or vanilla JavaScript

  • ✓
    Composable schemas

    Build complex validation logic from simple building blocks

import { v8 } from 'valid8';

// Define your validation schema
const userSchema = v8.object({
  name: v8.string()
    .min(2, "Name must be at least 2 characters")
    .max(50, "Name must be less than 50 characters"),
  email: v8.string()
    .email("Please enter a valid email address")
    .required("Email is required"),
  age: v8.number()
    .min(18, "You must be at least 18 years old")
    .optional(),
  password: v8.string()
    .min(8, "Password must be at least 8 characters")
    .matches(/[A-Z]/, "Password must contain an uppercase letter")
    .matches(/[a-z]/, "Password must contain a lowercase letter")
    .matches(/[0-9]/, "Password must contain a number"),
});

// Validate your data
const result = userSchema.validate(formData);

if (result.success) {
  // Data is valid, do something with it
  saveUser(result.data);
} else {
  // Handle validation errors
  displayErrors(result.errors);
}

Powerful Form Builder Components

Build complex forms with our intuitive drag-and-drop interface and pre-built components.

Input Fields
Text, number, email, password, and more
Selection Controls
Dropdowns, checkboxes, radio buttons
Advanced Elements
Date pickers, file uploads, sliders
Interactive Demo

Form Builder with Valid8

See how Valid8 powers complex form builders with hierarchical validation

Add Components

Form Settings

Personal Information
First Name
Required
Text Field
v8.string().required("First name is required")
Last Name
Required
Text Field
v8.string().required("Last name is required")
Email Address
Required
Email Field
v8.string().email("Invalid email address").required("Email is required")
Phone Number
Text Field
v8.string().pattern(/^[0-9]{10}$/, "Phone number must be 10 digits")
Address Information
Employment Details

Field Properties

Hierarchical Validation
Valid8's approach to nested form validation

Form Structure Visualization

Form
Section 1
Field 1
Section 2
Field 2
Field 3

Valid8 understands this hierarchical structure and allows you to:

  • Reference fields by path (e.g., section2.field3)
  • Apply validation rules at any level
  • Create dependencies between fields across sections
  • Validate relationships between sibling fields
Conditional Logic Visualization
How Valid8 handles complex form dependencies

Employment Status Example

Employment Status
Employed
Self-Employed
Unemployed
Student
Company Name
Condition: Required when Employment Status is "Employed" or "Self-Employed"
companyName: v8.string()
  .requiredWhen('employmentStatus', 
    status => ['employed', 'self-employed']
      .includes(status))
School Name
Condition: Required when Employment Status is "Student"
schoolName: v8.string()
  .requiredWhen('employmentStatus', 
    status => status === 'student')

Multi-field Dependencies

Field A
Field B
Field C
Target Field
targetField: v8.string()
  .requiredWhen(
    ['fieldA', 'fieldB', 'fieldC'],
    (valueA, valueB, valueC) => {
      // Complex conditional logic
      return valueA === 'yes' && 
        (valueB > 100 || valueC === 'special');
    }
  )
Form Builder Integration
How Valid8 powers no-code form builders

Dynamic Schema Building

Valid8 can generate validation schemas dynamically based on form builder configurations.

// Convert form builder config to Valid8 schema
function buildSchemaFromConfig(formConfig) {
  const schema = {};
  
  // Process each section
  formConfig.sections.forEach(section => {
    const sectionSchema = {};
    
    // Process each field in the section
    section.fields.forEach(field => {
      // Create base validator for the field type
      let validator;
      
      switch (field.type) {
        case 'text':
          validator = v8.string();
          break;
        case 'number':
          validator = v8.number();
          break;
        case 'email':
          validator = v8.string().email();
          break;
        case 'select':
          validator = v8.enum(field.options.map(o => o.value));
          break;
        default:
          validator = v8.any();
      }
      
      // Add required validation if needed
      if (field.required) {
        validator = validator.required(field.errorMessage);
      }
      
      // Add conditional logic if present
      if (field.conditions && field.conditions.length > 0) {
        field.conditions.forEach(condition => {
          const targetPath = condition.targetField;
          
          validator = validator.requiredWhen(
            targetPath,
            value => evaluateCondition(value, condition)
          );
        });
      }
      
      // Add the field validator to the section schema
      sectionSchema[field.name] = validator;
    });
    
    // Add the section schema to the main schema
    schema[section.name] = v8.object(sectionSchema);
  });
  
  return v8.object(schema);
}

Visual Builder to Schema

Form Builder UI
Personal Information
Section
Email Address
Email Field • Required
Age
Number Field • Min: 18
Generated Schema
const schema = v8.object({
  personalInformation: v8.object({
    emailAddress: v8.string()
      .email('Please enter a valid email')
      .required('Email is required'),
    age: v8.number()
      .min(18, 'Must be at least 18 years old')
  })
});

Advanced LLM-Powered Validation

Leverage the power of Large Language Models to validate complex inputs and provide intelligent feedback.

Intelligent Validation

Valid8's LLM integration allows you to validate complex inputs that traditional validation methods struggle with:

  • ✓
    Natural language inputs

    Validate that text inputs meet specific criteria or contain required information.

  • ✓
    Content moderation

    Automatically detect and filter inappropriate content in user submissions.

  • ✓
    Contextual validation

    Validate inputs based on the context of other form fields or application state.

LLM Validation Example
See how Valid8 provides intelligent feedback
A revolutionary smartphone with a 6.7-inch display, 12GB RAM, and 256GB storage.

Validation Feedback:

Your product description is missing important details:

  • • No mention of battery capacity
  • • Camera specifications are missing
  • • No information about the processor
// LLM Validation Schema
const productSchema = z.object({
  description: z.string().llmValidate({
    prompt: "Validate this product description includes all required specs",
    requiredElements: [
      "display", "memory", "storage", 
      "battery", "camera", "processor"
    ],
    feedback: true
  })
});

Ready to Simplify Your Form Validation?

Join thousands of developers who are building better forms with Valid8.