How do I convert JSON to a Python class?

Paste JSON into the formatter above. The generator infers each field type (str, int, float, bool, None, list, dict), produces one class per nested object, and emits either @dataclass declarations or Pydantic BaseModel classes depending on the mode you pick. Dataclasses are standard-library and have zero runtime cost; Pydantic adds validation at the cost of a dependency.

Should I use dataclass or Pydantic for JSON parsing?

Use @dataclass when you trust the JSON source (internal services, your own API) and want zero dependencies and maximum speed. Use Pydantic (or Pydantic v2 / msgspec) when the JSON comes from an untrusted source and you want runtime validation, coercion, and clear error messages. Pydantic also integrates with FastAPI for free OpenAPI schema generation.

How are optional fields detected?

For arrays of objects, if a key appears on some items but not others, it is typed as Optional[T] with a default of None. If a value is explicitly null in the sample, the type becomes Optional[T]. In Pydantic mode, the Field(default=None) is added so .model_dump() preserves the None vs absent distinction. In Python 3.10+ the generator uses the X | None union syntax instead of Optional[X].

How do I load the JSON into the generated class?

For a dataclass: use dataclasses.asdict() to serialise and a helper like `User(**data)` to construct — this works for flat dicts but recurses manually for nested fields. For Pydantic v2: User.model_validate(data) handles nested parsing automatically, and User.model_dump() serialises back. For Pydantic v1: User.parse_obj(data) and .dict(). The generator emits a small example `from_dict` helper for dataclasses so you don't have to write it.

Why does my generated class have Any as a field type?

Any appears when the generator can't infer a concrete type — usually from an empty list (list has no element to inspect) or an all-null field (no non-null sample seen). Fix by providing a larger JSON sample with at least one non-null, non-empty example of that field. If the field genuinely holds arbitrary values, keep Any (dataclass) or Field(default=None) with no type (Pydantic).

Does the converter upload my JSON?

No. The entire conversion runs in your browser as JavaScript. You can paste real API responses with sensitive data without it leaving your tab.

JSON to Python Class — Generate Dataclass or Pydantic Models (Free)

Paste JSON and get a Python @dataclass or Pydantic BaseModel with correct type hints, Optional fields, and nested models.

Why Convert JSON to a Python Class?

Python can load JSON into a dict with one line, but then every access becomes data["user"]["profile"]["bio"]and your IDE can't help with autocomplete or typo detection. A class gives you dot access, type hints, equality, and (with Pydantic) validation. For API clients, data pipelines, and any Python 3.7+ project, typed classes are standard practice — generating them from a real JSON sample saves tedious hand-typing.

Example: Dataclass Output

Given this JSON:

{
  "id": 42,
  "name": "Ada Lovelace",
  "email": "[email protected]",
  "verified": true,
  "roles": ["admin", "editor"],
  "profile": {
    "bio": "Mathematician",
    "avatar": null,
    "website": "https://ada.dev"
  }
}

The @dataclass output:

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

@dataclass
class Profile:
    bio: str
    avatar: Optional[str]
    website: str

@dataclass
class User:
    id: int
    name: str
    email: str
    verified: bool
    roles: List[str]
    profile: Profile

# Load:
def from_dict(cls, data):
    import dataclasses, inspect
    kwargs = {}
    for f in dataclasses.fields(cls):
        v = data.get(f.name)
        if dataclasses.is_dataclass(f.type) and isinstance(v, dict):
            v = from_dict(f.type, v)
        kwargs[f.name] = v
    return cls(**kwargs)

user = from_dict(User, data)

Example: Pydantic Output

from pydantic import BaseModel
from typing import List, Optional

class Profile(BaseModel):
    bio: str
    avatar: Optional[str] = None
    website: str

class User(BaseModel):
    id: int
    name: str
    email: str
    verified: bool
    roles: List[str]
    profile: Profile

# Load (Pydantic v2):
user = User.model_validate(data)

# Serialise back:
json_str = user.model_dump_json()

Dataclass vs Pydantic vs attrs vs msgspec

@dataclass — standard library, zero cost. No validation at runtime; type hints are hints only. Pick this for internal data classes and when you trust the input.
Pydantic v2 — the de facto standard for API models. Validates, coerces, and serialises automatically. 10× faster than Pydantic v1 (Rust-backed core). Pairs natively with FastAPI.
attrs — predates dataclass and still has features it lacks (slots, converters, validators). Pick if you need the extras.
msgspec— "Pydantic but 50× faster and no validation". Optimised for serialising/deserialising large payloads. Pick when raw throughput matters and the data is already clean.

Type Mapping Reference

"abc" → str
42 → int
3.14 → float
true / false → bool
null → Optional[X] or X | None (3.10+)
[1, 2] → List[int] or list[int] (3.9+)
{...} → nested class
Mixed array → List[Union[A, B]] or just List[Any]

Handling Dates, Decimals, and Enums

JSON timestamps come as strings. In Pydantic, type the field as datetime and Pydantic parses ISO-8601 automatically. In a dataclass, keep it as str and call datetime.fromisoformat() at use sites, or write a __post_init__ that converts the string in place.

For money amounts always use decimal.Decimal rather than float — floats lose precision on 0.1 + 0.2 and will silently corrupt accounting data. Pydantic has a condecimal helper for validation (max/min digits, decimal places).

Enums (fields with a known fixed set of values) can be typed as Literal["admin", "editor"] in both dataclasses and Pydantic. Pydantic will raise a clear error if an unknown value arrives.

Custom Validators (Pydantic)

from pydantic import BaseModel, field_validator, EmailStr

class User(BaseModel):
    id: int
    name: str
    email: EmailStr   # validates format
    roles: list[str]

    @field_validator("roles")
    @classmethod
    def not_empty(cls, v):
        if not v:
            raise ValueError("User must have at least one role")
        return v

# User(id=1, name="Ada", email="bad") 
#   → ValidationError: email is not a valid email

Common Pitfalls

Mutable default values. In a dataclass, roles: List[str] = [] is a bug — the list is shared across instances. Use roles: List[str] = field(default_factory=list). Pydantic handles this correctly by default.
Reserved keywords. JSON often contains fields like type, class, from which clash with Python keywords. In Pydantic use Field(alias="type") and name the attribute type_. For dataclasses, rename the attribute and handle translation in from_dict.
Big integers. Python handles arbitrary-precision integers natively — no overflow worries like Go or JavaScript.
Unknown fields. Pydantic v2 ignores unknown JSON keys by default. Set model_config = ConfigDict(extra="forbid") to raise an error — useful during API development to catch backend changes early.

Related Tools