JSON Schema to Zod Converter

JSON Schema to Zod: Migrating from Draft Validation to TypeScript-Native Schemas

JSON Schema is the interchange format for describing data shapes — used in OpenAPI specs, form libraries, database validators, and config file validators. Zod is TypeScript's runtime validation library with first-class type inference. Migrating from JSON Schema to Zod means moving from a JSON-based description to a code-first schema that gives you TypeScript types for free. This is common when adopting tRPC, adding type safety to a Next.js API, or replacing ajv with a library that integrates directly with your TypeScript toolchain.

Live Example: OpenAPI Component Schema to Zod

// Input: JSON Schema (from an OpenAPI spec)
{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "type": "object",
  "required": ["id", "email", "role"],
  "properties": {
    "id":         { "type": "string", "format": "uuid" },
    "email":      { "type": "string", "format": "email" },
    "username":   { "type": "string", "minLength": 3, "maxLength": 20 },
    "role":       { "type": "string", "enum": ["admin", "editor", "viewer"] },
    "age":        { "type": "integer", "minimum": 13, "maximum": 120 },
    "website":    { "type": "string", "format": "uri", "nullable": true },
    "created_at": { "type": "string", "format": "date-time" }
  }
}

// Generated Zod Schema
import { z } from 'zod';

export const RootSchema = z.object({
  id: z.string().uuid(),
  email: z.string().email(),
  username: z.string().optional(),
  role: z.enum(['admin', 'editor', 'viewer']),
  age: z.number().int().optional(),
  website: z.string().url().nullable().optional(),
  created_at: z.string().datetime().optional(),
});

export type Root = z.infer<typeof RootSchema>;

JSON Schema to Zod: Keyword Mapping

Most JSON Schema keywords have direct Zod equivalents:

// type
{ "type": "string" }   → z.string()
{ "type": "number" }   → z.number()
{ "type": "integer" }  → z.number().int()
{ "type": "boolean" }  → z.boolean()
{ "type": "array" }    → z.array(z.unknown())
{ "type": "object" }   → z.object({})

// String formats
{ "format": "email" }      → z.string().email()
{ "format": "uri" }        → z.string().url()
{ "format": "uuid" }       → z.string().uuid()
{ "format": "date-time" }  → z.string().datetime()

// Numeric constraints
{ "minimum": 0 }           → z.number().min(0)
{ "maximum": 100 }         → z.number().max(100)
{ "exclusiveMinimum": 0 }  → z.number().gt(0)

// String constraints
{ "minLength": 1 }         → z.string().min(1)
{ "maxLength": 50 }        → z.string().max(50)
{ "pattern": "^[a-z]+$" } → z.string().regex(/^[a-z]+$/)

// Composition
{ "enum": ["a", "b"] }    → z.enum(["a", "b"])
{ "nullable": true }       → .nullable()
{ "oneOf": [...] }         → z.union([...])
{ "allOf": [...] }         → z.intersection(...)

Handling $ref and Nested Schemas

JSON Schema uses $ref for reusability. In Zod, the equivalent is a named const:

// JSON Schema with $ref
{
  "$defs": {
    "Address": {
      "type": "object",
      "required": ["street", "city"],
      "properties": {
        "street": { "type": "string" },
        "city":   { "type": "string" },
        "zip":    { "type": "string" }
      }
    }
  },
  "type": "object",
  "properties": {
    "name":            { "type": "string" },
    "billing_address": { "$ref": "#/$defs/Address" },
    "shipping_address": { "$ref": "#/$defs/Address" }
  }
}

// Equivalent Zod (manually written after generation)
const AddressSchema = z.object({
  street: z.string(),
  city:   z.string(),
  zip:    z.string().optional(),
});

const UserSchema = z.object({
  name:             z.string().optional(),
  billing_address:  AddressSchema.optional(),
  shipping_address: AddressSchema.optional(),
});

Why Migrate from JSON Schema to Zod?

• TypeScript types for free: z.infer<typeof Schema> gives you the TypeScript type derived from the schema — no duplicate type definitions to keep in sync.
• tRPC and Next.js integration: tRPC uses Zod for input/output validation. Migrating lets you share schemas between your API routes and client code.
• Better error messages: Zod errors are structured (ZodError with an issues array) and easier to format for end users than raw AJV validation errors.
• Transforms and preprocessing: Zod supports .transform() for coercing data at parse time — JSON Schema is description-only and can't transform.

Frequently Asked Questions

Does the converter handle draft-07 vs draft-2020-12 differences? TypeMorph infers from the data structure, so draft-version differences in keywords like nullable vs type: ["string", "null"] are handled by the inference engine rather than keyword-by-keyword parsing.

What about additionalProperties: false? This is equivalent to Zod's .strict(): z.object({...}).strict() rejects objects with extra keys. Add it manually after generation if you need strict validation.

Can I still use AJV alongside the generated Zod schema? Yes. JSON Schema and Zod are not mutually exclusive. You might keep AJV for validating external API responses (where you have the JSON Schema) and use Zod internally for type-safe route handlers.

Is my schema sent to a server? No. TypeMorph converts entirely in your browser — schemas often describe internal data models and none of it leaves your machine.