Zod vs Joi

At a Glance

Defining a Schema

import { z } from "zod";

const UserSchema = z.object({
  name: z.string().min(2),
  email: z.string().email(),
  age: z.number().int().min(18).optional(),
});

// Automatically infer TypeScript type:
type User = z.infer<typeof UserSchema>;
// { name: string; email: string; age?: number }

// Validate:
const user = UserSchema.parse(rawInput); // throws on invalid
const result = UserSchema.safeParse(rawInput); // no throw
if (result.success) {
  console.log(result.data.name); // fully typed
}

import Joi from "joi";

const UserSchema = Joi.object({
  name: Joi.string().min(2).required(),
  email: Joi.string().email().required(),
  age: Joi.number().integer().min(18),
});

// TypeScript type must be defined separately:
interface User {
  name: string;
  email: string;
  age?: number;
}

// Validate:
const { error, value } = UserSchema.validate(rawInput);
if (!error) {
  const user = value as User; // manual cast needed
}

TypeScript Integration: The Key Difference

With Joi, you define the schema and the TypeScript type separately. If you add a field to the schema and forget to update the interface (or vice versa), your runtime validation and compile-time types are out of sync. You won't notice until a bug surfaces in production.

With Zod, the schema is the type. One definition drives both. Use z.infer<typeof MySchema> wherever you need the TypeScript type, and they are always in sync by construction.

// Zod: schema = type. One source of truth.
const ProductSchema = z.object({
  id: z.string().uuid(),
  title: z.string(),
  price: z.number().positive(),
  tags: z.array(z.string()),
});

type Product = z.infer<typeof ProductSchema>;
// TypeScript knows exactly what Product looks like.
// Add a field to ProductSchema -> type updates automatically.

// Use in a function — fully typed:
function displayProduct(product: Product) {
  return `${product.title}: $${product.price}`;
}

Error Messages

// ZodError with issues array:
{
  issues: [
    {
      code: "too_small",
      minimum: 2,
      path: ["name"],
      message: "String must contain at
                least 2 character(s)"
    },
    {
      code: "invalid_string",
      validation: "email",
      path: ["email"],
      message: "Invalid email"
    }
  ]
}

// Flatten for form use:
const errors = schema.safeParse(data)
  .error?.flatten().fieldErrors;

// ValidationError with details array:
{
  details: [
    {
      message: '"name" length must be at
                least 2 characters long',
      path: ["name"],
      type: "string.min",
      context: { limit: 2, label: "name" }
    },
    {
      message: '"email" must be a valid
                email',
      path: ["email"],
      type: "string.email"
    }
  ]
}

// abortEarly: false to get all errors

Frequently Asked Questions