JSON to TypeScript

The JSON to TypeScript Converter generates TypeScript interfaces and type definitions from JSON samples. Paste an API response, config file, or any JSON data, and the tool analyzes its structure to produce matching TypeScript interfaces — correct types (string, number, boolean, null), nested objects as nested interfaces, arrays with element types inferred, optional fields (for keys present in some samples but not others), and union types (when same field has different types across samples). Perfect for typing API responses, starting new TypeScript projects, or documenting data structures.

TypeScript adoption has made "what type does this API return?" a daily question. Writing interfaces by hand is tedious and error-prone — especially for complex nested responses. This tool solves it: give it the JSON, get typed interfaces instantly. Supports single-sample inference (types from one example) or multi-sample inference (paste multiple samples; tool computes union types, optional fields where some samples differ). Output uses modern TypeScript idioms — interface over type alias, proper generic arrays, marked optional fields, literal types when values are enum-like.

Type inference from JSON:

Primitive types:

| JSON value | TypeScript type |
|---|---|
| "hello" | string |
| 42 | number |
| 3.14 | number |
| true/false | boolean |
| null | null |

Arrays:

- Empty array [] → unknown[] or never[].
- Array of same type [1, 2, 3] → number[].
- Array of objects [{id:1}, {id:2}] → {id: number}[].
- Mixed types [1, "two"] → (number | string)[].

Objects:

Each object becomes an interface. Nested objects become nested interfaces.

``json
{
"user": {
"name": "Alice",
"age": 30
}
}
``

→

```typescript
interface Root {
user: User;
}

interface User {
name: string;
age: number;
}
```

Optional fields:

With multi-sample input:

``json
[
{"id": 1, "email": "a@x.com"},
{"id": 2}
]
``

→

``typescript
interface User {
id: number;
email?: string; // optional because not in all samples
}
``

Union types:

When same field has different types:

``json
[
{"value": "text"},
{"value": 42}
]
``

→

``typescript
interface Item {
value: string | number;
}
``

Literal types (enum-like):

When field values are a small set:

``json
[
{"status": "active"},
{"status": "inactive"},
{"status": "pending"}
]
``

→

``typescript
interface Item {
status: "active" | "inactive" | "pending";
}
``

Naming:

- Top-level interface: Root or configurable (e.g., use URL path for API).
- Nested interfaces: inferred from key name (capitalized). user → User.
- Collision handling: User1, User2 if different structures share name.

Modern TS features:

- Readonly arrays: Option to mark all arrays as readonly T[] (immutability).
- Readonly properties: Option to mark all properties as readonly.
- null vs undefined: Distinction preserved. Optional (?) means possibly undefined; explicit null means value is null.
- Utility types: Generated interfaces work well with Partial<T>, Pick<T, K>, Omit<T, K>.

Advanced features:

- Detect date strings: "2026-05-05" → string by default, or Date (if "Parse dates" option enabled — note TypeScript has no built-in Date type distinct from string).
- Detect enums: 3+ distinct string values used → suggest enum.
- Detect arrays of empty structures: [] with context clues → AnyType[].

Import/export options:

- Named exports for each interface.
- Default export of root.
- Export everything.
- Private (no export — internal use).

Common pitfalls:

- Single sample mistakes: email: null in one sample → inferred as null type. If email is sometimes string, provide multi-sample.
- Empty arrays/objects: [] and {} give limited information. Use non-empty samples.
- Very deeply nested: Result can be overwhelming. Extract sub-types for clarity.

Alternative tools:

- quicktype (the canonical tool for this, CLI and web).
- json2ts (VS Code extension).
- ts-json-schema-generator (TypeScript → JSON Schema, opposite).

This formatter inspired by quicktype's approach.

JSON to TypeScript vs quicktype: quicktype is the canonical tool with CLI, VS Code, and web interfaces. Supports many target languages (TS, Python, Go, Rust). This tool focuses on TS with clean output.

Interface vs Type alias: Interfaces for object shapes (generated here). Type aliases for unions, intersections. Interfaces preferable for API types (can be extended).

Manual vs generated types: Generated saves time, catches details you might miss. Manual gives more control (better naming, precise optionality). Use generated as starting point, refine.

JSON Schema to TS vs JSON to TS: JSON Schema is explicit type description. JSON is example data. From JSON Schema you get more precise types (required fields, formats). From JSON sample, you get inferred types.

Runtime vs compile-time types: TypeScript types are compile-time (erased in JS output). For runtime validation, pair types with Zod, Yup, or io-ts — validate JSON matches expected type at runtime.

TypeScript vs Flow: Flow (Facebook's type checker) similar to TS but less adopted. TS is dominant. Generated types here target TypeScript.