JSON Type Generator

Types from a sample, not a schema

The generator reads your example data and infers the widest type it justifies. A key missing from some records of an array becomes optional, and whole numbers mixed with decimals widen to a float. A field that mixes kinds of values becomes a union in TypeScript and the catch-all type elsewhere: any in Go, serde_json::Value in Rust and z.unknown() in Zod, or z.union if you turn that on.

A sample only shows what it contains. A price written as 10.0 reads as a whole number, an empty array says nothing about its elements and a field that is null in every record stays untyped, so check those against the real data. In Go and Rust, a whole number too large for 64 bits becomes a float.

Named types with example comments

Nested objects are hoisted into their own declarations named after their key, so a billing_address object becomes a BillingAddress type and an array under projects holds Project items. Structurally identical objects share one declaration instead of repeating it. Nesting that repeats itself, like children inside children, folds into a single type that refers to itself. With example comments on, each field shows a value taken from your data, truncated when long.

Go structs

Field and type names are exported and follow Go conventions for initialisms, so user_id becomes UserID and image_urls becomes ImageURLs, while the json tag keeps the original key. The output is already gofmt-clean. Optional and nullable scalars and structs become pointers, which you can turn off. Whole numbers become int64 and the rest float64. Turn on time.Time to use it wherever every sample is a strict RFC 3339 timestamp, and write nested structs inline if you prefer them anonymous. Keys that a struct tag cannot spell, such as ones with a comma, are flagged with a comment.

Zod schemas

Every shape becomes a z.object named after its type, ordered so each schema is defined before anything uses it, with .optional() and .nullable() where the data calls for them. Exported z.infer types, .strict(), .int() and format checks such as .email() are all options. Recursive shapes use z.lazy with an explicit type, because z.infer cannot describe a schema that refers to itself. The output works with Zod 3 and Zod 4.

Rust structs for serde

Fields are snake_case and map back to their JSON keys through #[serde(rename_all)] where one convention fits, or a #[serde(rename)] per field if you prefer that. Reserved words become raw identifiers like r#type. The derive list is yours to edit. A trait that a struct cannot derive, such as Eq on a struct that holds an f64, is left off that struct with a note below the code. Direct self references get a Box, so recursive types compile.

Standard JSON only

The input must be valid JSON, the same as your code would parse. Comments, trailing commas and single quotes are not accepted, and an invalid document shows the error with its line and column. To explore the data itself first, use the JSON Inspector. To restyle the generated TypeScript or Zod code, send it to the Code Formatter.