JSON to TypeScript Type Generator

When a JSON property has a null value, the generator produces a union type of "unknown | null" for that property. This approach preserves the information that the field exists in the data structure while indicating that the actual type cannot be inferred from a null sample. In your codebase, you can then refine the type to the expected type, such as "string | null".

Yes. The converter recursively walks through all levels of nesting and creates separate named interfaces for each nested object. For example, a "user" object containing an "address" object will produce both a "User" interface and an "Address" interface, with User referencing Address by name. This keeps the output clean and reusable.

The converter inspects array elements to infer the element type. Arrays of objects generate a dedicated interface for the element type. Arrays of primitives produce typed arrays like "string[]" or "number[]". Mixed-type arrays produce union types such as "(string | number)[]". Empty arrays default to "unknown[]" since no type can be inferred.

No. All conversion happens entirely in your browser using JavaScript. Your JSON data never leaves your device, making this tool completely safe for proprietary API responses, internal configurations, and sensitive data structures.

TypeScript interfaces support declaration merging and can be extended with the "extends" keyword, making them ideal for object shapes that may be augmented later. Type aliases are more flexible and can represent unions, intersections, and mapped types. For most API response typing, interfaces are the recommended choice. This tool lets you choose either format.

Yes. By default, the root type is named "RootObject". You can change this to any valid TypeScript identifier using the "Root Name" input field. For example, entering "ApiResponse" will generate "export interface ApiResponse { ... }" as the top-level type.

The converter generates required properties by default because JSON does not distinguish between "missing" and "present" keys — every key in the input is treated as required. If you need optional properties, add the "?" modifier manually to the generated output for fields that may not always be present in the API response.

No — and this is the single most important thing to understand. TypeScript types are erased at compile time; they produce zero runtime code. A generated interface tells the compiler and your editor what a value SHOULD look like, but at runtime nothing checks that an API actually returned that shape. If the server sends a string where your type says number, TypeScript won't catch it — you'll just get a confusing failure later. For true runtime validation, generate a schema with a library like Zod, io-ts, or Valibot (which can also infer the TypeScript type), and parse responses through it. Generated types are for developer experience; runtime validators are for safety.

The generator infers types from the sample you give it, and JSON doesn't distinguish 'this key is optional' from 'this key happens to be present' — so every key in your sample becomes a required property. If a field is sometimes absent in real responses, mark it optional yourself by adding ? to the property (field?: string). The robust approach is to feed the generator a sample that includes every possible field (merge a few real responses), then go through and add ? to the ones that aren't guaranteed. Or generate a runtime schema where optionality is explicit and enforced.