JSON to TypeScript

What is JSON to TypeScript Conversion?

Paste a JSON payload and you get back TypeScript interfaces — typed contracts that describe exactly what properties an object has and what type each one holds. Without them, data from JSON.parse() arrives as any, giving you no editor assistance and no compiler checks on property access or assignment. Converting JSON to TypeScript gives you that safety without writing interfaces by hand.

TypeScript covers all six JSON value types: string, number, boolean, null, object, and array. Every nested JSON object turns into its own named interface. Arrays get typed from their first element. The result matches what JSON.parse() actually returns at runtime, so the interfaces reflect real data rather than guesswork.

Manually writing interfaces for large or deeply nested JSON is tedious and error-prone. A JSON to TypeScript generator reads the structure automatically, handles nesting recursively, and outputs clean interface code in seconds. This is especially useful when wiring up an unfamiliar API, prototyping with mock data, or migrating a JavaScript codebase to TypeScript. It also frees you from tracking nested property names and types by hand, so you can focus on application logic rather than type boilerplate.

Why Use a JSON to TypeScript Generator?

Generating TypeScript interfaces by hand is practical for small objects, but breaks down quickly with nested structures or large API responses. Consider a 50-field API response with three levels of nesting — writing that by hand means dozens of interfaces, each one a potential source of typos or missed nullable fields. An automated generator produces the full set in milliseconds and reduces the chance of type mismatches between your code and the data it consumes. Beyond accuracy, it keeps your types in sync with the actual API contract. When a service changes its response shape, simply paste the updated JSON and regenerate — far faster than hunting down every property that shifted across a handwritten interface file.

JSON to TypeScript Use Cases

JSON to TypeScript Type Mapping Reference

Every JSON value maps to a TypeScript type. The table below shows how each JSON primitive and structural type translates. This mapping follows the ECMA-404 JSON standard and TypeScript's built-in types.

TypeScript interface vs type Alias

TypeScript offers two ways to describe object shapes: interface declarations and type aliases. Both work for representing JSON structures, but they differ in extension and merging behavior. Most JSON-to-TypeScript generators output interfaces because they are the idiomatic choice for object shapes in TypeScript.

Code Examples

Below are examples of generating TypeScript interfaces from JSON in different languages and tools. Each snippet produces runnable output.

// Manual interface definition from a JSON shape
const json = '{"id": 1, "name": "Alice", "active": true}';
const parsed = JSON.parse(json);

interface User {
  id: number;
  name: string;
  active: boolean;
}

const user: User = parsed;
console.log(user.name); // "Alice" — fully typed

import JsonToTS from 'json-to-ts';

const json = {
  id: 1,
  name: "Alice",
  address: { street: "123 Main St", city: "Springfield" },
  tags: ["admin", "user"]
};

const interfaces = JsonToTS(json, { rootName: "User" });
console.log(interfaces.join("\n\n"));
// interface Address {
//   street: string;
//   city: string;
// }
//
// interface User {
//   id: number;
//   name: string;
//   address: Address;
//   tags: string[];
// }

# Install: pip install datamodel-code-generator
# Generate TypeScript-style types from JSON using Pydantic models

# Command line:
# datamodel-codegen --input data.json --output model.py

# Or generate TypeScript directly with quicktype:
# pip install quicktype
# quicktype --lang ts --src data.json --out types.ts

import json

data = {"id": 1, "name": "Alice", "scores": [98, 85, 92]}

# Python equivalent using TypedDict (Python 3.8+)
from typing import TypedDict, List

class User(TypedDict):
    id: int
    name: str
    scores: List[int]

user: User = data  # type-checked by mypy

# Install quicktype globally
npm install -g quicktype

# Generate TypeScript interfaces from a JSON file
quicktype --lang ts --src data.json --out types.ts

# From a JSON string via stdin
echo '{"id": 1, "name": "Alice"}' | quicktype --lang ts

# Output:
# export interface Root {
#   id:   number;
#   name: string;
# }

Frequently Asked Questions