JSON to TypeScript, Zod & Go Struct Online — Generate Types from JSON

Open the JSON to types generator →

Why generate types from JSON?

Every integration starts the same way: you curl an endpoint, stare at a large response, and write types by hand. It is tedious, and the types drift the moment the API changes. Generating a first draft from a real payload gets you 90% of the way in seconds, leaving you to refine names, enums, and edge cases.

One input, three outputs

Start with this JSON:

{
  "id": 7,
  "name": "Ada",
  "tags": ["admin", "beta"],
  "address": { "city": "London", "zip": null },
  "orders": [
    { "sku": "A1", "qty": 2 },
    { "sku": "B2", "qty": 1, "gift": true }
  ]
}

TypeScript output:

export interface Root {
  id: number;
  name: string;
  tags: string[];
  address: Address;
  orders: Order[];
}

export interface Order {
  sku: string;
  qty: number;
  gift?: boolean;
}

export interface Address {
  city: string;
  zip: null;
}

Zod (excerpt) — note .int() for whole numbers and .optional() for the key missing from the first order:

export const OrderSchema = z.object({
  sku: z.string(),
  qty: z.number().int(),
  gift: z.boolean().optional(),
});
export type Order = z.infer<typeof OrderSchema>;

Go (excerpt) — optional values become pointers with omitempty:

type Order struct {
	Sku  string `json:"sku"`
	Qty  int    `json:"qty"`
	Gift *bool  `json:"gift,omitempty"`
}

How the inference works

• Arrays are merged. The generator compares every element, not just the first. A key present in only some objects becomes optional.
• Mixed types become unions. A field that is a string in one element and a number in another becomes string | number.
• Null becomes nullable. If a field is sometimes null, you get T | null, .nullable(), or *T.
• Integers and floats are distinguished. 5 and 5.5 widen to a float; all-whole numbers stay int in Go and Zod.
• Names come from keys. orders becomes Order for its items; identical shapes share one type.

Options worth knowing

• Root name — name the top-level type (User, ApiResponse).
• As observed / All optional — mark everything optional for PATCH bodies or partial updates.
• Readonly — readonly properties and arrays in TS, .readonly() in Zod.
• interface vs type — pick your house style.
• z.infer type — emit the inferred type next to each schema.

TypeScript types vs Zod schemas

TypeScript types exist only at compile time. If a server returns something unexpected, your app still compiles and then fails at runtime. A Zod schema checks the real value when you call parse or safeParse, so use it at trust boundaries: HTTP responses, webhooks, form submissions, environment variables, and local storage. Use plain interfaces for internal data that never crosses a boundary.

Go struct tips

• Field names are exported and use Go initialisms (ID, URL) while the json tag keeps the original key.
• Pointer fields distinguish “missing” from “zero value” in encoding/json.
• Change int to int64 or strings to time.Time where your domain needs it.
• Ambiguous or mixed values become any; narrow them after you inspect real data.

Python and Rust

Python can emit a Pydantic BaseModel or a dataclass. Optional fields use T | None = None and are ordered after required fields so a dataclass stays valid. Rust emits serde structs: JSON keys that are not snake_case get rename, missing keys become Option, and integers are i64.

Workflow on Spoold

1. Open /tools/json/to-types.
2. Paste JSON (use Format to pretty-print) and choose TypeScript, Zod, Python, Go, or Rust.
3. Set the root name and options with the chips.
4. Copy the output. The conversion is saved to History so you can reload it later, and Share creates a link.
5. Need a particular value first? Find it with the JSONPath Tester, then generate types for just that sub-document.

Pitfalls

• Empty arrays carry no element information and become unknown[].
• Dictionary-like objects (IDs as keys) generate one property per key; replace them with Record<string, T> or z.record().
• Sample bias — types describe your sample, not your business rules. Add enums, brands, and format checks yourself.
• Large numeric IDs can exceed JavaScript's safe integer range; model them as strings.

Related guides

• JSONPath tester online guide
• JSON Schema validator for formal contracts

Related search terms

Frequently asked questions