JSON to TypeScript Interface

What This Tool Does

This tool inspects one sample JSON value and infers matching TypeScript interface declarations from it. The outermost object is always named Root. For every nested object it encounters, it generates a separate, named interface rather than inlining the shape — the name is built from the immediate parent interface's name plus the title-cased property key. So a Root object with an address key produces a standalone RootAddress interface, and if that address object itself had a nested geo key, that would become RootAddressGeo, and so on down the tree.

Arrays are typed from their first element only: an array of strings becomes string[], an array of objects becomes SomeName[] with SomeName generated as its own interface, and an empty array — since there's nothing to inspect — becomes unknown[]. Primitive values map to JavaScript's own typeof result (string, number, boolean), and null is emitted as the literal type null. When the output contains multiple interfaces, Root is always printed first, followed by the nested interfaces in the order they were discovered.

How to Use It

1. Paste a representative sample of your JSON — an API response body, a config object, or a saved payload — into the Input box.
2. Click Run.
3. The generated Root interface, followed by any nested interfaces it references, appears in the Output box.
4. Copy the interfaces into your .ts file, and rename Root to something meaningful for your codebase (e.g. User, OrderResponse).
5. Review the output for optional fields, nullability, and array item variation before treating it as final — see Limitations below.

Worked Example

Input:

{
  "id": 1,
  "name": "Ada",
  "address": { "city": "Berlin" },
  "tags": ["a", "b"]
}

Output:

interface Root {
  id: number;
  name: string;
  address: RootAddress;
  tags: string[];
}

interface RootAddress {
  city: string;
}

Notice the naming: because address is a key on Root, its generated interface is named RootAddress — the parent interface's name followed by the title-cased key. The tags array is typed from its first element ("a", a string), producing string[] rather than a separate interface, since string arrays don't need one.

Common Use Cases

• Typing an API response quickly — paste a real response body and get a starting interface instead of typing every field by hand.
• Scaffolding types from a sample payload — turn a saved test fixture or webhook payload into TypeScript types for a new integration.
• Documenting expected shapes for a team — share a generated interface in a PR or ticket so reviewers can see the exact structure being consumed.
• Bootstrapping a data model — use the generated interfaces as a first draft before refining them into your project's shared type definitions.

Limitations

This tool infers types from a single example value — it has no visibility into any other possible response your API or data source might produce. Be aware of the following before using generated output in production:

• No optional fields. Every key present in the sample is generated as required. If a field is sometimes absent, you must add ? by hand.
• No unions across array items. Array typing only looks at the first element. If your array actually mixes shapes or types (e.g. some items have an extra field, or a numeric ID sometimes arrives as a string), that variation is silently missed.
• No real nullability. A null sample value produces the literal type null, not a union like string | null. If the field can hold both a string and null, you need to add that union manually.
• One sample, one shape. If your data source returns different shapes under different conditions (error vs. success responses, different API versions), generate and merge interfaces from each variant separately.

Treat the output as a strong first draft, not a final type definition — always review it against your actual API documentation or several sample payloads.

FAQ

Related Tools & Guides

• All JSON Tools
• JSON to TypeScript: Generating Interfaces You Can Trust
• JSON Formatter & Prettifier