JSON to TypeScript

When you consume an API, you usually start with a JSON response and need matching TypeScript types so the rest of your code is type-safe. Writing those interfaces by hand is tedious and easy to get wrong, especially for deeply nested objects. A JSON to TypeScript generator reads a sample and produces the interfaces for you.

ToolHub JSON to TypeScript parses your JSON sample and infers types recursively. The root object becomes an interface Root, nested objects become their own named interfaces, arrays become typed arrays, and primitives map to string, number, boolean, or null. Everything runs in your browser.

1. 1

   Paste a JSON sample

   Drop a representative JSON object into the input panel. One complete example with all the fields you care about is enough.
2. 2

   Review the generated types

   The output panel updates live with an interface Root and any nested interfaces it needs, named after your keys.
3. 3

   Copy into your project

   Click Copy and paste the interfaces into a .ts file. Rename Root to something meaningful for your domain.

The generator walks your JSON value by value. Each object becomes an interface; the name is derived from the key that holds it, converted to PascalCase. Arrays are typed from their first element, so a list of objects produces a reusable element interface and a T[] type on the parent field.

Primitives and null

Strings become string, numbers become number, and booleans become boolean. A JSON null becomes the null type. Because a single sample cannot tell that a field is sometimes null and sometimes a string, you may want to widen types like that by hand afterward.

Empty arrays

If an array is empty in your sample, there is no element to inspect, so the field is typed as unknown[]. Add a representative item to the sample to get a precise element type, or refine it manually.

• Use a complete sample. Include every optional field at least once so it shows up in the interface.
• Avoid empty arrays in your sample. One element lets the tool infer a real element type instead of unknown[].
• Rename Root to match your domain, such as User, Order, or ApiResponse.
• Mark fields optional with a question mark by hand when the API can omit them.
• Widen single-sample types to unions, such as string | null, where the real data varies.

Why is everything required in the output?

A single JSON sample shows which fields are present, not which are optional. The generator marks every field as required. Add a ? to keys that the source may omit.

How are nested interface names chosen?

They come from the key that holds the object, converted to PascalCase. If two different objects would produce the same name, the tool appends a number to keep the names unique.

What happens with arrays of objects?

The first element defines the element interface, and the field is typed as that interface followed by []. The element name is derived from a singularized version of the field name where possible.

Can it handle a top-level array or value?

Yes. If the root is not a plain object, the tool emits a type Root = ... alias instead of an interface, with any nested object interfaces alongside it.