Why Generate TypeScript from JSON?

TypeScript interfaces provide type safety for your JSON data. Instead of manually writing interfaces, generate them automatically from API responses or sample JSON data.

Example Conversion

Input JSON:

{
  "id": 1,
  "name": "John Doe",
  "email": "john@example.com",
  "isActive": true
}

Generated TypeScript:

interface User {
  id: number;
  name: string;
  email: string;
  isActive: boolean;
}

Features

• Nested object support — Creates separate interfaces for nested objects
• Array type inference — Detects array item types automatically
• Custom root name — Name your root interface anything you want
• Special character handling — Properly quotes keys with special characters

Type Inference Rules

Handling Nested Objects

Nested objects automatically get their own interfaces with descriptive names:

// Input
{
  "user": {
    "profile": {
      "name": "John"
    }
  }
}

// Output
interface RootUserProfile {
  name: string;
}

interface RootUser {
  profile: RootUserProfile;
}

interface Root {
  user: RootUser;
}

Working with API Responses

Common workflow for typing API data:

1. Make an API request and copy the JSON response
2. Paste it into this tool
3. Name the root interface (e.g., ApiResponse)
4. Copy the generated interfaces to your TypeScript project
5. Use with fetch or your HTTP client

// Usage in TypeScript
const response = await fetch('/api/users');
const data: User[] = await response.json();

// Now you have full type safety
data.forEach(user => {
  console.log(user.name); // TypeScript knows this is a string
});

Pro Tips

• 💡 Use representative data — Include all possible fields in your sample JSON for complete interfaces
• 💡 Handle optional fields — If a field might be missing, manually add ? after generation
• 💡 Union types — For fields that can be multiple types, consider using union types manually
• 💡 Validate first — Use the JSON Validator to ensure your JSON is valid before converting

Limitations

• Cannot detect optional properties (all properties are required)
• Cannot infer union types for non-array values
• Date strings are typed as string, not Date

For these cases, manually adjust the generated interfaces after copying.

Related Tools

• JSON Validator — Validate your JSON first
• JSON Schema Validator — Another way to define JSON structure
• JSON to CSV — Export JSON data

Common Mistakes & Pro Tips

• A single sample can't reveal optional fields — The generator infers types from one JSON object, so a property that happens to be present is marked required even if your real data sometimes omits it. After generating, manually add `?` to fields that are sometimes absent (e.g. `avatar?: string`) — otherwise the compiler will demand them everywhere.
• null becomes a union, not optional — A value of `null` in the sample produces a type like `string | null`, which is different from an optional `string?`. `T | null` means the key is present but may be null; `T?` means the key may be missing. If both can happen, you want `field?: T | null`.
• Mixed-type arrays collapse to unions or any — An array like `[1, "two", true]` yields `(number | string | boolean)[]`, and an array of differently-shaped objects produces a union of interfaces. An empty array `[]` gives no element information, so it defaults to `any[]` — narrow it manually to the real element type.
• Every JSON number is just `number` — TypeScript has a single `number` type, so there is no int/float distinction and no `bigint` inference. If a field holds a 64-bit integer ID that exceeds Number.MAX_SAFE_INTEGER, keep it as a `string` in your API and type it as `string`, because JSON.parse will silently lose precision.
• Keys that aren't valid identifiers get quoted — JSON keys like `"first-name"`, `"2fa"`, or keys with spaces can't be bare identifiers, so they're emitted as quoted property names (`"first-name": string`). Access them with bracket notation (`obj["first-name"]`), and remember the JSON key is preserved exactly — TypeScript does no camelCase conversion at runtime.