JSON to TypeScript

What this tool does

JSON to TypeScript reads a sample API response or config file and writes matching TypeScript declarations. Nested objects become named interfaces, arrays of objects are merged so keys missing from some items become optional, identical shapes are reused, and you can choose between interface and type alias, readonly fields and array syntax.

Typing an API response by hand is slow and error-prone. A real payload can have dozens of keys, nested objects several levels deep and arrays whose items do not all carry the same fields. Miss one optional key and the compiler will happily let you read a value that is undefined at runtime; mark everything optional and you lose most of the benefit of TypeScript.

This generator walks your JSON and infers a type for every value. When an array holds several objects, it merges them: a key present in every item is required, a key found in only some items becomes optional (key?: T), and a key whose values differ in type becomes a union such as string | number. Nested objects get PascalCase names derived from their keys, plural array keys are singularised (items becomes Item), and objects with an identical structure share one declaration. Everything runs locally, so private payloads stay on your machine.

How to use JSON to TypeScript

1. Paste a JSON sample into JSON sample, open a .json file, or click Sample to load an example order.
2. Set Root type name to the name you want for the top-level type, for example ApiResponse.
3. Choose Declare as interface or type alias, and decide how Keys missing from some items should be typed.
4. Turn on Top-level array is a list of samples if you pasted an array of records and want one merged Root type.
5. Adjust Readonly properties, Array syntax, Semicolons and Comment ISO date strings to match your code style.
6. Copy the result or download types.ts. Drop several files in batch mode to convert them all at once.

Tips for better results

• Paste several real responses wrapped in an array with the samples option on; the more examples you give, the more accurate the optional keys become.
• A field that only ever contains null in your sample is typed as null. Add a sample where it has a value so the generator can write string | null.
• Keys that are not valid identifiers, such as shipping-address, are quoted automatically, which keeps the output compilable.
• Use the type alias style if you plan to combine the results with intersections or mapped types; use interface if consumers may extend them.

Common use cases

• Typing a third-party REST API response before writing a fetch wrapper.
• Creating types for JSON configuration files loaded at start-up.
• Bootstrapping models for a front end from a backend team’s example payloads.
• Documenting the shape of webhook bodies in a shared types package.

Common mistakes to avoid

• Trusting a single example. One response rarely shows every optional field or every possible value type.
• Treating generated types as runtime validation. TypeScript types disappear at build time, so validate untrusted input with a schema as well.
• Leaving string where a field is really a fixed set of values; refine status: string to a union such as 'paid' | 'refunded' by hand.