JSON to TypeScript interfaces.

Worked example with null, a mixed array and a missing key

This JSON:

{"id":101,"name":"Ada","email":null,"tags":["admin","dev"],"scores":[9,"n/a",null],"orders":[{"sku":"A1","qty":2},{"sku":"B2","qty":1,"note":"gift","address":{"city":"Toronto"}}]}

becomes:

interface Root {
  id: number;
  name: string;
  email: null;
  tags: string[];
  scores: (string | number | null)[];
  orders: Order[];
}

interface Order {
  sku: string;
  qty: number;
  note?: string;
  address?: Address;
}

interface Address {
  city: string;
}

Look at what the sample forced. email is only ever null, so it is typed null; a real API probably returns string | null, which a sample cannot reveal. scores holds a number, a string and a null, so the element type is a union. The two orders objects are merged into one Order interface: note and address appear in only one of them, so they are optional.

How the types are inferred

The text is parsed with JSON.parse, which accepts the grammar of RFC 8259, giving six kinds of value: object, array, string, number, boolean and null. Then:

• Primitives map to string, number, boolean and null. JSON has one number type, so integers and decimals are both number.
• Arrays become T[], where T is the union of every element type, wrapped in parentheses when it is a union, such as (string | number)[]. An empty array gives unknown[] because nothing shows the element type.
• Objects become a named interface (or type alias). Objects found at the same position, for example every element of one array, are merged into one shape. A key present in some but not all of them gets the optional marker name?: T; types seen for the same key are unioned.
• Names come from the key in PascalCase (user_profile becomes UserProfile); array items use the singular of the key (orders gives Order). Duplicates get a number suffix. Keys that are not valid identifiers, such as user-id, are quoted.
• Root array or primitive: an interface cannot be an array, so those are written as a type alias.
• readonly: adds readonly to every property and uses ReadonlyArray<T>.

Limits to know: a sample shows only what it contains. A key present in every sample element may still be optional in production, a field seen only as null has an unknown real type, and a map-like object with arbitrary keys ({"u1": {...}, "u2": {...}}) is better written as Record<string, T> by hand. Review the output before relying on it. This differs from the JSON to JSON Schema Generator, which produces a runtime-validatable schema rather than compile-time types.

Sources (as of 2026-10-01): TypeScript Handbook, Object Types (optional properties, readonly, interfaces); TypeScript Handbook, Everyday Types (arrays, unions, type aliases); RFC 8259, The JSON Data Interchange Format.