TypeScript to Zod Schema — Paste an interface, Copy a z.object(), 100% Browser

Real-world use cases

• Add runtime validation to a fetch() boundary you already typed

  You have `interface ApiResponse { ... }` and code that does `const data = await res.json() as ApiResponse`. That cast is a lie — TS believes you, the server may disagree. Paste the interface here, copy the generated `ApiResponseSchema`, replace the cast with `ApiResponseSchema.parse(await res.json())`. Now a server returning unexpected shape throws a clear ZodError at the boundary instead of a confusing "undefined is not a function" three call-stacks deep.

• Bring a JSON-to-TS-inferred type back to a Zod schema

  You used /json-to-typescript-interface yesterday to infer types from a Stripe webhook sample. Paste that output here, get the matching Zod schema. Now you have static types AND a runtime validator from the same JSON payload — both stay in sync because they're both derived from the same source of truth, and you can regenerate either side when Stripe ships a new field.

• Lock down a feature flag config file at load time

  You ship a `flags.json` config and want `loadFlags()` to fail loudly if a teammate adds a malformed entry. Write the type: `interface Flag { key: string; enabled: boolean; rollout?: number }`, paste here, get `FlagSchema`. Then `z.array(FlagSchema).parse(JSON.parse(fs.readFileSync('flags.json')))` at boot — bad config crashes the app at startup, not in production when the bad flag finally gets read.

• Validate query params in a Next.js / Astro route

  Your `/search?q=&page=&category=` route reads `searchParams` and you've typed the shape as `interface SearchParams { q: string; page?: number; category: 'all' | 'tools' | 'blog' }`. Paste here, get `SearchParamsSchema`, use `SearchParamsSchema.safeParse(Object.fromEntries(url.searchParams))`. You get back a discriminated `{ success: true, data } | { success: false, error }` to feed straight into your error UI.

• Build a form validator that matches your DTO types exactly

  The frontend form posts to an endpoint expecting `CreateUserDto`. You don't want the form schema to drift from the DTO. Paste the DTO here, get `CreateUserDtoSchema`, hand it to react-hook-form via `zodResolver(CreateUserDtoSchema)`. Add a backend `CreateUserDtoSchema.parse(req.body)` at the endpoint — same contract, validated on both sides, one source of truth.

• Migrate a hand-written Zod schema to match a refactored TS type

  You changed `interface Order` (renamed a field, made one optional, narrowed a union) but the existing Zod `OrderSchema` is out of date. Paste the new interface here, diff the output against the old schema, apply the differences. Faster than chasing them by eye and catching the one you missed in production.

Common pitfalls

• Expecting Zod to model every TS form. Zod is runtime-only — conditional types, mapped types, template literal types, `infer`, `keyof`, indexed access `T[K]` are compile-time shape manipulators with no runtime equivalent. The tool flags these as "unsupported, manual review" warnings above the output rather than silently emitting wrong validators.

• Pasting code that imports types from another file. Imports are ignored — only declarations in this paste resolve. References to imported types fall back to `z.unknown()` with a warning. Paste the related declarations together, or hand-edit the output to add `import { UserSchema } from "./user"`.

• Forgetting Zod object mode defaults to silently stripping unknown keys. The tool defaults to `.strict()` precisely because silent-strip burns users once. Want lenient parsing (third-party data with extras you ignore)? Switch to `.passthrough()` — a deliberate choice, not the default.

• Expecting `z.enum` to accept number literals. Zod's `z.enum([1, 2, 3])` does not type-check — `z.enum` is string-only by design. `1 | 2 | 3` renders as `z.union([z.literal(1), z.literal(2), z.literal(3)])`. For a tighter check, append `.refine(v => [1,2,3].includes(v))`.

• Pasting a JS file (no types) and getting parse error. The tool parses TypeScript declarations only — `function foo()` or `const x = 1` at top level produces "no interface/type declaration found". Wrap your shapes in an `interface` or `type` first.

• Using `Pick<T, K>` / `Omit<T, K>` with a non-literal key set. Only literal-string keys resolve (`Pick<User, "id" | "name">`). `Pick<T, keyof T>` falls back to the base type with a warning. For dynamic key sets, hand-build the schema (usually one `.pick({ id: true, name: true })` line).

Privacy