JSON to Python Converter

Data engineers materializing API responses into typed models, backend developers writing a Pydantic-adjacent dataclass by hand, and script writers who keep re-parsing the same nested JSON with bracket notation all share a common friction point. Transcribing a payload into a Python class is slow, error-prone, and easy to get subtly wrong on the first pass.

Paste your JSON and this converter emits a Python dataclass, TypedDict, or plain typed class for every nested object, with correct int, float, str, bool, and list annotations. It runs entirely in the tab, so sample payloads containing internal IDs or customer data never leave the machine.

How the conversion works

The converter walks the parsed JSON tree and maps each value to a Python type. Whole numbers become int, decimal numbers become float, true and false become bool, and null becomes None with an Optional annotation. Strings become str, arrays become list of the element type, and every distinct nested object becomes its own class so nesting is preserved instead of flattened.

Field names are converted to PascalCase and any Python keyword collision is escaped with a trailing underscore, so a field named class becomes class_. In dataclass mode a field whose sample value is null receives a None default so instantiating without it works. In TypedDict mode every field is required, which matches how mypy validates dict literals.

The generated code uses only the standard library. Copy it into a .py file and import it directly, no pip install required.

Before and after: a typical API response

Input, a JSON payload from a user endpoint:

{ "id": 42, "name": "Ada Lovelace", "active": true,
  "tags": ["math", "code"],
  "address": { "city": "London" } }

Output, dataclass style:

from __future__ import annotations
from dataclasses import dataclass, field
from typing import Optional

@dataclass
class Root:
    Id: int
    Name: str
    Active: bool
    Tags: list[str]
    Address: Optional[Address] = None

@dataclass
class Address:
    City: str

Who converts JSON to Python with this tool

Common mistakes when generating Python from JSON

• Confusing TypedDict with a dataclass. A TypedDict does not create a real class at runtime, it only describes a dict shape for type checkers. If you try to instantiate it like a class or access attributes with dot notation, you get a runtime error. Use the dataclass style when you want objects, TypedDict when you want dict validation.
• Assuming every number is an int. A field that looks like a small integer in one sample but carries decimals in another becomes float. If you know a field is always integral, switch the annotation to int by hand. Leaving it as float is safe for mypy but loses precision intent.
• Deleting the trailing underscore on keyword fields. A JSON field named class or import becomes class_ or import_ in Python. Removing the underscore makes the file fail to compile. Keep the suffix or rename the field and adjust the mapping manually.
• Ignoring Optional defaults on null fields. In dataclass mode a field whose sample was null gets a None default so you can construct the object without it. If you delete the default but the API sometimes omits the field, deserialization with a plain dict-to-dataclass helper will raise a TypeError. Keep the default.

Best practices for JSON to Python workflows

• 1.Paste a realistic sample with real nesting and at least one array so every class the converter emits is exercised by your actual data shape.
• 2.Pick dataclass when you want objects and TypedDict when you want mypy to validate dict keys, and confirm with one round-trip test before committing.
• 3.Keep the from __future__ import annotations line so forward references to nested classes do not raise at definition time on Python 3.9 and earlier.
• 4.Regenerate and diff when the upstream API changes, rather than editing annotations by hand, so new fields are not silently dropped.

Frequently asked questions