JSON to Python Class Converter

From dicts to typed classes

json.loads gives you nested dicts and lists, which means no autocomplete, no type checking with mypy or Pyright, and KeyErrors at run time. Typed classes fix that, but writing them for a large payload by hand is tedious. Paste an API response, a config file or an event payload here and get class definitions with type hints for every field.

Style: dataclasses or Pydantic v2

The Style option decides what kind of class is generated.

dataclasses (the default) produces @dataclass classes using only the standard library. They describe the data but do not parse it: you build instances yourself, e.g. Address(**data["address"]), and nested objects are not converted automatically. Good for lightweight scripts and when you already validate elsewhere.

Pydantic v2 produces BaseModel subclasses. Root.model_validate(data) parses the whole nested structure, converts nested dicts into model instances and raises a readable error when the data does not match. Choose it for FastAPI apps, settings files and any input you do not control. A top-level array becomes a RootModel, for example class Root(RootModel[List[int]]).

Types and field names

• Objects become classes named after their key (address → Address, items of orders → Order), and the Root type name option (default Root) names the top-level class.
• Whole numbers become int, values with a decimal point or exponent become float, plus str and bool. Arrays use List[...].
• Every object in an array is merged into one class. Keys that are missing in some items, or null in some, become Optional[...] = None; a key that is only ever null is typed None.
• Fields with defaults are placed after required ones, as dataclasses require.
• Keys are turned into snake_case attribute names: firstName becomes first_name and created-at becomes created_at. Python keywords are prefixed with the class name, so class becomes root_class.

In Pydantic mode every renamed field carries Field(alias="firstName"), so validation reads the original JSON keys. Dataclasses have no alias mechanism: when a key was renamed, map it yourself before constructing the object.

Imports use the typing module (List, Optional), which works on every supported Python 3 version.

Limits

Inference sees only your sample, so strings stay str even when they look like dates, UUIDs or enum values; refine those hints by hand (datetime, UUID, Literal[...]). Mixed-type arrays become Union types. Python integers have arbitrary precision, but the sample is inferred through JavaScript numbers, so an integer beyond 2^53 is flagged with a warning and typed as float; change it back to int. The conversion runs in your browser. Tidy the result with the Python formatter if you change it.

Examples

{
  "id": 1042,
  "firstName": "Aisha",
  "email": "aisha.tan@example.com",
  "address": { "city": "Singapore", "postcode": "018956" },
  "orders": [
    { "id": "ord_1", "total": 129.9, "note": null },
    { "id": "ord_2", "total": 79 }
  ]
}

from dataclasses import dataclass
from typing import List


@dataclass
class Address:
    city: str
    postcode: str


@dataclass
class Order:
    id: str
    total: float
    note: None = None


@dataclass
class Customer:
    id: int
    first_name: str
    email: str
    address: Address
    orders: List[Order]

{
  "event-type": "payment.succeeded",
  "createdAt": "2026-09-14T08:21:05Z",
  "data": { "amount": 12990, "currency": "SGD", "metadata": { "orderId": "ord_8f2k1" } },
  "livemode": false
}

from pydantic import BaseModel, Field


class Metadata(BaseModel):
    order_id: str = Field(alias="orderId")


class Data(BaseModel):
    amount: int
    currency: str
    metadata: Metadata


class WebhookEvent(BaseModel):
    event_type: str = Field(alias="event-type")
    created_at: str = Field(alias="createdAt")
    data: Data
    livemode: bool

Common errors and how to fix them

Related tools

• cURL to Python requests
• Python formatter
• JSON formatter
• JSON to TypeScript
• JSON to JSON Schema
• python jsondecodeerror expecting value