JSON to Python

Related

About JSON to Python: Turning JSON data into runnable dataclass models

Use Cases

• REST API integration: Convert backend JSON responses to Python @dataclass, use with requests + json for strongly typed HTTP request parsing. With mypy or pyright, get real-time attribute completion and type checking in your IDE to avoid common spelling errors.
• FastAPI request/response models: Convert example JSON from API interface documentation into Pydantic BaseModel templates to unify frontend and backend model definitions. We recommend enabling the response_model parameter in FastAPI projects to let OpenAPI docs auto-generate field examples and validation rules.
• Django Ninja / DRF serializers: Convert JSON responses to dataclass, then manually add DRF's ModelSerializer or Ninja's Schema-derived classes. DRF's ModelSerializer can auto-generate validation rules based on dataclass; Ninja's Schema can also directly reuse this tool's output.
• Web scraper data modeling: Convert JSON data scraped from web pages to dataclass to avoid field omissions and spelling errors caused by dynamic dict access. When used with async scraper libraries like requests-html, playwright, dataclass also reduces boilerplate for JSON deserialization.
• Machine learning feature definition: Convert JSON schemas for scikit-learn / pandas training data to dataclass to standardize feature field names and types. sklearn Pipeline.fit(X, y) accepts data structures with type hints; dataclass + asdict is an efficient bridge for converting to/from pandas DataFrames.
• Configuration file deserialization: Convert YAML/JSON configuration file examples to dataclass, use with Hydra / OmegaConf for strongly typed configuration reading. With Hydra's @dataclass decoration, configurations enjoy autocompletion in your IDE, avoiding common spelling errors and type inconsistencies in YAML configs.
• Jupyter Notebook temporary structures: Convert JSON samples from exploratory data analysis to dataclass for easy attribute access and IDE completion in Notebooks. Wrapping JSON responses with dataclass in Notebooks significantly improves readability of exploratory analysis code, making subsequent refactoring into production modules easier.
• Microservice interface definition: Convert example JSON request bodies for gRPC/HTTP services to Python types to unify server-side model definitions. After converting gRPC protobuf to JSON, converting to dataclass serves as a strongly typed model for backend services, aligned with frontend TypeScript types.
• CLI tool development: Convert CLI configuration JSON examples to dataclass, use with argparse for configuration deserialization and validation. Converting argparse Namespace to dataclass only requires one line: dataclass(**vars(args)), which is safer than hand-written parsing logic.
• Test data construction: Convert real JSON fixtures returned by backend to Python types, use dataclasses.replace for test data driving in pytest. pytest's parametrize decorator combined with dataclass constructs typed test fixtures with clearer failure messages.
• Structured log parsing: Convert JSON logs captured by ELK / Loki to dataclass for easy filtering and alerting rules. After wrapping ELK JSON logs with dataclass, you can do precise field filtering and aggregation queries, safer than dict access.
• Configuration center migration: Convert JSON configs from Apollo / Nacos / Consul to Python types for server-side configuration hot reloading. Apollo / Nacos JSON configs can be bidirectionally validated with dataclass, immediately detecting missing fields, type mismatches, and other issues on config changes.
• Cross-language collaboration: When integrating Python backend with TypeScript frontend, convert the same JSON to Python dataclass and TS interface respectively to keep both sides consistent. In cross-language collaboration scenarios, Python backend + TS frontend share the same JSON sample, generating dataclass and interface respectively to keep field names consistent.
• Database migration: Convert JSON documents exported from MongoDB / PostgreSQL JSONB fields to Python models as reference for ORM entity definitions. Converting MongoDB JSONB document exports to dataclass serves as field reference for ORM entities, easier to maintain than reading MongoDB documents directly.
• Blockchain/Web3: Convert on-chain JSON RPC responses to Python dataclass for type wrapping in SDKs like web3.py. Ethereum SDKs like web3.py, eth-brownie all support dataclass-style return values, convenient for secondary wrapping.
• Data science ETL: Convert upstream JSON data sources to dataclass, then use pandas DataFrame.from_records to convert to tables for downstream analysis. pandas DataFrame.from_records([asdict(d) for d in dataclass_list]) converts nested structures to tables in one line.
• OpenAPI Schema validation: Convert example JSON from OpenAPI docs to Python models, then write Pydantic validation logic. OpenAPI example fields can be directly copied into this tool's input; generated Pydantic models automatically validate API documentation consistency.
• Teaching examples: Convert example JSON to dataclass in Python courses to explain concepts like the typing module, type hints, automatic __init__ generation, etc. When explaining concepts like typing module, automatic __init__ generation, slots in Python courses, dataclass is the most intuitive demonstration vehicle.
• Field naming conversion: Convert snake_case JSON API responses to dataclass, then manually change field names or use Pydantic alias_generator for field mapping. Pydantic's alias_generator can be configured in BaseModel for automatic camelCase ↔ snake_case mapping, avoiding hand-written aliases.

How to Use

1. Paste JSON content into the left editor, or click the upload button to select a .json / .txt file
2. Wait 400ms for auto-conversion; generated Python dataclass code will appear on the right
3. If JSON is malformed, click the "Fix JSON" button to auto-repair common syntax issues
4. Click "Copy" to paste into your project's models/ directory, or click "Download" to save as model.py

Features

• Local browser conversion: JSON parsing and Python code generation happen entirely in your browser; input data is never uploaded to any server, so sensitive API responses are safe to use
• dataclass annotated output: Generates standard Python classes decorated with @dataclass, usable directly in Python 3.7+ projects with from __future__ import annotations
• Automatic type inference: str / int / float / bool / List[T] / Dict[str, Any] / Optional[Any] are automatically mapped from JSON values without manual field type specification
• Automatic nested object splitting: Nested JSON objects generate separate @dataclass classes named with PascalCase field names (e.g., address -> Address), avoiding duplicate type definitions
• Automatic List generic expansion: JSON arrays are automatically converted to List[T], with element types inferred from the first non-null element in the array, e.g., ["a","b"] -> List[str], [{...},{...}] -> List[Item]
• Optional fields: null fields generate Optional[Any] as a fallback, ensuring type annotations correctly express potentially missing fields
• 400ms debounce auto-conversion: Conversion triggers automatically after pasting, with real-time Python code preview on the right to reduce waiting and extra clicks
• One-click JSON error repair: Automatically fixes common formatting errors like trailing commas, single quotes, missing quotes, then continues generating code once repaired
• Copy and download: Copy all Python code with one click, or download as a model.py file to drop directly into your project root or models submodule
• localStorage input history: Automatically saves recent inputs locally, so you can quickly resume editing after refreshing or accidentally closing the page
• Responsive split-pane editing: Enter JSON on the left, view Python code on the right; supports drag-to-resize panel widths, adapted for large screens and mobile
• Supports Pydantic / attrs / TypedDict secondary adaptation: Generated dataclasses can have BaseModel or attrs decorators added with one click to adapt to FastAPI, Django Ninja, pydantic-settings, and other frameworks

Code Examples

# requirements.txt
# requests>=2.31

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


@dataclass
class Address:
    city: str
    zip: str


@dataclass
class User:
    id: int
    name: str
    active: bool
    address: Address
    tags: List[str]
    label: Optional[Any] = None


def main() -> None:
    resp = requests.get("https://api.example.com/users/1", timeout=10)
    resp.raise_for_status()

    # Directly deserialize JSON string to dataclass instance
    user: User = User(**resp.json())

    # Strongly typed access: IDE completion, mypy/pyright static checking
    print(f"{user.name} lives in {user.address.city}")
    print(f"tags: {user.tags}")


if __name__ == "__main__":
    main()

# pip install fastapi 'pydantic>=2'

from typing import List, Optional
from fastapi import FastAPI
from pydantic import BaseModel


class Address(BaseModel):
    city: str
    zip: str


class User(BaseModel):
    id: int
    name: str
    email: str
    active: bool = True
    address: Address
    tags: List[str] = []
    label: Optional[str] = None


app = FastAPI()


@app.post("/users")
async def create_user(user: User) -> dict:
    # FastAPI automatically validates request body with User; field type/required errors return 422
    return {"id": user.id, "name": user.name}


@app.get("/users/{user_id}", response_model=User)
async def get_user(user_id: int) -> User:
    # response_model auto-serializes response; OpenAPI docs auto-generated
    return User(
        id=user_id,
        name="Alice",
        email="alice@example.com",
        active=True,
        address=Address(city="Beijing", zip="100000"),
        tags=["fastapi", "pydantic"],
    )

from dataclasses import dataclass, asdict
from typing import List, Optional
import json


@dataclass
class Author:
    id: int
    name: str


@dataclass
class Article:
    id: int
    title: str
    url: str
    author: Author
    score: int
    tags: List[str]
    summary: Optional[str] = None


def parse_articles(raw_json: str) -> List[Article]:
    """Deserialize scraped JSON string into list of Articles."""
    payloads = json.loads(raw_json)
    return [Article(**payload) for payload in payloads]


if __name__ == "__main__":
    raw = '''[
        {
            "id": 1,
            "title": "Hello dataclass",
            "url": "https://example.com/p/1",
            "author": {"id": 10, "name": "Alice"},
            "score": 95,
            "tags": ["python", "typing"],
            "summary": "quick intro"
        }
    ]'''

    articles = parse_articles(raw)
    for art in articles:
        # IDE autocompletes author.name, tags, summary
        print(f"[{art.score}] {art.title} - {art.author.name}")
        print(f"  tags: {art.tags}")

        # Use asdict when dict form is needed (e.g., writing to MongoDB)
        doc = asdict(art)
        print(f"  mongo doc: {doc}")

# pip install pandas scikit-learn

from dataclasses import dataclass, field, asdict
from typing import List, Optional
import json
import pandas as pd
from sklearn.ensemble import RandomForestClassifier


@dataclass
class FeatureSchema:
    """Sample feature schema, fine-tuned after generation by JSON to Python tool."""
    user_id: int
    age: int
    city: str
    plan: str
    monthly_spend: float
    active: bool
    tags: List[str] = field(default_factory=list)
    last_login: Optional[str] = None


def features_to_frame(samples: List[dict]) -> pd.DataFrame:
    """Convert JSON list to DataFrame, automatically using dataclass field names as column names."""
    rows = [asdict(FeatureSchema(**row)) for row in samples]
    df = pd.DataFrame(rows)
    # One-hot encode categorical fields
    df = pd.get_dummies(df, columns=["city", "plan"], drop_first=True)
    return df


def main() -> None:
    raw = json.loads('''[
        {"user_id": 1, "age": 25, "city": "Beijing", "plan": "pro", "monthly_spend": 99.0, "active": true, "tags": ["new"]},
        {"user_id": 2, "age": 40, "city": "Shanghai", "plan": "free", "monthly_spend": 0.0, "active": false, "tags": []}
    ]''')

    X = features_to_frame(raw)
    y = [1, 0]  # Assume labels: paying user / free user

    model = RandomForestClassifier(n_estimators=100, random_state=42)
    model.fit(X, y)

    print("feature_columns:", list(X.columns))
    print("importances:", dict(zip(X.columns, model.feature_importances_)))

Best Practices

FAQ

Troubleshooting

Glossary

dataclass

Python 3.7+ standard library decorator (@dataclass) used to automatically generate magic methods like __init__, __repr__, __eq__. This tool generates @dataclass classes, e.g., @dataclass class User: id: int; name: str. Essentially decouples "data storage" from "data operations", letting classes focus on describing data fields while the decorator auto-generates boilerplate methods.

typing module

Python standard library for type hints, providing generic types like List, Dict, Optional, Any, Union. List[T], Optional[Any] generated by this tool come from the typing module. Python 3.9+ can directly use built-in list, dict. Alongside collections.abc, contextlib, etc., it's the core module for static type constraints in Python standard library; gradually became standard for large projects since PEP 484.

Optional[T]

Optional type from the typing module, equivalent to Union[T, None], indicating a field may be None. This tool maps JSON null to Optional[Any], which can be manually changed to more precise types like Optional[str]. Note that Optional[T] differs from T = None default: the former is a type-level None expression, the latter is a value-level default setting.

List[T]

Python generic list type. This tool automatically maps JSON arrays to List[T], e.g., string arrays map to List[str], object arrays to List[Item]. Python 3.9+ can write list[T]. The tool imports from typing by default, equivalent to Python 3.9+'s built-in list[T]; if your team prefers new syntax, replace the import with one click.

Any

Special type from the typing module indicating acceptance of any type. This tool defaults to using Any as a fallback for null values and empty arrays to avoid type inference errors. Frequent use of Any disables mypy / pyright checking; we recommend changing to precise types like Optional[str], List[int] after determining field types.

Pydantic BaseModel

Base data model class from the Pydantic library, providing runtime data validation, serialization, and deserialization. dataclasses generated by this tool can be adapted to BaseModel with one click for FastAPI request body validation. Pydantic v2 rewrote core validation logic in Rust, with 5-50x performance improvement over v1; dataclasses generated by this tool can also inherit BaseModel to enjoy this acceleration.

FastAPI

Modern Python web framework relying on Pydantic for automatic request body validation. dataclasses generated by this tool can serve as request/response model templates for FastAPI route functions. Based on Starlette + Pydantic, it auto-generates OpenAPI documentation and is one of the de facto standards for Python backend API frameworks today.

PEP 557

Python Enhancement Proposal defining the syntax and behavior of the dataclass decorator. Code generated by this tool fully complies with PEP 557 specifications. The proposal was initiated by Eric V. Smith in 2017, drawing design ideas from existing solutions like attrs and Haskell records.

Type Hint

Type annotations marked with : Type after Python function parameters and variables. dataclass fields generated by this tool all have type hints, enabling static type checking with mypy / pyright. Annotations themselves don't affect runtime behavior, only used for IDE hints, mypy / pyright static checking, and runtime validation libraries (like Pydantic).

PEP 484

Python type hint specification proposal defining the typing module and generic syntax. List[T], Optional[T], etc. generated by this tool follow PEP 484. Drafted by Guido van Rossum, Jukka Lehtosalo, Łukasz Langa, and others, it's the foundational document for Python's type hint system.

from __future__ import annotations

Deferred annotation evaluation statement introduced in PEP 563, storing all annotations as strings to avoid forward reference issues. Adding this line to dataclasses generated by this tool makes type annotation reference order irrelevant. When enabled, all annotations are lazily evaluated as strings, avoiding forward reference problems and decoupling dataclass field order from reference order.

model.py

Default filename downloaded by this tool, conforming to Python project conventions. Can be renamed to user.py, schemas.py, or other names matching project structure. Consistent with naming styles like Django's models.py, Flask's models.py; multi-model projects can split into submodules like user.py, order.py under a models package.

JSON Type to Python Type Mapping Cheat Sheet

The tool automatically infers corresponding Python types based on JSON value types:

Generated Python Code Structure Explanation

Typical code quicktype-core generates for Python includes the following parts:

Python Data Modeling Solution Comparison

The tool outputs @dataclass by default, but there are multiple data modeling options in the Python ecosystem; choose based on project needs:

Python Version and dataclass Feature Compatibility Table

Different Python versions have varying support for dataclass, typing, Pydantic; choose by version:

Privacy & Security

All operations of this JSON to Python tool happen completely locally in your browser: JSON parsing, Python code generation, and file downloads are all executed client-side via browser JavaScript; no JSON content, uploaded files, or generated code are sent over the network to any server. File uploads use the browser's native FileReader API to read directly into memory without passing through any intermediate services. No Cookie tracking is used, no user input or usage data is collected. After closing or refreshing the page, all input and output content is automatically cleared from memory. Suitable for processing JSON containing API keys, tokens, and sensitive business data.

Authoritative References

• PythonPython Official Documentation - dataclasses
• PythonPython Official Documentation - typing module
• PythonPEP 557 - Data Classes
• PydanticPydantic Official Documentation - Models
• FastAPIFastAPI Official Documentation - Request Body
• PythonPython Official Documentation - typing module
• attrsattrs Official Documentation
• PythonPEP 484 - Type Hints