Add valid JSON
Paste an object or array, or open a local .json file. Nested structures and representative array records produce the best types.
Intelligent JSON type inference
JSON to TypeScript Converter
Generate clean TypeScript definitions from real JSON data. Infer nested object types, array element types, nullability, property names, and mixed-value unions without uploading your data.
- Nested type inference
- Private browser processing
- Copy or download TypeScript
JSON input
Generated TypeScript0 bytes
How to convert JSON to TypeScript
Generate reusable TypeScript definitions in three focused steps.
Infer the model
Choose interfaces or type aliases, name the root type, and let the converter merge object shapes and value types.
Export TypeScript
Review the definitions, copy them into your project, or download a ready-to-use .ts file.
Type inference designed for real API data
The generator examines complete structures rather than guessing from the first property alone.
Nested models
Objects inside objects receive clear named definitions instead of unreadable inline blocks.
Array merging
Multiple object records are inspected to identify shared, optional, nullable, and differing properties.
Valid identifiers
Property names that are not legal TypeScript identifiers are quoted automatically and safely.
Private conversion
JSON parsing and type generation happen locally in your browser without a server upload.
How JSON becomes a TypeScript model
Each JSON value maps to a TypeScript type: strings to string, numbers to number, booleans to boolean, null values to null, arrays to element arrays, and objects to named definitions.
Arrays reveal optional properties
When an array contains several objects, the generator merges their keys. A property missing from some records becomes optional, while values with different shapes become union types.
Use representative JSON
Generated types describe the sample you provide. Include realistic records, null states, and variant values so the output reflects the API payload accurately.
// JSON { "id": 42, "name": "Alex", "roles": ["admin", "editor"] } // TypeScript export interface Root { id: number; name: string; roles: string[]; }
JSON to TypeScript converter FAQs
Practical details about inference, arrays, nulls, and generated definitions.
Does the converter support nested JSON?
Yes. Nested objects receive their own named interfaces or type aliases, and nested arrays are inferred recursively.
How are arrays of objects handled?
All object samples in the array are merged. Missing keys become optional, and differing value types are combined into unions.
What happens to null values?
A null-only sample becomes the null type. When another record provides a concrete value for the same property, the result becomes a union such as string | null.
Can I generate type aliases instead of interfaces?
Yes. Clear the interface option to produce exported type aliases for object definitions.
Are invalid property names supported?
Yes. Keys containing spaces, hyphens, or other characters are quoted so the generated TypeScript remains valid.
What type is generated for an empty array?
An empty array does not contain enough evidence to infer an element, so it is generated as unknown[].
Is my JSON uploaded to the server?
No. Parsing, inference, copying, and downloading happen locally inside your browser.
Should generated types be reviewed?
Yes. The definitions describe the supplied sample. Compare them with your API contract, especially when optional or rare fields may be absent.