JSON to TypeScript Converter

The JSON to TypeScript Converter is a free, browser-based tool that turns any JSON object or array into ready-to-use TypeScript interfaces (or type aliases). Paste your JSON, and it recursively infers the shape of your data - typing every field, promoting nested objects into their own named interfaces, and inferring array element types - so you get static types you can drop straight into your project.

Everything runs client-side with a hand-written recursive type walker and the native JSON.parse, so no data is uploaded, there is no sign-up, and there is no dependency on an external API. Your JSON never leaves your device, which makes the tool safe for private payloads and internal API responses.

How to convert JSON to TypeScript

1. Paste a JSON object or array into the input pane on the left.
2. Set the root interface name (for example User or ApiResponse).
3. Choose whether to emit an interface or a type alias.
4. Toggle the export keyword and whether nullable fields should be marked optional with ?.
5. Read the generated TypeScript on the right, then use Copy or Download to save a .ts file.

How does the type inference work?

The converter walks your JSON recursively and maps each value to a TypeScript type: strings become string, numbers become number, booleans become boolean, and every nested object becomes its own named interface derived from the property key. Arrays are inspected element by element - a list of strings becomes string[], while an array of objects is merged into a single interface where keys that appear in only some elements are marked optional.

When a value is null or a field holds more than one type, the tool produces a union such as string | number | null, and identical nested shapes are automatically deduplicated so the same interface is reused instead of generated twice.

Interface vs type alias: which should you use?

An interface is the idiomatic choice for describing the shape of an object, especially when you expect to extend it or let declarations merge. A type alias is more flexible for unions, intersections, and mapped types, and many teams prefer it for API response models. This tool supports both so you can match your codebase's convention - flip the dropdown and the entire output regenerates instantly.

Why use this JSON to TypeScript converter

• Recursive inference: nested objects and arrays are typed all the way down.
• Named interfaces: child objects become reusable, well-named types instead of inline blobs.
• Smart unions: mixed and nullable values become clean union types automatically.
• Configurable: pick interface or type, toggle export, and mark nullable fields optional.
• Private: 100% client-side, nothing is sent to any server.
• Portable: copy the result or download it as a .ts file in one click.

When to reach for a different tool

Generate TypeScript types when you are consuming an API and want compile-time safety around its JSON payloads. If instead you just need to tidy or validate that JSON, a dedicated JSON Formatter is the faster path, and when your target is a different data format you can reach for a JSON to XML Converter or a JSON to YAML Converter instead. If your source data starts as a spreadsheet, convert it first with a CSV to JSON Converter and then paste the result here, and when you are wiring up the request itself a cURL to Code Converter pairs neatly with the interfaces you generate.

Tips for cleaner generated types

Feed the converter a representative sample - if a field can be null or missing in real responses, include an example of that so the inferred type reflects it. For arrays of records, pass several objects rather than one, since the merge step relies on multiple samples to decide which keys are optional. Finally, give the root a meaningful name; a good root name flows into the nested interface names and keeps the output readable.

Frequently Asked Questions

Is my JSON uploaded to a server?

No. The conversion runs entirely in your browser using client-side JavaScript. Your JSON is parsed and typed locally and never leaves your device, so it is safe to use with private or sensitive API data.

How are nested objects handled?

Each nested object is promoted into its own named interface derived from the property key, and the parent interface references it by name. Identical nested shapes are detected and reused, so you get one clean interface instead of duplicated inline types.

What happens with null values and mixed types?

A null value produces the type null, and if you enable the optional setting the field is marked with a question mark instead. When a field or array holds more than one type, the tool emits a union such as string | number | null.

Can I generate a type alias instead of an interface?

Yes. Switch the declaration style dropdown to type and the tool emits type aliases like type User = { ... } instead of interface declarations. You can also toggle the export keyword on or off.

How does it type an array of objects?

It merges every object in the array into a single interface. Keys present in all elements are required, while keys that appear in only some elements are marked optional, and the array itself is typed as ElementType[].

Can I download the result as a .ts file?

Yes. Click Download to save the generated TypeScript as a .ts file named after your root interface, or use Copy to place it on your clipboard and paste it straight into your editor.