Generate a Zod Schema for React Form Validation

The most common case: email, password, age, and a terms checkbox. Note the generator never adds .email() or .min() — that is your job in the second step.

Input (sample submission):
{ "email": "a@b.com", "password": "hunter2", "age": 31, "acceptTerms": true }

Generated:
import { z } from "zod";

export const schema = z.object({
  email: z.string(),
  password: z.string(),
  age: z.number().int(),
  acceptTerms: z.boolean()
});

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

You then refine:
  email: z.string().email(),
  password: z.string().min(8),
  acceptTerms: z.literal(true)

Dot-path form fields like address.zip come from a nested object in the payload and become a nested z.object. The shape mirrors your field structure one-for-one.

Input:
{ "name": "Sam", "address": { "city": "NYC", "zip": "10001", "unit": 4 } }

Generated:
export const schema = z.object({
  name: z.string(),
  address: z.object({
    city: z.string(),
    zip: z.string(),
    unit: z.number().int()
  })
});

Setting the Root schema name to checkoutForm produces a self-documenting export you can import by name across your form components.

Root schema name: checkoutForm

Generated:
export const checkoutForm = z.object({ /* ... */ });
export type CheckoutForm = z.infer<typeof checkoutForm>;

Usage:
const form = useForm<CheckoutForm>({
  resolver: zodResolver(checkoutForm)
});

Tick Strict objects when a form posts a fixed set of fields and you want Zod to reject anything extra (e.g. injected hidden inputs).

Strict objects: ON

Generated:
export const schema = z.strictObject({
  email: z.string(),
  acceptTerms: z.boolean()
});

z.strictObject rejects { email, acceptTerms, csrf } with an
'Unrecognized key(s)' error — z.object would silently allow it.

Password-confirmation and other multi-field rules are not derivable from a single payload. Add them with .refine() after generating the skeleton.

Generated skeleton:
export const schema = z.object({
  password: z.string(),
  confirmPassword: z.string()
});

You add:
export const schema = z.object({
  password: z.string().min(8),
  confirmPassword: z.string()
}).refine(d => d.password === d.confirmPassword, {
  message: 'Passwords must match', path: ['confirmPassword']
});

The generator infers from the runtime type of the value, so "user@example.com" is just a string. It cannot know you want .email(). This is expected: the tool builds the structural skeleton, and you add format validators. The same applies to UUIDs, URLs, and ISO dates — all z.string() until you refine.

Inference only sees keys present in your sample object. A field the user left blank (and your form omitted) will not appear in the schema at all. Capture a submission with every field populated, or add the field manually as z.string().optional() afterwards.

A null value yields z.null(), which only accepts null. For a nullable field that is sometimes a string, rewrite it to z.string().nullable() (or z.string().optional() if it can be absent). The generator has no way to know the non-null type from a single null.

{ "age": "25" } produces z.string(), not z.number(). HTML form inputs submit strings, so if your raw payload has quoted numbers, either coerce in the form layer or use z.coerce.number() after generating. Decide deliberately — this is a common silent mismatch.

If a multi-select or tag field was empty ([]) in the sample, the element type is unknowable, so you get z.array(z.unknown()). Provide a sample with at least one element, or replace z.unknown() with the real element type by hand.

A key like "first-name" is not a valid JS identifier, so the generator quotes it: "first-name": z.string(). The schema is valid; you access it as data['first-name']. Consider renaming the form field with json-key-renamer before generating if you prefer dot access.

On the free tier, code generation is limited to 1 run per day (resetting at UTC midnight) with a 100-row cap on array inputs. A single form object counts as one run regardless of field count. Pro raises this to 5/day, and Developer is unlimited.

If you paste an array of submissions, you get z.array(z.object({...})), not the per-record object schema. For a single form, paste a single object. On limited tiers, arrays over the row cap are sliced to the first N records before inference.