zod vs superstruct

validation

zod

superstruct

Zod and Superstruct are both TypeScript-first schema validation libraries that enable runtime type checking and static type inference. Zod has emerged as the more feature-rich option with extensive methods for schema manipulation, custom error handling, and ecosystem integrations, while Superstruct focuses on a minimal, functional API with exceptional bundle size efficiency. Both libraries solve the same fundamental problem—validating unknown data at runtime while maintaining type safety—but take distinctly different philosophical approaches.

This comparison matters because validation libraries are foundational infrastructure choices that affect bundle size, developer experience, and TypeScript compilation performance across your entire codebase. Zod targets developers building full-stack applications who need comprehensive validation features and strong community support, particularly those using modern frameworks like tRPC or TanStack. Superstruct appeals to developers prioritizing minimal client-side bundle impact, those working in performance-constrained environments, or teams preferring functional composition patterns over object-oriented APIs.

Head-to-Head

Bundle Size Impact→ superstruct wins

zod

Ships at 13.1-17.7 kB minified, roughly 5x larger than Superstruct. The extensive method surface (refinements, transforms, object manipulation) makes tree-shaking difficult, and the size increases significantly when using advanced features. Acceptable for server-side or large applications, but problematic for bundle-sensitive frontends.

superstruct

Exceptionally small at 3.2-3.4 kB minified with zero dependencies. The functional API and minimal feature set enable effective tree-shaking. Ideal for client-side validation where every kilobyte matters, especially in performance-constrained environments or when validation is a secondary concern.

TypeScript Compilation Performance→ superstruct wins

zod

Runtime validation is fast, but TypeScript type-checking degrades severely on complex schemas—often 10x+ slower after operations like .extend() or .omit(). Deep generic types strain the compiler, causing noticeable slowdowns in large codebases. Type inference is excellent when it works, but compile times suffer.

superstruct

Clean, performant TypeScript inference with no significant compiler performance issues. Simpler type representations don't strain the type checker even on complex schemas. Zero dependencies eliminate transitive type resolution overhead. Maintains fast compilation even in large projects.

API Ergonomics and Feature Richness→ zod wins

zod

Fluent, method-chaining API with extensive built-in methods (.partial(), .pick(), .omit(), .merge(), .extend()). Supports advanced features like recursive types, promise validation, discriminated unions, custom error maps, and schema transformations. Intuitive for complex schemas but can feel verbose for simple cases. Rich ecosystem integration.

superstruct

Functional, nested composition style that can feel awkward with excessive parentheses. Limited built-in schema manipulation—lacks convenient object methods like partial or merge. Union types require custom implementation. API is extensible through custom types but requires more manual work. Better suited for straightforward validation scenarios.

Community and Maintenance Activity→ zod wins

zod

Extremely active with 40k+ GitHub stars, 391 weekly mentions, and top 0.9% ecosystem growth. Frequent updates (latest within 11 days as of late 2025), active discussions on v4 features, extensive third-party integrations. Strong support for questions and issues. Well-positioned for long-term reliability.

superstruct

Small community with 7k stars and only 29 weekly mentions. Development has stagnated—last major activity over a year ago with rare author responses since 2020. Missing features (like proper union support) noted in 2022 remain unaddressed. Maintenance risk for production applications requiring ongoing support.

Runtime Validation Performancetie

zod

Fast runtime parsing suitable for production use. Performance is competitive with other validation libraries for typical use cases. The additional feature overhead is negligible at runtime—the bundle size cost is more significant than execution speed. Handles complex nested validations efficiently.

superstruct

Strong runtime performance (e.g., 18ms for complex validations). The minimal feature set translates to efficient execution. Lightweight footprint means less parsing overhead. Performance is excellent for both simple and moderately complex schemas, with no significant bottlenecks in typical usage.

Error Handling and Debugging→ zod wins

zod

Sophisticated error handling with custom error maps, detailed path information for nested errors, and the ability to customize messages per-field. Provides rich error metadata including union discrimination failures. Errors are structured and easily parseable for displaying user-friendly validation feedback.

superstruct

Basic structured errors with path information and failure details. Error messages are functional but less customizable than Zod. Lacks advanced features like custom error maps or fine-grained message control. Adequate for straightforward validation feedback but limited for complex UX requirements.

Verdict

Choose Zod for most modern application development, especially server-side validation, full-stack applications, or projects requiring comprehensive schema manipulation. Despite its TypeScript compilation performance issues and larger bundle size, the extensive feature set, active maintenance, and ecosystem integration (tRPC, TanStack Query, React Hook Form) make it the pragmatic default choice. The compilation slowdown is manageable in most projects, and the runtime performance is solid. The thriving community ensures bugs get fixed and new features arrive regularly, reducing long-term maintenance risk.

Choose Superstruct only when bundle size is absolutely critical—specifically for client-side validation in performance-constrained environments like mobile web applications or embedded widgets. Its 3.4 kB footprint is compelling when every kilobyte matters, and the TypeScript compilation performance is genuinely superior. However, you must accept the maintenance risk of a stagnant project and be prepared to implement missing features yourself. If your validation needs are simple and you value functional composition, Superstruct remains viable, but most teams will find Zod's active development and feature completeness worth the tradeoffs.

When to Use Each

If you are building a tRPC API or full-stack Next.js application → use Zod because it's the de facto standard in these ecosystems with first-class integration support, and server-side bundle size is irrelevant. If you are building a lightweight client-side widget or embeddable component → use Superstruct because the 3.4 kB bundle is 5x smaller than Zod, and you can't justify 17 kB for basic validation in a size-constrained context. If you are validating complex nested data with conditional logic and custom error messages → use Zod because it provides discriminated unions, custom error maps, and sophisticated schema manipulation that Superstruct lacks. If you are working on a project with slow TypeScript compilation and simple validation needs → use Superstruct because its clean type inference won't compound your existing compiler performance issues like Zod's deep generics will.

Learn More

zod →superstruct →

Head-to-Head

Bundle Size Impact→ superstruct wins

zod

superstruct

TypeScript Compilation Performance→ superstruct wins

zod

superstruct

API Ergonomics and Feature Richness→ zod wins

zod

superstruct

Community and Maintenance Activity→ zod wins

zod

superstruct

Runtime Validation Performancetie

zod

superstruct

Error Handling and Debugging→ zod wins

zod

superstruct

Verdict

When to Use Each