JSON to TypeScript Interface
Generator

Stop writing interfaces by hand

Everything you need for JSON to TypeScript

Related JSON tools

Common questions answered

What are TypeScript interfaces?

TypeScript interfaces define the shape of an object — specifying which properties exist, their types, and whether they are required. Generating interfaces from JSON gives you autocompletion, compile-time error checking, and documentation directly in your IDE. This eliminates runtime bugs caused by accessing non-existent properties or passing wrong types.

This tool analyzes your JSON and generates TypeScript interface definitions. Nested objects produce nested interfaces, arrays infer their element type, and primitives map to string, number, boolean, or null. When array elements have different shapes, the generator creates a union type. The output is ready to paste into a .ts file.

{
  "id": 1,
  "name": "Alice",
  "email": "alice@test.com",
  "roles": ["admin"],
  "address": {
    "city": "Portland",
    "zip": "97201"
  }
}

interface Root {
  id: number;
  name: string;
  email: string;
  roles: string[];
  address: Address;
}

interface Address {
  city: string;
  zip: string;
}

Get the most out of this tool

• Generate interfaces from real API responses rather than documentation — actual data often has undocumented fields.
• Review generated interfaces for optional fields: if a field could be absent, add ? manually.
• Use the interfaces with fetch calls: fetch<User>("/api/user") gives typed API responses throughout your codebase.

TypeScript interfaces from JSON explained

TypeScript is a strongly-typed superset of JavaScript that adds compile-time type checking. When you fetch JSON data from an API or read it from a file, TypeScript cannot automatically infer the type — you get any by default, which defeats the purpose of using TypeScript. To get proper type checking, you must define an interface or type alias that describes the shape of the JSON. Manually writing these definitions for large API responses is tedious and error-prone; this tool automates the entire process.

The converter analyzes the JSON structure recursively and generates TypeScript interface declarations. Each JSON object becomes an interface with typed properties. JSON strings map to string, numbers to number, booleans to boolean, null to null, and undefined to undefined. Arrays of objects generate interfaces for the element type and use Array<ElementType> or ElementType[] syntax. Nested objects generate nested interfaces, with each getting a descriptive name derived from its parent key.

Type unions are generated for JSON values that could be one of several types. If a field is sometimes a string and sometimes null, the converter generates string | null for that property. If an array contains mixed element types (both numbers and strings), the converter generates Array<string | number>. These union types accurately reflect the real shape of the data and prevent incorrect assumptions in your code.

Optional properties in TypeScript are marked with a question mark (property?: type). The converter adds the optional modifier when a JSON key is absent from some elements of an array of objects but present in others — this is a common pattern where some API response records have fields that others lack. Getting this right automatically saves significant debugging time compared to marking everything required.

TypeScript interfaces are structural, not nominal. This means any object that has the required properties with the right types satisfies the interface, even without explicitly declaring that it implements it. This makes generated interfaces immediately usable with fetch responses, Axios response data, and JSON.parse() results once cast to the interface type. You can also use them with TypeScript's Partial<T>, Readonly<T>, and Pick<T, K> utility types.

Teams maintaining large TypeScript codebases often keep generated type files alongside their API client code. When an API version changes, developers paste the new sample response into this converter, compare the output to the existing interface definitions, and update accordingly. Some teams automate this with JSON Schema-to-TypeScript generators for complex schemas, but for common REST API response shapes, this tool is the fastest starting point.

When developers use this tool

Additional frequently asked questions