Generate Zod-Ready TypeScript Interfaces from JSON

The base case: generate the interface, then transcribe each field to its Zod equivalent and add constraints.

Input:
{ "id": 1, "email": "a@x.com", "active": true }

Generated interface:
export interface User {
  id: number;
  email: string;
  active: boolean;
}

Transcribed Zod (with constraints added):
const UserSchema = z.object({
  id: z.number().int().positive(),
  email: z.string().email(),
  active: z.boolean(),
});

A nested object becomes a named interface, which maps to a nested z.object wrapper in the same position.

Input:
{ "name": "Ada", "address": { "city": "London", "zip": "EC1" } }

Generated:
export interface Root {
  name: string;
  address: Address;
}
export interface Address { city: string; zip: string; }

Zod:
const Schema = z.object({
  name: z.string(),
  address: z.object({ city: z.string(), zip: z.string() }),
});

A null sample value generates the literal null; in Zod you almost always want .nullable() on the real base type.

Input:
{ "name": "Ada", "deletedAt": null }

Generated (verbatim):
export interface Root {
  name: string;
  deletedAt: null;
}

Zod (widened by hand):
const Schema = z.object({
  name: z.string(),
  deletedAt: z.string().datetime().nullable(),
});

Flipping 'Optional properties' on marks every field ?, which corresponds to chaining .optional() — but apply it per field, not globally, in the real schema.

Generated (Optional properties: ON):
export interface Root {
  id?: number;
  nickname?: string;
}

Zod (transcribe selectively — id is required, nickname optional):
const Schema = z.object({
  id: z.number(),
  nickname: z.string().optional(),
});

If you want a runnable schema rather than a blueprint, the sibling tool emits the z.object() directly — including z.number().int() for integers and z.infer at the bottom.

Input:
{ "id": 1, "name": "Ada" }

json-to-zod output (runnable, verbatim shape):
import { z } from "zod";

export const schema = z.object({
  id: z.number().int(),
  name: z.string()
});

export type Schema = z.infer<typeof schema>;

A null sample value maps to the literal null (and naively to z.null()). The real intent is almost always z.string().nullable() or similar — widen the base type by hand. Capture a sample with the field populated to infer the underlying type instead.

Email format, min/max ranges, regex, UUID, and enum membership aren't present in a JSON sample, so the generated interface (and any naive Zod transcription) lacks them. Adding these constraints is the entire reason to use Zod — layer them on by hand: .email(), .min(0), .uuid(), z.enum([...]).

The optional switch marks every field ? at once and never detects which fields are sometimes-absent. When transcribing to Zod, apply .optional() per field based on your real contract, not by mirroring the global switch.

An array of objects infers its item interface from the first element; later-only keys are missing from both the type and your transcribed z.array(z.object({...})). Reorder the sample so the richest element is first, or merge a superset object.

A status: "active" value becomes string, naively z.string(). Replace with z.enum(['active','inactive','pending']) to actually validate membership — the sample shows one value, not the allowed set.

This tool types both 42 and 9.5 as number (TypeScript has no integer type). If you want z.number().int() for integers without transcribing by hand, use the sibling json-to-zod, which inspects each number and emits .int() for integers.

A dictionary { "en": "...", "fr": "..." } is typed with literal keys. In Zod, a dynamic map should be z.record(z.string(), z.string()) instead of a fixed z.object. Recognize maps and transcribe them as z.record.

Two different nested objects sharing a key name yield a single interface (first write wins), so your transcribed schema would reuse one shape for both. Rename one key before generating, or generate the branches separately.

An empty array becomes unknown[], which has no element type to transcribe. Decide the element type and write z.array(z.string()) (or the right type), or capture a sample where the array is populated.

The input runs through JSON.parse after trimming; malformed JSON throws and the error surfaces in the UI. Repair with json-format-fixer first, then regenerate the interface.