JSON to Code

Generate type definitions from JSON objects. Infers structure and produces idiomatic interfaces, dataclasses, structs, or types for your target language.

Overview

The JSON to Code tool analyzes a JSON value and generates:

TypeScript — Interfaces with proper type annotations
Python — Dataclasses with type hints
Go — Structs with json tags
Rust — Structs with Serde derives

Supports nested objects, arrays, and primitive types. Field names are sanitized to valid identifiers for each language.

Use Cases

API client generation

Generate types from API responses for type-safe client code

Schema scaffolding

Quickly scaffold type definitions from example JSON data

Migration

Port JSON structures between languages with correct naming conventions

Documentation

Auto-generate type definitions for documentation or code review

Input Format

Paste a JSON object or array. The tool accepts:

Strict JSON
Relaxed JSON (unquoted keys, single quotes, trailing commas)
Nested objects and arrays

Example

{
  "user": {
    "id": 123,
    "name": "Alice",
    "email": "[email protected]",
    "is_active": true,
    "tags": ["admin", "verified"]
  }
}

Output Formats

TypeScript
Python
Go
Rust

Generates interfaces with TypeScript type annotations. Keys that aren’t valid identifiers (e.g., "first-name") are quoted.

interface User {
  id: number;
  name: string;
  email: string;
  is_active: boolean;
  tags: string[];
}

interface Root {
  user: User;
}

Generates @dataclass classes with type hints (int, float, str, bool, List, Optional). Field names are converted to snake_case.

from dataclasses import dataclass
from typing import Any, List, Optional

@dataclass
class User:
    id: int
    name: str
    email: str
    is_active: bool
    tags: List[str]

@dataclass
class Root:
    user: User

Generates structs with json tags. Field names are converted to PascalCase.

package main

type User struct {
  Id       int64    `json:"id"`
  Name     string   `json:"name"`
  Email    string   `json:"email"`
  IsActive bool     `json:"is_active"`
  Tags     []string `json:"tags"`
}

type Root struct {
  User User `json:"user"`
}

Generates structs with #[derive(Debug, Serialize, Deserialize)] and #[serde(rename = "...")] when field names differ from Rust conventions.

use serde::{Deserialize, Serialize};

#[derive(Debug, Serialize, Deserialize)]
pub struct User {
    pub id: i64,
    pub name: String,
    pub email: String,
    pub is_active: bool,
    pub tags: Vec<String>,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct Root {
    pub user: User,
}

Type Inference Rules

Primitives

null → null (TS), Optional[Any] (Python), interface{} (Go), Option<serde_json::Value> (Rust)
true/false → boolean, bool, bool, bool
Numbers → number (TS), int/float (Python), int64/float64 (Go), i64/f64 (Rust)
Strings → string, str, string, String

Arrays

Empty arrays → unknown[], List[Any], []interface{}, Vec<serde_json::Value>
Non-empty → Infers element type from first item: T[], List[T], []T, Vec<T>

Objects

Each object becomes a named interface/struct/class
Field names are sanitized:
- TypeScript: Invalid identifiers are quoted
- Python: Converted to snake_case, comments preserve original names
- Go: Converted to PascalCase, json tags preserve original names
- Rust: Converted to snake_case, #[serde(rename)] when needed

Implementation Details

The tool recursively traverses the JSON structure, collecting type definitions in a Map to avoid duplicates. Each target language has its own infer() function and naming conventions. Source: lib/tools/json-to-code.ts:5-143

Type inference is heuristic. For arrays, the tool infers the type from the first element only. Heterogeneous arrays will produce inaccurate types.

Keyboard Shortcuts

Cmd/Ctrl+Enter — Generate TypeScript (default)
Cmd/Ctrl+Shift+C — Copy output
Cmd/Ctrl+Shift+S — Download output

JSON Format/Validate

Validate and format JSON with prettify/minify

JSON to YAML

Convert JSON to YAML format

cURL to Code

Convert cURL commands to code

Encoding & Encryption

Escaping & Entities

Preview & Comparison

Format Converters

Code Beautifiers

Generators

Data Transformers

JSON to Code

JSON to Code

Overview

Use Cases

API client generation

Schema scaffolding

Migration

Documentation

Input Format

Output Formats

Type Inference Rules

Implementation Details

Keyboard Shortcuts

JSON Format/Validate

JSON to YAML

cURL to Code

Build docs developers (and LLMs) love

Encoding & Encryption

Escaping & Entities

Preview & Comparison

Format Converters

Code Beautifiers

Generators

Data Transformers

​JSON to Code

​Overview

​Use Cases

API client generation

Schema scaffolding

Migration

Documentation

​Input Format

​Output Formats

​Type Inference Rules

​Implementation Details

​Keyboard Shortcuts

​Related Tools

JSON Format/Validate

JSON to YAML

cURL to Code

Build docs developers (and LLMs) love

JSON to Code

Overview

Use Cases

Input Format

Output Formats

Type Inference Rules

Implementation Details

Keyboard Shortcuts

Related Tools