JSON to TypeScript.

Convert JSON to TypeScript online

A JSON to TypeScript converter turns sample JSON into TypeScript interfaces or type aliases. Paste an API response, webhook payload, config object, or mock JSON above and generate clean types with nested names, optional fields, readonly support, and custom root naming.

How to convert JSON to TypeScript in three steps

1. Paste a JSON sample — ideally an array of several records, not just one.
2. Choose your options — interface or type alias, root name, optional-field detection, readonly.
3. Copy the types straight into your codebase.

What the generated types look like

This JSON:

[
  { "id": 1, "name": "Ada", "email": "ada@example.com",
    "address": { "city": "London", "zip": "E1 6AN" } },
  { "id": 2, "name": "Alan", "address": { "city": "Cambridge" } }
]

produces:

export interface Address {
  city: string;
  zip?: string;          // absent from the second record
}

export interface User {
  id: number;
  name: string;
  email?: string;        // absent from the second record
  address: Address;      // nested objects become named interfaces
}

export type Users = User[];

Note what a single sample would have missed: both email and zip would have been marked required, and the first time the API omitted one your code would break. That is why the generator compares across records.

Generate interfaces from realistic JSON samples

The best JSON to TypeScript interface output comes from realistic examples. Arrays help detect optional fields, nested objects become named shapes, and null values can be represented explicitly so your frontend, backend, or SDK code gets safer autocomplete.

The practical rule: paste at least three or four records that differ from one another — one with nulls, one with missing optional fields, one fully populated. Types inferred from a single happy-path response are the main reason generated types are wrong in production.

Types are not validation — the mistake worth avoiding

TypeScript types are erased at compile time. They do not exist when your code runs, so they cannot check what an API actually sends you. Declaring const user: User = await res.json() tells the compiler to trust you — it verifies nothing at runtime. If the server returns null where you promised a string, your code crashes exactly as it would have without types.

Types catch mistakes in your code; they do not police incoming data. For that you need a runtime check — generate a JSON Schema from the same sample and validate against it, or use a library like Zod. Use both together: the types for autocomplete and compile-time safety, the schema for the network boundary.

Common problems (and fixes)

“Everything came out required.” You pasted a single object. Paste an array of varied records so optional fields can be detected.

“I got any[] for an empty array.” An empty array carries no type information — nothing can infer the element type from []. Include at least one populated item.

“A field is typed null.” The only sample value was null. Add a record where the field is populated, and you will get a proper string | null union.

“My JSON will not parse.” Clean it first with the JSON repair tool or the JSON validator.

Why use this JSON to TS converter?

It is instant, private, and focused on practical TypeScript output. Use it when wiring up a new API response, documenting sample data, or replacing loose any types — and because it runs entirely in your browser, you can safely paste real API responses containing customer data or tokens, which you should never paste into a server-side generator. Need a validation contract too? Try the JSON Schema generator. Related: JSON formatter, JSON viewer to explore the shape first, and mock JSON generator to create test fixtures that match your new types. Read how to convert JSON to TypeScript.