Zod vs Valibot vs ArkType 2026: O guia definitivo de validação de esquemas em TypeScript

O Zod mudou a forma como a gente pensa sobre validação em TypeScript. Escreve um schema uma vez, ganha validação em runtime E inferência de tipos de graça. Foi um divisor de águas. Mas em 2026, o Zod não tá mais sozinho.

O Valibot chegou prometendo: "A mesma segurança, 10x menor bundle." O ArkType foi ainda mais radical: "Escreve tipos TypeScript, ganha validação." E os devs tão confusos. Qual usar afinal?

Esse não é um guia de "escolhe o que você gostar". Vamos rodar benchmarks, comparar APIs, medir tamanhos de bundle e analisar a integração com TypeScript. No final, você vai saber exatamente qual se encaixa no seu caso de uso.

Os Competidores: Uma visão geral

Antes de aprofundar, vamos ver o que cada biblioteca oferece.

Zod: O campeão estabelecido

O Zod foi pioneiro na abordagem "schema-first" em TypeScript. Define um schema, infere o tipo, valida em runtime. É testado em batalha, tem documentação excelente e um ecossistema massivo.

import { z } from 'zod';

const UserSchema = z.object({
  id: z.string().uuid(),
  name: z.string().min(1).max(100),
  email: z.string().email(),
  age: z.number().int().positive().optional(),
  role: z.enum(['admin', 'user', 'guest']),
  createdAt: z.date(),
});

type User = z.infer<typeof UserSchema>;

Pontos fortes: Maduro, bem documentado, ecossistema enorme (zod-to-json-schema, zod-validation-error, etc.)
Pontos fracos: Tamanho do bundle (~12KB min+gzip), preocupações de performance em escala

Valibot: O desafiante modular

O Valibot usa uma abordagem radicalmente diferente. Em vez de encadear métodos, usa uma API funcional e modular. Cada função de validação é um import separado, permitindo tree-shaking agressivo.

import * as v from 'valibot';

const UserSchema = v.object({
  id: v.pipe(v.string(), v.uuid()),
  name: v.pipe(v.string(), v.minLength(1), v.maxLength(100)),
  email: v.pipe(v.string(), v.email()),
  age: v.optional(v.pipe(v.number(), v.integer(), v.minValue(1))),
  role: v.picklist(['admin', 'user', 'guest']),
  createdAt: v.date(),
});

type User = v.InferOutput<typeof UserSchema>;

Pontos fortes: Bundle minúsculo (~1KB min+gzip pra uso básico), arquitetura modular, tree-shaking excelente
Pontos fracos: API um pouco mais verboso, ecossistema menor

ArkType: O radical type-first

O ArkType muda completamente as regras. Em vez de aprender um novo DSL de schema, você escreve sintaxe parecida com TypeScript. Ele parseia essas expressões de tipo em runtime.

import { type } from 'arktype';

const User = type({
  id: 'string.uuid',
  name: '1<=string<=100',
  email: 'string.email',
  'age?': 'integer>0',
  role: "'admin' | 'user' | 'guest'",
  createdAt: 'Date',
});

type User = typeof User.infer;

Pontos fortes: Sintaxe mais nativa de TypeScript, inferência de tipos incrível, morphing (transformar + validar)
Pontos fracos: Curva de aprendizado em casos complexos, ecossistema mais jovem

Tamanho do Bundle: Os números não mentem

Na era do edge computing e serverless, cada kilobyte conta. Vamos medir o impacto real.

Setup do teste

Fizemos bundle de um schema realista (10 campos, tipos mistos, objetos aninhados) com cada biblioteca usando esbuild com minificação e compressão gzip.

Análise:

• Valibot ganha disparado em tamanho de bundle. A arquitetura modular significa que você só envia o que usa. Pra uma validação simples de formulário, pode ser menos de 1KB.
• Zod tá no meio do caminho. Tree-shaking ajuda, mas o core ainda é substancial.
• ArkType é o mais pesado. O parser de tipos em runtime precisa de bastante código. Mas se você usa extensivamente, o overhead por schema fica insignificante.

Quando o tamanho do bundle importa

• Funções Edge (Cloudflare Workers, Vercel Edge): Cada KB adiciona latência de cold start. Valibot vence.
• Validação client-side: Se você valida formulários no browser, a vantagem do Valibot se acumula.
• Server-side (Node.js): Tamanho do bundle importa menos. Escolha baseado em outros fatores.

Performance em Runtime: Benchmarks

Rodamos 1 milhão de validações do mesmo objeto complexo com cada biblioteca. Aqui estão os resultados:

Validação de objeto simples (10 campos, flat)

Validação de objeto aninhado (3 níveis, 25 campos)

Array de 100 objetos

Pontos-chave:

• ArkType é consistentemente o mais rápido, frequentemente 3-4x mais rápido que Zod.
• Valibot fica perto do ArkType, significativamente mais rápido que Zod.
• Zod é o mais lento, mas ainda processa mais de 1 milhão de validações por segundo pra objetos simples—mais que suficiente pra maioria das aplicações.

Performance importa pro seu caso de uso?

Importa se:

• Você valida milhares de requests por segundo (APIs de alto tráfego)
• Você processa datasets grandes (validação em batch)
• Você tá em edge/serverless onde tempo de CPU = dinheiro

Não importa se:

• Você valida formulários de usuário (algumas validações por segundo)
• Você tá construindo ferramentas internas (baixo tráfego)
• Experiência do desenvolvedor é sua prioridade

Design da API: Experiência do desenvolvedor

Vamos implementar o mesmo schema real nas três bibliotecas e comparar a experiência.

O Schema: Um Post de Blog

// O que estamos modelando:
// - title: string obrigatória, 1-200 caracteres
// - content: string obrigatória, pelo menos 100 caracteres
// - author: objeto aninhado com name e email
// - tags: array de 1-5 strings únicas
// - publishedAt: data opcional, deve ser no passado
// - metadata: record opcional de valores string

Implementação com Zod

import { z } from 'zod';

const AuthorSchema = z.object({
  name: z.string().min(1).max(100),
  email: z.string().email(),
});

const BlogPostSchema = z.object({
  title: z.string().min(1).max(200),
  content: z.string().min(100),
  author: AuthorSchema,
  tags: z.array(z.string())
    .min(1)
    .max(5)
    .refine(
      (tags) => new Set(tags).size === tags.length,
      { message: 'Tags devem ser únicas' }
    ),
  publishedAt: z.date()
    .refine((date) => date < new Date(), {
      message: 'Data de publicação deve ser no passado',
    })
    .optional(),
  metadata: z.record(z.string()).optional(),
});

type BlogPost = z.infer<typeof BlogPostSchema>;

Implementação com ArkType

import { type } from 'arktype';

const Author = type({
  name: '1<=string<=100',
  email: 'string.email',
});

const BlogPost = type({
  title: '1<=string<=200',
  content: 'string>=100',
  author: Author,
  tags: '1<=string[]<=5',
  'publishedAt?': 'Date',
  'metadata?': 'Record<string, string>',
}).narrow((post, ctx) => {
  if (post.tags.length !== new Set(post.tags).size) {
    return ctx.mustBe('um array de tags únicas');
  }
  if (post.publishedAt && post.publishedAt >= new Date()) {
    return ctx.mustBe('uma data no passado');
  }
  return true;
});

type BlogPost = typeof BlogPost.infer;

Vencedor: ArkType tem a sintaxe mais concisa e nativa de TypeScript.

Mensagens de Erro: Comparando qualidade

Saída de erro do ArkType

const result = BlogPost(invalidPost);

if (result instanceof type.errors) {
  console.log(result.summary);
  // "title must be at least 1 characters (was 0)
  //  tags must be um array de tags únicas
  //  publishedAt must be uma data no passado"
}

Vencedor: O .summary do ArkType é o mais legível pra humanos.

Integração TypeScript: Qualidade da inferência

Unions discriminadas

// Zod
const Shape = z.discriminatedUnion('type', [
  z.object({ type: z.literal('circle'), radius: z.number() }),
  z.object({ type: z.literal('square'), side: z.number() }),
]);

// ArkType
const Shape = type({
  type: "'circle'",
  radius: 'number',
}).or({
  type: "'square'",
  side: 'number',
});

Vencedor: ArkType precisa de menos boilerplate.

Tipos recursivos

// Zod
const Category: z.ZodType<Category> = z.lazy(() =>
  z.object({
    name: z.string(),
    children: z.array(Category),
  })
);

// ArkType
const Category = type({
  name: 'string',
  children: 'this[]', // Auto-referência embutida
});

Vencedor: A sintaxe 'this[]' do ArkType é a mais elegante pra tipos recursivos.

Ecossistema e Integrações

Zod

• React Hook Form: First-class @hookform/resolvers/zod
• tRPC: Suporte nativo ao Zod
• Drizzle ORM: drizzle-zod
• 50+ integrações no npm

Valibot

• React Hook Form: @hookform/resolvers/valibot
• Ecossistema crescendo (~15 integrações)

ArkType

• React Hook Form: Adaptador da comunidade
• Ecossistema pequeno (~5 integrações)

Vencedor: Zod tem o ecossistema mais maduro.

Recomendações práticas

Escolha Zod se:

• Você precisa do maior ecossistema e mais integrações
• Seu time valoriza familiaridade (a maioria dos devs conhece Zod)
• Performance não é um gargalo crítico
• Você quer a opção mais estável e testada em batalha

Escolha Valibot se:

• Tamanho do bundle é crítico (funções edge, client-side)
• Você curte padrões de programação funcional
• Você quer segurança comparável ao Zod com melhor performance
• Você tá construindo uma biblioteca e quer dependências mínimas

Escolha ArkType se:

• Performance é sua prioridade máxima
• Você quer a sintaxe de tipos mais expressiva
• Você tá confortável com uma biblioteca mais nova
• Você faz transformações de tipo complexas (morphing)

O Veredito: Nossa recomendação pra 2026

Pra maioria dos projetos em 2026, recomendamos:

1. Projetos novos com preocupações de performance: Valibot
2. Projetos enterprise/time que precisam de estabilidade: Zod
3. Usuários avançados de TypeScript querendo DX de ponta: ArkType

Não existe uma opção universalmente "melhor". Cada biblioteca faz trade-offs diferentes:

• Zod troca performance por maturidade do ecossistema
• Valibot troca verbosidade por tamanho do bundle
• ArkType troca ecossistema por performance e expressividade

Boa notícia? As três são excelentes, bem mantidas e ativamente desenvolvidas. Você não vai errar com nenhuma—só escolha a que se alinha com suas prioridades.

Conclusão: O renascimento da validação

A gente tá vivendo uma era de ouro de validação em TypeScript. Zod provou o conceito, Valibot otimizou, e ArkType reimaginou. A competição melhorou todas elas.

Se você tá começando do zero em 2026:

• Edge-first ou consciente do bundle? → Valibot
• Segurança-first, ecossistema importa? → Zod
• Performance-first, mago de tipos? → ArkType

O que você escolher, você ganha segurança em tempo de compilação E validação em runtime. Essa é a verdadeira vitória.

Agora vai validar uns dados. Com type safety.