Skip to content

JSON naar Python-klasse-omzetter

Plak JSON en krijg direct Python-klassen — dataclass, Pydantic v2 of TypedDict. Correcte Optional-typen, camelCase-aliassen, geneste klassen. 100% in je browser, gratis.

Geen tracking Draait in je browser Gratis
Uitvoer
0 tekens
Python-uitvoer
0 regels
Uitvoer geverifieerd tegen Python 3.12+-syntaxis en Pydantic v2-semantiek voor API-payloads uit de praktijk. — Go Tools Team · Jul 3, 2026

Wat is JSON naar Python-conversie?

JSON naar Python-conversie zet een JSON-voorbeeld om in kant-en-klare Python-klassen — een dataclass uit de standaardbibliotheek, een Pydantic v2-model of een TypedDict — zodat je nooit met de hand velddefinities schrijft voor een API-respons of configuratiebestand. Deze Python-klasse-generator leidt correcte typen af (int, float, str, bool, Optional), zet geneste objecten om in benoemde klassen en voegt Pydantic-aliassen toe voor camelCase-sleutels, allemaal 100% in je browser.

Voorbeelden

API-respons → dataclass

{"id":101,"name":"Ada Lovelace","email":"ada@example.com","active":true,"roles":["admin","user"]}
from dataclasses import dataclass
from typing import List


@dataclass
class Root:
    id: int
    name: str
    email: str
    active: bool
    roles: List[str]

Een typische REST-payload wordt een kant-en-klare @dataclass. Gehele getallen worden int, decimalen worden float, en arrays worden List[str].

Genest object (onderliggende klasse eerst)

{"repo":"pydantic","owner":{"login":"samuelcolvin","id":100}}
from dataclasses import dataclass


@dataclass
class Owner:
    login: str
    id: int


@dataclass
class Root:
    repo: str
    owner: Owner

Geneste objecten worden afzonderlijke, benoemde klassen. De onderliggende klasse (Owner) wordt vóór de bovenliggende uitgevoerd, zodat de code werkt zonder from __future__ import annotations.

camelCase → Pydantic v2-alias

{"login":"octocat","publicRepos":15,"createdAt":"2011-01-25"}
from pydantic import BaseModel, ConfigDict, Field


class Root(BaseModel):
    model_config = ConfigDict(populate_by_name=True)

    login: str
    public_repos: int = Field(alias="publicRepos")
    created_at: str = Field(alias="createdAt")

In de Pydantic-modus zijn velden snake_case met Field(alias=...) die terugverwijst naar de originele JSON-sleutel, en met populate_by_name kun je het model op beide manieren opbouwen — zodat validatie echte API-data heen en weer laat gaan.

Array van objecten → TypedDict (optionele sleutel)

{"users":[{"id":1,"nick":"x"},{"id":2}]}
from typing import List, Optional, TypedDict


class User(TypedDict):
    id: int
    nick: Optional[str]


class Root(TypedDict):
    users: List[User]

Arrays van objecten worden samengevoegd tot één elementtype. Een sleutel die in sommige items ontbreekt (nick) wordt Optional. TypedDict beschrijft de vorm van een gewone dict zonder enige runtime-overhead.

Zo zet je JSON om naar Python

  1. 1

    Plak je JSON

    Zet een JSON-object, array of API-respons in het invoerveld. De conversie start direct.

  2. 2

    Kies dataclass, Pydantic of TypedDict

    Schakel de uitvoerstijl om die bij je project past, en hernoem de root-klasse vanaf de standaard Root.

  3. 3

    Kopieer of download

    Haal de gegenereerde Python met één klik op en plak het rechtstreeks in je code.

Common Use Cases

Getypeerde API-clients
Zet een voorbeeldrespons van REST of GraphQL om in Pydantic-modellen of dataclasses voor een requests- of httpx-client, zonder velddefinities met de hand te schrijven.
Config- en fixture-parsing
Genereer modellen voor JSON-configuratiebestanden, testfixtures of webhook-payloads die je moet laden en valideren.
Snel prototypen en type-hints
Plak een onbekende payload om de vorm ervan direct als Python-typen te zien — een snelle manier om een nieuwe API te verkennen of TypedDict-hints toe te voegen aan bestaande dict-code.

Hoe de conversie werkt

Structurele afleiding
Elk object wordt een benoemde klasse; identieke vormen worden ontdubbeld, zodat je één klasse krijgt en geen kopieën. Arrays van objecten worden sleutel voor sleutel samengevoegd, en sleutels die in sommige items ontbreken, worden Optional.
Drie idiomatische doelen
dataclass houdt nul dependencies aan en behoudt geldige sleutels voor Root(**data); Pydantic v2 voegt Field-aliassen plus populate_by_name toe voor echte validatie; TypedDict beschrijft een gewone dict voor statische typecheckers, met functionele syntaxis wanneer een sleutel geen identifier is.
Correcte, dependency-arme typering
Gehele getallen worden int (willekeurige precisie, geen overflow), decimalen en exponenten worden float, en velden die alleen null zijn, worden Optional[Any]. typing-imports (Optional, List, Any) worden alleen toegevoegd wanneer ze daadwerkelijk worden gebruikt.
100% aan de clientzijde
Het parsen en genereren draait in je browser zonder netwerkaanroepen, zodat je data privé blijft.

Tips voor schone Python-modellen

Stem de modus af op de taak
Gebruik dataclass voor interne datahouders, Pydantic v2 wanneer je niet-vertrouwde invoer valideert of parset, en TypedDict wanneer je alleen statische type-hints over bestaande dicts nodig hebt.
Plak een representatief voorbeeld
Velden worden alleen als Optional gemarkeerd wanneer een voorbeeld ze weglaat, en waarden die alleen null zijn, vallen terug op Any. Een ingevuld, volledig voorbeeld levert de nauwkeurigste typen op.
Geef je root-klasse een naam
Stel een betekenisvolle rootnaam in (User, ApiResponse) in plaats van de standaard Root voor leesbare, importeerbare code.

Veelgestelde vragen

Hoe zet ik JSON om naar een Python-klasse?
Plak je JSON in het invoerveld. De omzetter leest het direct in je browser en genereert rechts Python. Kies met de schakelaar dataclass, Pydantic v2 of TypedDict en klik op Kopiëren — geen upload, geen account, geen wachten.
Wat is het verschil tussen de uitvoer van dataclass, Pydantic en TypedDict?
dataclass geeft je een @dataclass uit de standaardbibliotheek zonder dependencies — ideaal voor eenvoudige datahouders. Pydantic v2 produceert BaseModel-klassen die data tijdens runtime valideren en converteren, perfect voor het parsen van niet-vertrouwde API-responses. TypedDict beschrijft de vorm van een gewone dict voor statische typecheckers (mypy, Pyright) zonder runtime-kosten. Wissel van modus om dezelfde JSON in elke variant te vergelijken.
Hoe genereer ik een Pydantic-model uit JSON?
Kies het tabblad Pydantic v2. Velden worden omgezet naar snake_case met Field(alias="originalKey") zodat het model nog steeds camelCase-JSON leest, en model_config = ConfigDict(populate_by_name=True) laat je het ook op veldnaam opbouwen. Parse een payload met Root.model_validate(data) — Pydantic valideert de typen en werpt een duidelijke fout bij ongeldige invoer.
Hoe gaat de dataclass-uitvoer om met camelCase-sleutels?
Een dataclass heeft geen ingebouwde alias, dus om Root(**data) te laten werken, behoudt de dataclass-modus de originele sleutel als veldnaam wanneer die een geldige Python-identifier is (publicRepos blijft publicRepos). Wil je idiomatisch snake_case met aliassen, gebruik dan de Pydantic v2-modus, die snake_case-velden terugkoppelt naar de exacte JSON-sleutel.
Hoe worden optionele en null-velden getypeerd?
Wanneer een sleutel in sommige array-items voorkomt maar in andere niet, wordt het type in Optional verpakt. Een veld dat altijd alleen null is, wordt Optional[Any], omdat JSON null op zichzelf geen type draagt. Plak een representatief voorbeeld met een ingevulde waarde om een specifieker type dan Any te krijgen.
Naar welk Python-type wordt elke JSON-waarde omgezet?
Strings worden str, booleans bool, gehele getallen int, en elk getal met een decimaalpunt of exponent wordt float. Omdat Python-integers willekeurige precisie hebben, blijven zelfs enorme ID's int — er is geen 64-bits overflow. Lege of gemengde arrays worden List[Any], en objecten worden geneste klassen.
Kan het geneste objecten en arrays van objecten aan?
Ja. Elk genest object wordt een eigen benoemde klasse, en identieke vormen worden ontdubbeld tot één klasse die door elk veld wordt hergebruikt. Arrays van objecten worden sleutel voor sleutel samengevoegd, zodat je één element-klasse krijgt, waarbij sleutels die in sommige items ontbreken als Optional worden gemarkeerd. Onderliggende klassen worden altijd vóór de klassen die ze gebruiken uitgevoerd.
Hoe worden Python-sleutelwoorden en niet-identifier-sleutels afgehandeld?
Een JSON-sleutel die een Python-sleutelwoord is (class, from, import) krijgt een underscore achteraan (class_). Sleutels met koppeltekens, spaties of een cijfer vooraan worden in de dataclass- en Pydantic-modus opgeschoond tot geldige identifiers. In de TypedDict-modus wordt elke dict met een niet-identifier-sleutel uitgevoerd met de functionele syntaxis TypedDict('Name', {...}), zodat de exacte sleutel zoals "first-name" behouden blijft.
Hoe gebruik ik de gegenereerde dataclass om JSON te parsen?
Voor een plat object werkt json.loads gevolgd door Root(**data) rechtstreeks. Bij geneste structuren recurset dataclass niet automatisch — bouw dan zelf de onderliggende objecten, gebruik een bibliotheek als dacite of pydantic.dataclasses, of schakel deze tool naar de Pydantic v2-modus, waar Root.model_validate(json.loads(text)) de hele boom in één aanroep parset.
Zijn mijn JSON-gegevens privé en veilig?
Ja. De conversie draait 100% in je browser met JavaScript. Je JSON — inclusief tokens, ID's of klantgegevens — verlaat de pagina nooit en wordt nooit naar een server verzonden.
Is de tool gratis? Heb ik een account nodig?
Hij is volledig gratis, zonder registratie, zonder limieten en zonder advertenties die de werkruimte vervuilen. Zodra de pagina is geladen, werkt hij offline.

Gerelateerde tools

Alle tools bekijken →