JSON to TypeScript Interface Generator

JSON Input

Root interface name

Output will appear here

Generate TypeScript interfaces from a JSON sample

Paste a real JSON response — from an API, a fixture file, or a database export — and get ready-to-use TypeScript interface declarations. This saves the tedious, error-prone work of hand-typing interfaces for large or deeply nested payloads, and gives your frontend or Node.js code proper type safety from day one.

How the type inference works

Nested objects become their own named interfaces, named after the property key (e.g. an address field produces an Address interface).
Arrays of primitives become typed arrays, like string[] or number[].
Arrays of mixed primitive types become a union array type, like (number | string)[].
Arrays of objects generate one shared interface for the item shape and reference it as Item[].
Interfaces with an identical field signature are automatically deduplicated so you don't get repeated, redundant types.
null values are typed as null — widen them to string | null etc. by hand if a field is sometimes populated.

Typical use cases

Frontend development: Type an API response before wiring it into a React, Vue, or Angular component.
Backend contracts: Quickly scaffold types for a Node.js/Express handler based on sample request or response bodies.
SDK & client generation: Bootstrap types for a small internal API client without a full code-gen pipeline.

Frequently Asked Questions

Yes. If your JSON is an array of objects, the tool generates one interface for the item shape plus a RootList type alias for the array itself.

Since type inference is based on a single sample, a field that's null in your sample is typed as null. If you know a field can be either a value or null across different responses, manually widen it to something like string | null.

Yes — set the “Root interface name” field before generating, and nested interfaces are named after their parent property automatically. You can always rename them afterward in your editor.

It's a lightweight, sample-based inference tool — great for quickly bootstrapping types. For strict, schema-driven type generation across an entire API, a dedicated code-gen tool paired with a JSON Schema or OpenAPI spec is more robust.