What is a TypeScript interface?

A TypeScript interface is a structural contract that describes the shape of an object — which properties it has and what type each property is. Interfaces are erased at compile time (they produce no JavaScript output) and are used exclusively for type checking during development.

How is a TypeScript interface different from a type alias?

Both interfaces and type aliases can describe object shapes in TypeScript. Interfaces can be extended with `extends` and merged (declaration merging), while type aliases support union and intersection types. For plain object shapes from JSON, both are equivalent. This tool generates interfaces because they are idiomatic for data transfer objects.

How are nested objects handled?

Each nested object generates its own named interface. The interface name is derived from the parent interface name and the key name (e.g., a key "address" inside "Root" generates an "RootAddress" interface). All nested interfaces are output before the interfaces that reference them, so the code is valid top-to-bottom.

How are arrays handled?

Arrays are typed as `ElementType[]`. If the array contains objects, the tool generates a named interface for the element type (e.g., `TagItem[]`). If the array is empty, the type is `unknown[]`. The tool infers the type from the first element of the array.

What happens with null values?

JSON null values are typed as TypeScript `null`. In practice you may want to widen the type to `string | null` — this tool types it as the literal value found in the JSON. You can manually edit the generated interface to add union types.

Is the generated TypeScript production-ready?

The generated interfaces are correct TypeScript that you can paste directly into your project. For production use, review whether fields should be optional (add `?` suffix) and whether null types should be widened to unions. The tool infers types from a single sample JSON object, so optional fields that are absent will be missing from the interface.

Free · Browser-only · No sign-up

JSON to TypeScript Interface Generator

Paste any JSON object and instantly get export-ready TypeScript interface definitions. Handles nested objects, arrays, null values, and deeply nested structures. Runs entirely in your browser — your data never leaves your device.

Nested objectsArray inferenceNull typesCustom root name100% offline

root name

json input

typescript interfaces

About this tool

Converts any JSON object into typed TypeScript interfaces. Nested objects produce separate named interfaces, arrays infer their element type, and null values map to null. All interfaces are export-ready and ordered so child types appear before their parents. Runs entirely in your browser — nothing is sent to a server.

Features

Nested objects

Each nested object generates a separate named interface automatically

Array inference

Arrays are typed correctly — object arrays generate item interfaces

Null support

JSON null values are preserved as TypeScript null types

Custom root name

Set any name for the root interface — not just "Root"

Dependency order

Child interfaces always appear before the parents that reference them

Browser-only

Zero network requests — your JSON never leaves your device

How to use

1
Paste JSON
Copy any JSON object or array into the input field on the left.
2
Set root name
Optionally rename the root interface from "Root" to something meaningful like "User" or "ApiResponse".
3
Generate
Click Generate Interfaces. Nested objects will produce their own interfaces, ordered by dependency.
4
Copy & paste
Copy the output and paste it directly into your TypeScript project file.

Frequently asked questions

Can I generate interfaces from a JSON array?

Yes. Paste a JSON array and the tool will use the first element to infer the interface shape. For example, pasting an array of user objects will generate a User interface based on the first item.

How do I mark fields as optional?

The tool generates all fields as required. To mark a field as optional, add a ? after the field name in the output — for example: email?: string;

Does it support deeply nested JSON?

Yes. The tool recursively processes objects at any depth, generating one interface per unique object shape with names that reflect the nesting path.

Why does the tool only look at the first array element?

JSON has no schema — arrays can contain mixed types. The tool uses the first element as a representative sample. If your array contains objects with varying shapes, review the generated interface and add union types or optional fields as needed.

Related tools

JSON → Zod Schema

Generate runtime Zod validators from JSON

JSON Formatter

Format and validate JSON syntax

JSON Diff Checker

Compare two JSON objects visually