Zod
✨ <a href="https://zod.dev">https://zod.dev</a> ✨
<br/>
TypeScript-first schema validation with static type inference
Zod 3.23 is out! View the release notes.
These docs have been translated into Chinese.
Table of contents
- Sponsors- [Gold](#gold)
- [Silver](#silver)
- [Bronze](#bronze)- [Resources](#resources)
- [API libraries](#api-libraries)
- [Form integrations](#form-integrations)
- [Zod to X](#zod-to-x)
- [X to Zod](#x-to-zod)
- [Mocking](#mocking)
- [Powered by Zod](#powered-by-zod)
- [Utilities for Zod](#utilities-for-zod)npm (Node/Bun)
- From deno.land/x (Deno)
- Datetimes
- Dates
- Times
- IP addresses
- .shape
- .keyof
- .extend
- .merge
- .pick/.omit
- .partial
- .deepPartial
- .required
- .passthrough
- .strict
- .strip
- .catchall
- .element
- .nonempty
- .min/.max/.length
- Record key type
- ZodType with ZodEffects
- JSON type
- Cyclical objects
- .parse
- .parseAsync
- .safeParse
- .safeParseAsync
- .refine- [Arguments](#arguments)
- [Customize error path](#customize-error-path)
- [Asynchronous refinements](#asynchronous-refinements)
- [Relationship to transforms](#relationship-to-transforms).superRefine- [Abort early](#abort-early)
- [Type refinements](#type-refinements).transform- [Chaining order](#chaining-order)
- [Validating during transform](#validating-during-transform)
- [Relationship to refinements](#relationship-to-refinements)
- [Async transforms](#async-transforms).default
- .describe
- .catch
- .optional
- .nullable
- .nullish
- .array
- .promise
- .or
- .and
- .brand
- .readonly
- .pipe- [You can use `.pipe()` to fix common issues with `z.coerce`.](#you-can-use-pipe-to-fix-common-issues-with-zcoerce)- [Constraining allowable inputs](#constraining-allowable-inputs)Introduction
Zod is a TypeScript-first schema declaration and validation library. I'm using the term "schema" to broadly refer to any data type, from a simplestring to a complex nested object.Zod is designed to be as developer-friendly as possible. The goal is to eliminate duplicative type declarations. With Zod, you declare a validator once and Zod will automatically infer the static TypeScript type. It's easy to compose simpler types into complex data structures.
Some other great aspects:
- Zero dependencies
- Works in Node.js and all modern browsers
- Tiny: 8kb minified + zipped
- Immutable: methods (e.g.
.optional()) return a new instance - Concise, chainable interface
- Functional approach: parse, don't validate
- Works with plain JavaScript too! You don't need to use TypeScript.
Sponsors
Sponsorship at any level is appreciated and encouraged. For individual developers, consider the Cup of Coffee tier. If you built a paid product using Zod, consider one of the podium tiers.Gold
Silver
Bronze
Ecosystem
There are a growing number of tools that are built atop or support Zod natively! If you've built a tool or library on top of Zod, tell me about it on Twitter or start a Discussion. I'll add it below and tweet it out.Resources
- Total TypeScript Zod Tutorial by @mattpocockuk
- Fixing TypeScript's Blindspot: Runtime Typechecking by @jherr
API libraries
tRPC: Build end-to-end typesafe APIs without GraphQL.@anatine/zod-nestjs: Helper methods for using Zod in a NestJS project.zod-endpoints: Contract-first strictly typed endpoints with Zod. OpenAPI compatible.zhttp: An OpenAPI compatible, strictly typed http library with Zod input and response validation.domain-functions: Decouple your business logic from your framework using composable functions. With first-class type inference from end to end powered by Zod schemas.@zodios/core: A typescript API client with runtime and compile time validation backed by axios and zod.express-zod-api: Build Express-based APIs with I/O schema validation and custom middlewares.tapiduck: End-to-end typesafe JSON APIs with Zod and Express; a bit like tRPC, but simpler.koa-zod-router: Create typesafe routes in Koa with I/O validation using Zod.
Form integrations
react-hook-form: A first-party Zod resolver for React Hook Form.zod-validation-error: Generate user-friendly error messages fromZodErrors.zod-formik-adapter: A community-maintained Formik adapter for Zod.react-zorm: Standalone<form>generation and validation for React using Zod.zodix: Zod utilities for FormData and URLSearchParams in Remix loaders and actions.conform: A typesafe form validation library for progressive enhancement of HTML forms. Works with Remix and Next.js.remix-params-helper: Simplify integration of Zod with standard URLSearchParams and FormData for Remix apps.formik-validator-zod: Formik-compliant validator library that simplifies using Zod with Formik.zod-i18n-map: Useful for translating Zod error messages.@modular-forms/solid: Modular form library for SolidJS that supports Zod for validation.houseform: A React form library that uses Zod for validation.sveltekit-superforms: Supercharged form library for SvelteKit with Zod validation.mobx-zod-form: Data-first form builder based on MobX & Zod.@vee-validate/zod: Form library for Vue.js with Zod schema validation.
Zod to X
zod-to-ts: Generate TypeScript definitions from Zod schemas.zod-to-json-schema: Convert your Zod schemas into JSON Schemas.@anatine/zod-openapi: Converts a Zod schema to an OpenAPI v3.xSchemaObject.zod-fast-check: Generatefast-checkarbitraries from Zod schemas.zod-dto: Generate Nest.js DTOs from a Zod schema.fastify-type-provider-zod: Create Fastify type providers from Zod schemas.zod-to-openapi: Generate full OpenAPI (Swagger) docs from Zod, including schemas, endpoints & parameters.nestjs-graphql-zod: Generates NestJS GraphQL model classes from Zod schemas. Provides GraphQL method decorators working with Zod schemas.zod-openapi: Create full OpenAPI v3.x documentation from Zod schemas.fastify-zod-openapi: Fastify type provider, validation, serialization and @fastify/swagger support for Zod schemas.typeschema: Universal adapter for schema validation.
X to Zod
ts-to-zod: Convert TypeScript definitions into Zod schemas.@runtyping/zod: Generate Zod from static types & JSON schema.json-schema-to-zod: Convert your JSON Schemas into Zod schemas. Live demo.json-to-zod: Convert JSON objects into Zod schemas. Live demo.graphql-codegen-typescript-validation-schema: GraphQL Code Generator plugin to generate form validation schema from your GraphQL schema.zod-prisma: Generate Zod schemas from your Prisma schema.Supervillain: Generate Zod schemas from your Go structs.prisma-zod-generator: Emit Zod schemas from your Prisma schema.prisma-trpc-generator: Emit fully implemented tRPC routers and their validation schemas using Zod.zod-prisma-typesCreate Zod types from your Prisma models.quicktype: Convert JSON objects and JSON schemas into Zod schemas.@sanity-typed/zod: Generate Zod Schemas from Sanity Schemas.java-to-zod: Convert POJOs to Zod schemasOrval: Generate Zod schemas from OpenAPI schemas
Mocking
@anatine/zod-mock: Generate mock data from a Zod schema. Powered by faker.js.zod-mocking: Generate mock data from your Zod schemas.zod-fixture: Use your zod schemas to automate the generation of non-relevant test fixtures in a deterministic way.zocker: Generate plausible mock-data from your schemas.zodockGenerate mock data based on Zod schemas.
Powered by Zod
freerstore: Firestore cost optimizer.slonik: Node.js Postgres client with strong Zod integration.soly: Create CLI applications with zod.pastel: Create CLI applications with react, zod, and ink.zod-xlsx: A xlsx based resource validator using Zod schemas.znv: Type-safe environment parsing and validation for Node.js with Zod schemas.zod-config: Load configurations across multiple sources with flexible adapters, ensuring type safety with Zod.
Utilities for Zod
zod_utilz: Framework agnostic utilities for Zod.zod-sandbox: Controlled environment for testing zod schemas. Live demo.zod-dev: Conditionally disables Zod runtime parsing in production.zod-accelerator: Accelerates Zod's throughput up to ~100x.
Installation
Requirements
- TypeScript 4.5+!
- You must enable
strictmode in yourtsconfig.json. This is a best practice for all TypeScript projects.
```ts // tsconfig.json {
// ...
"compilerOptions": {
// ...
"strict": true
}From npm (Node/Bun)
npm install zod # npm
yarn add zod # yarn
bun add zod # bun
pnpm add zod # pnpmZod also publishes a canary version on every commit. To install the canary:
npm install zod@canary # npm
yarn add zod@canary # yarn
bun add zod@canary # bun
pnpm add zod@canary # pnpmFrom deno.land/x (Deno)
Unlike Node, Deno relies on direct URL imports instead of a package manager like NPM. Zod is available on deno.land/x. The latest version can be imported like so:import { z } from "https://deno.land/x/zod/mod.ts";You can also specify a particular version:
import { z } from "https://deno.land/x/zod@v3.16.1/mod.ts";The rest of this README assumes you are using npm and importing directly from the "zod" package.Basic usage
Creating a simple string schemaimport { z } from "zod";
// creating a schema for strings
const mySchema = z.string();
// parsing
mySchema.parse("tuna"); // => "tuna"
mySchema.parse(12); // => throws ZodError
// "safe" parsing (doesn't throw error if validation fails)
mySchema.safeParse("tuna"); // => { success: true; data: "tuna" }
mySchema.safeParse(12); // => { success: false; error: ZodError }Creating an object schema
import { z } from "zod";
const User = z.object({
username: z.string(),
});
User.parse({ username: "Ludwig" });
// extract the inferred type
type User = z.infer<typeof User>;
// { username: string }Primitives
import { z } from "zod";
// primitive values
z.string();
z.number();
z.bigint();
z.boolean();
z.date();
z.symbol();
// empty types
z.undefined();
z.null();
z.void(); // accepts undefined
// catch-all types
// allows any value
z.any();
z.unknown();
// never type
// allows no values
z.never();Coercion for primitives
Zod now provides a more convenient way to coerce primitive values.const schema = z.coerce.string();
schema.parse("tuna"); // => "tuna"
schema.parse(12); // => "12"During the parsing step, the input is passed through the
String() function, which is a JavaScript built-in for coercing data into strings.schema.parse(12); // => "12"
schema.parse(true); // => "true"
schema.parse(undefined); // => "undefined"
schema.parse(null); // => "null"The returned schema is a normal
ZodString instance so you can use all string methods.z.coerce.string().email().min(5);How coercion works
All primitive types support coercion. Zod coerces all inputs using the built-in constructors:
String(input), Number(input), new Date(input), etc.z.coerce.string(); // String(input)
z.coerce.number(); // Number(input)
z.coerce.boolean(); // Boolean(input)
z.coerce.bigint(); // BigInt(input)
z.coerce.date(); // new Date(input)Note — Boolean coercion with
z.coerce.boolean() may not work how you expect. Any truthy value is coerced to true, and any falsy value is coerced to false.const schema = z.coerce.boolean(); // Boolean(input)
schema.parse("tuna"); // => true
schema.parse("true"); // => true
schema.parse("false"); // => true
schema.parse(1); // => true
schema.parse([]); // => true
schema.parse(0); // => false
schema.parse(""); // => false
schema.parse(undefined); // => false
schema.parse(null); // => falseFor more control over coercion logic, consider using
z.preprocess or z.pipe().Literals
Literal schemas represent a literal type, like"hello world" or 5.const tuna = z.literal("tuna");
const twelve = z.literal(12);
const twobig = z.literal(2n); // bigint literal
const tru = z.literal(true);
const terrificSymbol = Symbol("terrific");
const terrific = z.literal(terrificSymbol);
// retrieve literal value
tuna.value; // "tuna"Currently there is no support for Date literals in Zod. If you have a use case for this feature, please file an issue.
Strings
Zod includes a handful of string-specific validations.// validations
z.string().max(5);
z.string().min(5);
z.string().length(5);
z.string().email();
z.string().url();
z.string().emoji();
z.string().uuid();
z.string().nanoid();
z.string().cuid();
z.string().cuid2();
z.string().ulid();
z.string().regex(regex);
z.string().includes(string);
z.string().startsWith(string);
z.string().endsWith(string);
z.string().datetime(); // ISO 8601; by default only `Z` timezone allowed
z.string().ip(); // defaults to allow both IPv4 and IPv6
// transforms
z.string().trim(); // trim whitespace
z.string().toLowerCase(); // toLowerCase
z.string().toUpperCase(); // toUpperCase
// added in Zod 3.23
z.string().date(); // ISO date format (YYYY-MM-DD)
z.string().time(); // ISO time format (HH:mm:ss[.SSSSSS])
z.string().duration(); // ISO 8601 duration
z.string().base64();Check out validator.js for a bunch of other useful string validation functions that can be used in conjunction with Refinements.
You can customize some common error messages when creating a string schema.
const name = z.string({
required_error: "Name is required",
invalid_type_error: "Name must be a string",
});When using validation methods, you can pass in an additional argument to provide a custom error message.
z.string().min(5, { message: "Must be 5 or more characters long" });
z.string().max(5, { message: "Must be 5 or fewer characters long" });
z.string().length(5, { message: "Must be exactly 5 characters long" });
z.string().email({ message: "Invalid email address" });
z.string().url({ message: "Invalid url" });
z.string().emoji({ message: "Contains non-emoji characters" });
z.string().uuid({ message: "Invalid UUID" });
z.string().includes("tuna", { message: "Must include tuna" });
z.string().startsWith("https://", { message: "Must provide secure URL" });
z.string().endsWith(".com", { message: "Only .com domains allowed" });
z.string().datetime({ message: "Invalid datetime string! Must be UTC." });
z.string().date({ message: "Invalid date string!" });
z.string().time({ message: "Invalid time string!" });
z.string().ip({ message: "Invalid IP address" });Datetimes
As you may have noticed, Zod string includes a few date/time related validations. These validations are regular expression based, so they are not as strict as a full date/time library. However, they are very convenient for validating user input.The
z.string().datetime() method enforces ISO 8601; default is no timezone offsets and arbitrary sub-second decimal precision.const datetime = z.string().datetime();
datetime.parse("2020-01-01T00:00:00Z"); // pass
datetime.parse("2020-01-01T00:00:00.123Z"); // pass
datetime.parse("2020-01-01T00:00:00.123456Z"); // pass (arbitrary precision)
datetime.parse("2020-01-01T00:00:00+02:00"); // fail (no offsets allowed)Timezone offsets can be allowed by setting the
offset option to true.const datetime = z.string().datetime({ offset: true });
datetime.parse("2020-01-01T00:00:00+02:00"); // pass
datetime.parse("2020-01-01T00:00:00.123+02:00"); // pass (millis optional)
datetime.parse("2020-01-01T00:00:00.123+0200"); // pass (millis optional)
datetime.parse("2020-01-01T00:00:00.123+02"); // pass (only offset hours)
datetime.parse("2020-01-01T00:00:00Z"); // pass (Z still supported)You can additionally constrain the allowable
precision. By default, arbitrary sub-second precision is supported (but optional).const datetime = z.string().datetime({ precision: 3 });
datetime.parse("2020-01-01T00:00:00.123Z"); // pass
datetime.parse("2020-01-01T00:00:00Z"); // fail
datetime.parse("2020-01-01T00:00:00.123456Z"); // failDates
Added in Zod 3.23
The
z.string().date() method validates strings in the format YYYY-MM-DD.const date = z.string().date();
date.parse("2020-01-01"); // pass
date.parse("2020-1-1"); // fail
date.parse("2020-01-32"); // failTimes
Added in Zod 3.23
The
z.string().time() method validates strings in the format HH:MM:SS[.s+]. The second can include arbitrary decimal precision. It does not allow timezone offsets of any kind.const time = z.string().time();
time.parse("00:00:00"); // pass
time.parse("09:52:31"); // pass
time.parse("23:59:59.9999999"); // pass (arbitrary precision)
time.parse("00:00:00.123Z"); // fail (no `Z` allowed)
time.parse("00:00:00.123+02:00"); // fail (no offsets allowed)You can set the
precision option to constrain the allowable decimal precision.const time = z.string().time({ precision: 3 });
time.parse("00:00:00.123"); // pass
time.parse("00:00:00.123456"); // fail
time.parse("00:00:00"); // failIP addresses
Thez.string().ip() method by default validate IPv4 and IPv6.const ip = z.string().ip();
ip.parse("192.168.1.1"); // pass
ip.parse("84d5:51a0:9114:1855:4cfa:f2d7:1f12:7003"); // pass
ip.parse("84d5:51a0:9114:1855:4cfa:f2d7:1f12:192.168.1.1"); // pass
ip.parse("256.1.1.1"); // fail
ip.parse("84d5:51a0:9114:gggg:4cfa:f2d7:1f12:7003"); // failYou can additionally set the IP
version.const ipv4 = z.string().ip({ version: "v4" });
ipv4.parse("84d5:51a0:9114:1855:4cfa:f2d7:1f12:7003"); // fail
const ipv6 = z.string().ip({ version: "v6" });
ipv6.parse("192.168.1.1"); // failNumbers
You can customize certain error messages when creating a number schema.const age = z.number({
required_error: "Age is required",
invalid_type_error: "Age must be a number",
});Zod includes a handful of number-specific validations.
z.number().gt(5);
z.number().gte(5); // alias .min(5)
z.number().lt(5);
z.number().lte(5); // alias .max(5)
z.number().int(); // value must be an integer
z.number().positive(); // > 0
z.number().nonnegative(); // >= 0
z.number().negative(); // < 0
z.number().nonpositive(); // <= 0
z.number().multipleOf(5); // Evenly divisible by 5. Alias .step(5)
z.number().finite(); // value must be finite, not Infinity or -Infinity
z.number().safe(); // value must be between Number.MIN_SAFE_INTEGER and Number.MAX_SAFE_INTEGEROptionally, you can pass in a second argument to provide a custom error message.
z.number().lte(5, { message: "this👏is👏too👏big" });BigInts
Zod includes a handful of bigint-specific validations.z.bigint().gt(5n);
z.bigint().gte(5n); // alias `.min(5n)`
z.bigint().lt(5n);
z.bigint().lte(5n); // alias `.max(5n)`
z.bigint().positive(); // > 0n
z.bigint().nonnegative(); // >= 0n
z.bigint().negative(); // < 0n
z.bigint().nonpositive(); // <= 0n
z.bigint().multipleOf(5n); // Evenly divisible by 5n.NaNs
You can customize certain error messages when creating a nan schema.const isNaN = z.nan({
required_error: "isNaN is required",
invalid_type_error: "isNaN must be 'not a number'",
});Booleans
You can customize certain error messages when creating a boolean schema.const isActive = z.boolean({
required_error: "isActive is required",
invalid_type_error: "isActive must be a boolean",
});Dates
Use z.date() to validateDate instances.z.date().safeParse(new Date()); // success: true
z.date().safeParse("2022-01-12T00:00:00.000Z"); // success: falseYou can customize certain error messages when creating a date schema.
const myDateSchema = z.date({
required_error: "Please select a date and time",
invalid_type_error: "That's not a date!",
});Zod provides a handful of date-specific validations.
z.date().min(new Date("1900-01-01"), { message: "Too old" });
z.date().max(new Date(), { message: "Too young!" });Coercion to Date
Since zod 3.20, use
z.coerce.date() to pass the input through new Date(input).const dateSchema = z.coerce.date();
type DateSchema = z.infer<typeof dateSchema>;
// type DateSchema = Date
/* valid dates */
console.log(dateSchema.safeParse("2023-01-10T00:00:00.000Z").success); // true
console.log(dateSchema.safeParse("2023-01-10").success); // true
console.log(dateSchema.safeParse("1/10/23").success); // true
console.log(dateSchema.safeParse(new Date("1/10/23")).success); // true
/* invalid dates */
console.log(dateSchema.safeParse("2023-13-10").success); // false
console.log(dateSchema.safeParse("0000-00-00").success); // falseFor older zod versions, use
z.preprocess like described in this thread.Zod enums
const FishEnum = z.enum(["Salmon", "Tuna", "Trout"]);
type FishEnum = z.infer<typeof FishEnum>;
// 'Salmon' | 'Tuna' | 'Trout'z.enum is a Zod-native way to declare a schema with a fixed set of allowable string values. Pass the array of values directly into z.enum(). Alternatively, use as const to define your enum values as a tuple of strings. See the const assertion docs for details.const VALUES = ["Salmon", "Tuna", "Trout"] as const;
const FishEnum = z.enum(VALUES);This is not allowed, since Zod isn't able to infer the exact values of each element.
const fish = ["Salmon", "Tuna", "Trout"];
const FishEnum = z.enum(fish);.enumTo get autocompletion with a Zod enum, use the
.enum property of your schema:FishEnum.enum.Salmon; // => autocompletes
FishEnum.enum;
/*
=> {
Salmon: "Salmon",
Tuna: "Tuna",
Trout: "Trout",
}
*/You can also retrieve the list of options as a tuple with the
.options property:FishEnum.options; // ["Salmon", "Tuna", "Trout"];.exclude/.extract()You can create subsets of a Zod enum with the
.exclude and .extract methods.const FishEnum = z.enum(["Salmon", "Tuna", "Trout"]);
const SalmonAndTrout = FishEnum.extract(["Salmon", "Trout"]);
const TunaOnly = FishEnum.exclude(["Salmon", "Trout"]);Native enums
Zod enums are the recommended approach to defining and validating enums. But if you need to validate against an enum from a third-party library (or you don't want to rewrite your existing enums) you can usez.nativeEnum().Numeric enums
enum Fruits {
Apple,
Banana,
}
const FruitEnum = z.nativeEnum(Fruits);
type FruitEnum = z.infer<typeof FruitEnum>; // Fruits
FruitEnum.parse(Fruits.Apple); // passes
FruitEnum.parse(Fruits.Banana); // passes
FruitEnum.parse(0); // passes
FruitEnum.parse(1); // passes
FruitEnum.parse(3); // failsString enums
enum Fruits {
Apple = "apple",
Banana = "banana",
Cantaloupe, // you can mix numerical and string enums
}
const FruitEnum = z.nativeEnum(Fruits);
type FruitEnum = z.infer<typeof FruitEnum>; // Fruits
FruitEnum.parse(Fruits.Apple); // passes
FruitEnum.parse(Fruits.Cantaloupe); // passes
FruitEnum.parse("apple"); // passes
FruitEnum.parse("banana"); // passes
FruitEnum.parse(0); // passes
FruitEnum.parse("Cantaloupe"); // failsConst enums
The
.nativeEnum() function works for as const objects as well. ⚠️ as const requires TypeScript 3.4+!const Fruits = {
Apple: "apple",
Banana: "banana",
Cantaloupe: 3,
} as const;
const FruitEnum = z.nativeEnum(Fruits);
type FruitEnum = z.infer<typeof FruitEnum>; // "apple" | "banana" | 3
FruitEnum.parse("apple"); // passes
FruitEnum.parse("banana"); // passes
FruitEnum.parse(3); // passes
FruitEnum.parse("Cantaloupe"); // failsYou can access the underlying object with the
.enum property:FruitEnum.enum.Apple; // "apple"Optionals
You can make any schema optional withz.optional(). This wraps the schema in a ZodOptional instance and returns the result.const schema = z.optional(z.string());
schema.parse(undefined); // => returns undefined
type A = z.infer<typeof schema>; // string | undefinedFor convenience, you can also call the
.optional() method on an existing schema.const user = z.object({
username: z.string().optional(),
});
type C = z.infer<typeof user>; // { username?: string | undefined };You can extract the wrapped schema from a
ZodOptional instance with .unwrap().const stringSchema = z.string();
const optionalString = stringSchema.optional();
optionalString.unwrap() === stringSchema; // trueNullables
Similarly, you can create nullable types withz.nullable().const nullableString = z.nullable(z.string());
nullableString.parse("asdf"); // => "asdf"
nullableString.parse(null); // => nullOr use the
.nullable() method.const E = z.string().nullable(); // equivalent to nullableString
type E = z.infer<typeof E>; // string | nullExtract the inner schema with
.unwrap().const stringSchema = z.string();
const nullableString = stringSchema.nullable();
nullableString.unwrap() === stringSchema; // trueObjects
// all properties are required by default
const Dog = z.object({
name: z.string(),
age: z.number(),
});
// extract the inferred type like this
type Dog = z.infer<typeof Dog>;
// equivalent to:
type Dog = {
name: string;
age: number;
};.shape
Use .shape to access the schemas for a particular key.Dog.shape.name; // => string schema
Dog.shape.age; // => number schema.keyof
Use .keyof to create a ZodEnum schema from the keys of an object schema.const keySchema = Dog.keyof();
keySchema; // ZodEnum<["name", "age"]>.extend
You can add additional fields to an object schema with the .extend method.const DogWithBreed = Dog.extend({
breed: z.string(),
});You can use
.extend to overwrite fields! Be careful with this power!.merge
Equivalent to A.extend(B.shape).const BaseTeacher = z.object({ students: z.array(z.string()) });
const HasID = z.object({ id: z.string() });
const Teacher = BaseTeacher.merge(HasID);
type Teacher = z.infer<typeof Teacher>; // => { students: string[], id: string }If the two schemas share keys, the properties of B overrides the property of A. The returned schema also inherits the "unknownKeys" policy (strip/strict/passthrough) and the catchall schema of B.
.pick/.omit
Inspired by TypeScript's built-in Pick and Omit utility types, all Zod object schemas have .pick and .omit methods that return a modified version. Consider this Recipe schema:const Recipe = z.object({
id: z.string(),
name: z.string(),
ingredients: z.array(z.string()),
});To only keep certain keys, use
.pick .const JustTheName = Recipe.pick({ name: true });
type JustTheName = z.infer<typeof JustTheName>;
// => { name: string }To remove certain keys, use
.omit .const NoIDRecipe = Recipe.omit({ id: true });
type NoIDRecipe = z.infer<typeof NoIDRecipe>;
// => { name: string, ingredients: string[] }.partial
Inspired by the built-in TypeScript utility type Partial, the .partial method makes all properties optional.Starting from this object:
const user = z.object({
email: z.string(),
username: z.string(),
});
// { email: string; username: string }We can create a partial version:
const partialUser = user.partial();
// { email?: string | undefined; username?: string | undefined }You can also specify which properties to make optional:
const optionalEmail = user.partial({
email: true,
});
/*
{
email?: string | undefined;
username: string
}
*/.deepPartial
The .partial method is shallow — it only applies one level deep. There is also a "deep" version:const user = z.object({
username: z.string(),
location: z.object({
latitude: z.number(),
longitude: z.number(),
}),
strings: z.array(z.object({ value: z.string() })),
});
const deepPartialUser = user.deepPartial();
/*
{
username?: string | undefined,
location?: {
latitude?: number | undefined;
longitude?: number | undefined;
} | undefined,
strings?: { value?: string}[]
}
*/Important limitation: deep partials only work as expected in hierarchies of objects, arrays, and tuples.
.required
Contrary to the .partial method, the .required method makes all properties required.Starting from this object:
const user = z
.object({
email: z.string(),
username: z.string(),
})
.partial();
// { email?: string | undefined; username?: string | undefined }We can create a required version:
const requiredUser = user.required();
// { email: string; username: string }You can also specify which properties to make required:
const requiredEmail = user.required({
email: true,
});
/*
{
email: string;
username?: string | undefined;
}
*/.passthrough
By default Zod object schemas strip out unrecognized keys during parsing.const person = z.object({
name: z.string(),
});
person.parse({
name: "bob dylan",
extraKey: 61,
});
// => { name: "bob dylan" }
// extraKey has been strippedInstead, if you want to pass through unknown keys, use
.passthrough() .person.passthrough().parse({
name: "bob dylan",
extraKey: 61,
});
// => { name: "bob dylan", extraKey: 61 }.strict
By default Zod object schemas strip out unrecognized keys during parsing. You can disallow unknown keys with .strict() . If there are any unknown keys in the input, Zod will throw an error.const person = z
.object({
name: z.string(),
})
.strict();
person.parse({
name: "bob dylan",
extraKey: 61,
});
// => throws ZodError.strip
You can use the .strip method to reset an object schema to the default behavior (stripping unrecognized keys)..catchall
You can pass a "catchall" schema into an object schema. All unknown keys will be validated against it.const person = z
.object({
name: z.string(),
})
.catchall(z.number());
person.parse({
name: "bob dylan",
validExtraKey: 61, // works fine
});
person.parse({
name: "bob dylan",
validExtraKey: false, // fails
});
// => throws ZodErrorUsing
.catchall() obviates .passthrough() , .strip() , or .strict(). All keys are now considered "known".Arrays
const stringArray = z.array(z.string());
// equivalent
const stringArray = z.string().array();Be careful with the
.array() method. It returns a new ZodArray instance. This means the order in which you call methods matters. For instance:z.string().optional().array(); // (string | undefined)[]
z.string().array().optional(); // string[] | undefined.element
Use .element to access the schema for an element of the array.stringArray.element; // => string schema.nonempty
If you want to ensure that an array contains at least one element, use .nonempty().const nonEmptyStrings = z.string().array().nonempty();
// the inferred type is now
// [string, ...string[]]
nonEmptyStrings.parse([]); // throws: "Array cannot be empty"
nonEmptyStrings.parse(["Ariana Grande"]); // passesYou can optionally specify a custom error message:
// optional custom error message
const nonEmptyStrings = z.string().array().nonempty({
message: "Can't be empty!",
});.min/.max/.length
z.string().array().min(5); // must contain 5 or more items
z.string().array().max(5); // must contain 5 or fewer items
z.string().array().length(5); // must contain 5 items exactlyUnlike
.nonempty() these methods do not change the inferred type.Tuples
Unlike arrays, tuples have a fixed number of elements and each element can have a different type.const athleteSchema = z.tuple([
z.string(), // name
z.number(), // jersey number
z.object({
pointsScored: z.number(),
}), // statistics
]);
type Athlete = z.infer<typeof athleteSchema>;
// type Athlete = [string, number, { pointsScored: number }]A variadic ("rest") argument can be added with the
.rest method.const variadicTuple = z.tuple([z.string()]).rest(z.number());
const result = variadicTuple.parse(["hello", 1, 2, 3]);
// => [string, ...number[]];Unions
Zod includes a built-inz.union method for composing "OR" types.const stringOrNumber = z.union([z.string(), z.number()]);
stringOrNumber.parse("foo"); // passes
stringOrNumber.parse(14); // passesZod will test the input against each of the "options" in order and return the first value that validates successfully.
For convenience, you can also use the
.or method:const stringOrNumber = z.string().or(z.number());Optional string validation:
To validate an optional form input, you can union the desired string validation with an empty string literal.
This example validates an input that is optional but needs to contain a valid URL:
const optionalUrl = z.union([z.string().url().nullish(), z.literal("")]);
console.log(optionalUrl.safeParse(undefined).success); // true
console.log(optionalUrl.safeParse(null).success); // true
console.log(optionalUrl.safeParse("").success); // true
console.log(optionalUrl.safeParse("https://zod.dev").success); // true
console.log(optionalUrl.safeParse("not a valid url").success); // falseDiscriminated unions
A discriminated union is a union of object schemas that all share a particular key.type MyUnion =
| { status: "success"; data: string }
| { status: "failed"; error: Error };Such unions can be represented with the
z.discriminatedUnion method. This enables faster evaluation, because Zod can check the discriminator key (status in the example above) to determine which schema should be used to parse the input. This makes parsing more efficient and lets Zod report friendlier errors.With the basic union method, the input is tested against each of the provided "options", and in the case of invalidity, issues for all the "options" are shown in the zod error. On the other hand, the discriminated union allows for selecting just one of the "options", testing against it, and showing only the issues related to this "option".
const myUnion = z.discriminatedUnion("status", [
z.object({ status: z.literal("success"), data: z.string() }),
z.object({ status: z.literal("failed"), error: z.instanceof(Error) }),
]);
myUnion.parse({ status: "success", data: "yippie ki yay" });You can extract a reference to the array of schemas with the
.options property.myUnion.options; // [ZodObject<...>, ZodObject<...>]To merge two or more discriminated unions, use
.options with destructuring.const A = z.discriminatedUnion("status", [
/* options */
]);
const B = z.discriminatedUnion("status", [
/* options */
]);
const AB = z.discriminatedUnion("status", [...A.options, ...B.options]);Records
Record schemas are used to validate types such asRecord<string, number>. This is particularly useful for storing or caching items by ID.Instanceof
You can usez.instanceof to check that the input is an instance of a class. This is useful to validate inputs against classes that are exported from third-party libraries.class Test {
name: string;
}
const TestSchema = z.instanceof(Test);
const blob: any = "whatever";
TestSchema.parse(new Test()); // passes
TestSchema.parse(blob); // throwsFunctions
Zod also lets you define "function schemas". This makes it easy to validate the inputs and outputs of a function without intermixing your validation code and "business logic".You can create a function schema with
z.function(args, returnType) .const myFunction = z.function();
type myFunction = z.infer<typeof myFunction>;
// => ()=>unknownDefine inputs and outputs.
```ts const myFunction = z .function() .args(z.st
