What is Zod? Type-Safe Validation for Modern Apps

What is Zod?

A TypeScript-first schema validation library. It gives you both compile-time type safety and trustworthy runtime checks. It provides a single validation language for API responses, forms and env variables.

• TypeScript-first schema validation
• Runtime type safety
• A type system you can trust

Why Zod?

Where Zod stands out among alternatives:

• Type-safe runtime validation
• Easy schema definition
• Helpful type inference (z.infer)
• Zero dependencies
• Active, fast-growing ecosystem

Installation

A single package — installed as a runtime dependency.

npm install zod

Basic Schema

Define a schema with z.object. For each field there are helpers like z.string(), z.number() and z.boolean().

import { z } from "zod";

const UserSchema = z.object({
  name: z.string(),
  age: z.number(),
  email: z.string().email(),
});

Parsing & Validation

schema.parse(data) validates data and throws on failure. On success it returns the type-safe value.

const data = UserSchema.parse({
  name: "Ada",
  age: 30,
  email: "ada@dev.com",
});
// data: { name: string; age: number; email: string }

Safe Parse (IMPORTANT)

safeParse returns { success, data | error } without throwing. Use it when you'd rather branch with if/else than try/catch.

const result = UserSchema.safeParse(input);

if (result.success) {
  console.log(result.data);
} else {
  console.error(result.error.format());
}

Type Inference (Key Feature)

z.infer<typeof Schema> derives the TypeScript type from your schema. The schema becomes the single source of truth — you don't need to write the type separately.

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

Advanced Validation

Chain rules on strings and numbers: min, max, regex, email, url, uuid, length…

z.string().min(3).max(20);
z.string().email();
z.string().regex(/^[a-z]+$/i);
z.number().int().positive();

Refinement (Custom Rules)

When the standard rules aren't enough, refine adds a custom check. superRefine and transform let you transform values and write cross-field rules.

z.string().refine((val) => val !== "test", {
  message: "Test value is not allowed",
});

Nested Schemas

Schemas can nest — objects inside objects, arrays of objects, etc. — and you can model anything cleanly.

const PostSchema = z.object({
  title: z.string(),
  author: z.object({
    name: z.string(),
    email: z.string().email(),
  }),
  tags: z.array(z.string()),
});

Use with React Hook Form (IMPORTANT)

Pass your Zod schema as a resolver via @hookform/resolvers/zod. RHF uses Zod for validation and infers types automatically.

import { zodResolver } from "@hookform/resolvers/zod";
import { useForm } from "react-hook-form";

const schema = z.object({
  email: z.string().email(),
  password: z.string().min(8),
});

const { register, handleSubmit } = useForm({
  resolver: zodResolver(schema),
});

Key Concepts

The pieces you'll keep reaching for:

• schema — z.object, z.string, z.number…
• parse / safeParse — runtime checks
• z.infer — derive types from a schema
• refine / superRefine — custom rules
• transform — transform values

Use Cases

Where Zod shows up most often:

• Form validation (RHF + Zod)
• API request/response parsing
• Environment variable validation
• tRPC and Zod-based SDKs
• Backend payload validation

Summary

Zod produces strong TypeScript types and trustworthy runtime validation from a single schema. Less unsafe code, no code generation, and a fit for almost every layer of a modern stack — forms, APIs, environment. Start with a single command and unify your validation layer.