Ajv, Zod oder Yup: welche Validation-Library für dein Projekt?

Drei Library-Familien

Die drei Bibliotheken bedienen unterschiedliche Use-Cases:

Library	Schema-Format	Primäres Use-Case
Ajv	JSON Schema (Standard)	Backend, Cross-Language, höchste Performance
Zod	TypeScript-Code (Builder)	Frontend, TS-only-Apps, Type-Inference
Yup	JavaScript-Code (Builder)	Formik-Formulare, JS-only

Ajv - der Standard-konforme Workhorse

Ajv ist die schnellste JSON-Schema-Library für JavaScript. Über 90 % der npm-Pakete die JSON-Validation brauchen, nutzen Ajv unter der Haube (Fastify, AWS-SDK, viele OpenAPI-Tools).

import Ajv from 'ajv';
const ajv = new Ajv();
const validate = ajv.compile({
  type: 'object',
  required: ['email'],
  properties: { email: { type: 'string', format: 'email' } }
});
if (!validate(data)) console.log(validate.errors);

Stärken: Standard-konform (cross-language Schemas möglich), maximale Performance (kompiliert Schemas in JS-Code), riesige Plugin-Welt (ajv-formats, ajv-keywords, ajv-errors).

Schwächen: Keine TS-Type-Inference (Schema und Type doppelt schreiben oder generieren), Schema als JSON-String wirkt verbose im TS-Code.

Zod - der TypeScript-First-Liebling

Zod ist eine TS-Library mit Builder-API. Schemas werden in TypeScript-Code geschrieben, Types lassen sich daraus ableiten.

import { z } from 'zod';

const userSchema = z.object({
  email: z.string().email(),
  age: z.number().int().positive()
});

type User = z.infer<typeof userSchema>;

const parsed = userSchema.safeParse(data);
if (parsed.success) console.log(parsed.data);
else console.log(parsed.error.issues);

Stärken: Type-Inference (kein doppeltes Schreiben), exzellente DX in modernen TS-Stacks, gute Fehlermeldungen.

Schwächen: Nicht standardisiert - Schema-Definition lebt im TS-Code, kein direkter Export nach JSON Schema (es gibt zod-to-json-schema, hat aber Limitierungen), langsamer als Ajv.

Yup - der Formik-Begleiter

Yup nutzt ebenfalls eine Builder-API, ist aber älter und weniger TS-zentriert. Hat eine intuitive when()-Funktion für konditionelle Validation.

import * as yup from 'yup';

const schema = yup.object({
  email: yup.string().email().required(),
  age: yup.number().integer().positive(),
  newsletter: yup.boolean(),
  newsletterEmail: yup.string().when('newsletter', {
    is: true,
    then: (s) => s.email().required()
  })
});

await schema.validate(data);

Stärken: Sehr breite Verbreitung in React-Formularen (Formik, react-hook-form), gute Doku, intuitive when()-Syntax.

Schwächen: Type-Inference ist da, aber weniger ausgereift als Zod, Performance liegt unter Ajv, kein JSON-Schema-Export.

Performance-Vergleich (Indikativ)

Realistische Werte aus Benchmarks (Anfang 2026, Validate eines mittleren User-Schemas):

Library	Validations / Sekunde	Anmerkung
Ajv (pre-compiled)	~5.000.000	Mit standalone Code-Generation noch schneller
Zod	~250.000	Reicht für 99 % der Frontend-Use-Cases
Yup	~120.000	Reicht für UI-Formulare

Faustregel: bei API-Backends Ajv (Performance + Standard). Bei Frontend/TS-Apps Zod (DX). Yup nur in Bestands-Code halten oder wenn Formik-Integration eine Anforderung ist.

Entscheidungs-Matrix

Use-Case	Empfehlung
REST-API-Backend (Express, Fastify)	Ajv
OpenAPI 3.1 → Stand-alone-Validator	Ajv
Cross-Language (TS Backend + Python Worker)	Ajv (gemeinsame JSON Schema-Files)
Next.js / Remix Server-Actions	Zod
React-Formular mit react-hook-form	Zod (via @hookform/resolvers/zod)
Legacy Formik-Codebase	Yup