SponsorsTable of ContentsGetting StartedInstallationMigration guide
Usage
CoerceLiteralsStringsNumbersBigIntsNaNsBooleansDatesEnumsOptionalsNullablesObjectsArraysUnionsRecordsMapsSetsIntersectionsRecursive typesPromisesInstanceofFunctionsPreprocess
Schema methods
Custom schemas
Guides and Concepts
Error HandlingComparisonEcosystem
Contributing
ChangelogCode of ConductLICENSE
Links
Clerk
⌘+J

© 2025 Zod


Designed in Earth-616

Build by oeri

Getting Started

Zod

Introduction

Zod is a runtime schema validation library built with TypeScript-first principles. This guide is designed to help you integrate Zod into your development workflow, understand its core concepts, and start leveraging its powerful features for data validation and transformation. Whether you are building APIs, validating form inputs, or ensuring data integrity across your application, Zod provides a robust and intuitive solution.


"Empower your application with robust type safety and runtime validation—achieve cleaner, safer, and more maintainable code with minimal overhead."


What Zod can do:

  • Define Schemas: Easily declare schemas for your data structures using an expressive and intuitive API.
  • Validate Data: Ensure that incoming data conforms to the expected types and formats at runtime.
  • Transform Data: Automatically transform and sanitize data as it is validated.
  • Infer Types: Automatically infer TypeScript types from your schemas, reducing boilerplate and keeping your code DRY.
  • Custom Validations: Integrate custom refinement logic to enforce complex validation rules.
  • Compose Schemas: Combine and nest schemas to model deeply nested or composite data structures.

How Can Zod Help You?

Zod is a versatile tool that adapts to many common development scenarios:

  • Ensure Data Integrity: Validate external inputs such as API requests, responses, or form data to avoid runtime errors and security vulnerabilities.
  • Streamline Development: Eliminate the need for redundant type definitions by inferring types directly from schemas.
  • Enhance Developer Experience: Benefit from clear, descriptive error messages that make debugging validation issues simpler.
  • Boost Productivity: With its minimal API and powerful abstractions, Zod allows you to build complex validations without sacrificing code clarity or performance.
  • Facilitate Integration: Easily integrate with modern frameworks and libraries (e.g., Next.js, React Hook Form, tRPC) to provide seamless validation solutions.

Why Use Zod?

Zod distinguishes itself through its TypeScript-first approach and its focus on simplicity without compromising on power. Here are some compelling reasons to use Zod:

  • Type Safety at Its Core: By leveraging TypeScript, Zod ensures that your schemas and validations are type-safe both at compile-time and at runtime.
  • Lightweight & Fast: With zero external dependencies, Zod is optimized for performance, making it an ideal choice for both client-side and server-side applications.
  • Expressive & Flexible: The API is designed to be both simple to use and capable of handling even the most complex validation scenarios.
  • Rich Error Handling: Enjoy comprehensive error messages and detailed validation reports that help you quickly identify and fix issues.
  • Scalable: Whether you're building a small project or a large-scale application, Zod scales gracefully to meet your needs.

Core Features

  • Schema Definition: Define schemas for various data types including objects, arrays, primitives, unions, intersections, and more.

  • Safe Parsing: Use methods like parse and safeParse to validate data. While parse throws on invalid input, safeParse returns an object with success and error properties, allowing for more graceful error handling.

  • Refinements & Transformations: Add custom validation logic with refine and superRefine methods, and transform input data seamlessly as part of the validation process.

  • Default Values: Specify default values for schema fields, ensuring that your data always has the expected shape.

  • Asynchronous Validation: Perform asynchronous checks (e.g., database lookups, API calls) during validation without blocking the main thread.

  • Error Formatting: Receive detailed error output that is easy to interpret and use for debugging.

  • Composable Schemas: Build complex validations by composing simple, reusable schemas, allowing for modular and maintainable code.


Next Steps

  • Dive Deeper: Explore the API Reference for in-depth details on every function and method available in Zod.

  • Quick Start Tutorial: Follow the Quick Start Guide to build your first schema and see Zod in action.

  • Advanced Use Cases: Learn about integrating Zod with your favorite frameworks and handling advanced validation scenarios in our Advanced Topics section.

Contributing

Zod is an open-source project that thrives on community contributions. Whether you're reporting issues, suggesting features, or contributing code improvements, your input is valuable:

  • GitHub Repository: github.com/colinhacks/zod
  • Community Discussions: Zod Discussions
  • Contributing Guide: Check out our Contributing Guidelines for more information on how you can help make Zod even better.

On This Page

Getting started
Introduction
What zod can do
How can zod help you
Why use zod
Core features
Next steps
Contributing

Edit this page on GitHub