JSON to Python Dataclass Converter – Free | JsonToTable

Python Output

Dataclass source will appear here

Drop JSON on the left; annotated @dataclass modules show up on the right.

Sample: warehouse inventory with manager, SKU list, null holdReason, lastAudit

Converting posts the sample JSON to /api/convert, which returns Python dataclass source. The request body is not written to a database and is omitted from application logs. A short-lived in-memory cache may retain the result for up to one hour. Remove credentials and PII before you convert.

Generate Python Dataclasses from JSON in Three Steps

Start from a live API body, inspect the @dataclass modules, then drop them into your package before wiring json.loads.

1

Step 1 – Capture a Real Response Body

Use a FastAPI, Flask, or Django JSON body that matches production. Upload a .json file if that is easier. Broken syntax? Clean it with the JSON validator first.

📄

Paste or upload - Objects, arrays, or files up to 1 MB.

🧭

Immediate parse errors - Invalid JSON is flagged before conversion.

Warehouse inventory sample

{
  "warehouseId": "WH-42",
  "region": "apac",
  "manager": {
    "name": "Aiko Sato",
    "badgeId": 1188,
    "onCall": true
  },
  "skus": [
    { "code": "PLN-01", "units": 40, "unitCost": 12.5, "fragile": false },
    { "code": "GLS-09", "units": 6, "unitCost": 88, "fragile": true }
  ],
  "lastAudit": "2026-10-28T09:15:00Z",
  "holdReason": null,
  "tags": ["priority", "cold-chain"]
}

2

Step 2 – Skim Root and Nested Classes

Root holds top-level fields. Nested objects such as manager become sibling @dataclass types. Arrays of objects typically become List[Skus]-style collections with snake_case attributes.

🧬

Typing annotations - str, int, float, bool, List, Optional, datetime.

🧩

Nested dataclasses - One class per distinct object shape.

Emitted dataclasses

from dataclasses import dataclass
from typing import List
from datetime import datetime


@dataclass
class Manager:
    name: str
    badge_id: int
    on_call: bool


@dataclass
class Skus:
    code: str
    units: int
    unit_cost: float
    fragile: bool


@dataclass
class Root:
    warehouse_id: str
    region: str
    manager: Manager
    skus: List[Skus]
    last_audit: datetime
    hold_reason: None
    tags: List[str]

3

Step 3 – Save into Your Package

Copy or download the .py text, place it under your models package, then construct instances after json.loads (or via dacite / mashumaro).

⬇️

Download .py - Named json-to-python-<timestamp>.py.

📋

One-click copy - Clipboard gets the full module.

⚡Take the dataclasses into your repo

2 Actions

⬇️

Download

json-to-python-<date>.py

📋

Copy

Full Python module

💡Tip: replace literal None annotations with Optional before merging.

How Sample Values Become Python Types

A quick map from JSON literals to the annotations this converter emits.

JSON value → Python annotation

Seen in the sample	Written in the dataclass
Text value	`str`
Whole number	`int`
Number with a fraction	`float`
true / false	`bool`
Object value	`Nested @dataclass`
Array of similar objects	`List[NestedClass]`
Array of strings	`List[str]`
ISO-8601 timestamp string	`datetime annotation`
Key absent on some array items	`Optional[T] = None`
Key always null in the sample	`Literal None (widen before shipping)`

Snake Case Names and Partial Objects

How identifiers are cleaned up and how sparse array rows become Optional fields.

Messy key cleanup

Reserved words, digits-first keys, hyphens and spaces are folded into legal snake_case fields.

Dataclass after key cleanup

# {"api-key":"k","class":"demo","3dModel":1,"XMLHttp":true,"order id":9}

from dataclasses import dataclass


@dataclass
class Root:
    api_key: str
    root_class: str
    the_3_d_model: int
    xml_http: bool
    order_id: int

Catalog rows with gaps

Shared code / units stay required. Row-specific fragile and label become Optional defaults.

Dataclass for sparse rows

# [{"code":"PLN-01","units":40,"fragile":true},{"code":"GLS-09","units":6},{"code":"BOX-02","units":12,"label":"fragile"}]

from dataclasses import dataclass
from typing import Optional


@dataclass
class RootElement:
    code: str
    units: int
    fragile: Optional[bool] = None
    label: Optional[str] = None

Construct Root After json.loads

A minimal pattern for mapping camelCase JSON onto snake_case dataclasses.

Manual mapping sketch

Build nested Manager / Skus instances, then call asdict when you need a JSON-friendly dict again.

Construction sketch

import json
from dataclasses import asdict
from datetime import datetime

# After pasting the generated dataclasses into models.py:
raw = json.loads(payload)

# Lightweight construction when shapes already match:
root = Root(
    warehouse_id=raw["warehouseId"],
    region=raw["region"],
    manager=Manager(**{ "name": raw["manager"]["name"], "badge_id": raw["manager"]["badgeId"], "on_call": raw["manager"]["onCall"] }),
    skus=[Skus(code=s["code"], units=s["units"], unit_cost=s["unitCost"], fragile=s["fragile"]) for s in raw["skus"]],
    last_audit=datetime.fromisoformat(raw["lastAudit"].replace("Z", "+00:00")),
    hold_reason=raw["holdReason"],
    tags=list(raw["tags"]),
)

print(root.manager.name, root.last_audit.isoformat())
print(json.dumps(asdict(root), default=str))

JSON to Python Dataclass FAQs

Dataclasses, Optional fields, datetime parsing, snake_case keys and privacy

Can I turn an API JSON response into Python dataclasses?

Yes. Drop a realistic payload into the workspace. The service returns @dataclass definitions with typed attributes, nested classes for objects, and List[…] for homogeneous arrays. Download the .py file or copy it into models.py.

Will I get Pydantic BaseModel classes?

No. Output uses the standard library dataclasses module so it imports cleanly without pydantic, attrs, or msgspec. You can hand-migrate fields into BaseModel later if your stack already depends on Pydantic.

Why do some attributes show Optional[…] = None?

Across an array sample, keys that appear on only a subset of elements are marked Optional and defaulted to None. Keys present on every element stay required with no default value.

How should I parse datetime fields after generation?

Annotations may use datetime for ISO-8601 strings, but json.loads still yields str. Convert with datetime.fromisoformat after swapping a trailing Z for +00:00, or feed the dict through a helper such as dacite before constructing Root.

What if a field is typed as None instead of Optional[str]?

When every sample value for a key is JSON null, the emitter can produce a literal None annotation (for example hold_reason: None). Change it to Optional[str], Optional[Any], or another concrete type before you ship.

Do camelCase JSON keys stay camelCase in Python?

They become snake_case attributes (warehouseId → warehouse_id). Awkward keys with hyphens, spaces, or reserved words are rewritten into legal identifiers such as api_key or root_class.

Should I use list[str] or typing.List[str]?

Generated source follows the quicktype Python 3.7 profile with typing.List / Optional. On 3.9+ you may rewrite those to built-in generics; behavior of the models does not change.

Is my JSON stored when I convert?

The browser sends the sample to /api/convert for dataclass generation, then displays the returned .py text. We do not store the payload in durable storage or echo it into request logs. Cached results may live in memory for at most one hour. Scrub secrets beforehand.

JSON EDITOR

Edit, format, and beautify JSON

JSON VALIDATOR

Validate, fix, and inspect JSON

JSON ANALYZER

Compare, measure, and map JSON

EXPORT & SHARE

Convert JSON to other formats

IMPORT TO JSON

Convert other formats to JSON

XML TOOLS

Convert, format, fix, and minify XML

CODE & FORMATTERS

Generate code and format other languages