JSON Formatter Python — json.dumps() Handleiding

Maria Santos·Backend Developer·Beoordeeld doorDmitri Volkov·Gepubliceerd 2026-03-10

Gebruik de gratis JSON Formatter & Beautifier direct in je browser — geen installatie nodig.

JSON Formatter & Beautifier online uitproberen →

Wanneer ik een Python API-client debug, is het eerste waar ik naar grijp python pretty print json — één aanroep naar json.dumps(data, indent=4) en een onleesbare blob op één regel wordt direct navigeerbaar. De ingebouwde json module van Python regelt dit volledig in de standaardbibliotheek — geen installatie van derde partijen vereist. Als u alleen snel een resultaat nodig heeft zonder code te schrijven, doet de JSON Formatter van ToolDeck dat direct. Deze gids behandelt elke praktische methode: json.dumps() met alle parameters, pprint, orjson voor hoogwaardige opmaak, de json.tool CLI, serialisatie van aangepaste typen zoals datetime en UUID, het streamen van bestanden van gigabytes met ijson, en syntaxiskleuring in de terminal met rich — alles met Python 3.8+ compatibele code.

Kernpunten

→json.dumps(data, indent=4) is ingebouwd in Python's stdlib sinds 2.6 — geen installatie nodig.
→Geef ensure_ascii=False mee als uw data tekens met accenten, CJK-tekens of emoji bevat.
→Gebruik voor datetime, UUID of aangepaste klassen de parameter default= of subklasse json.JSONEncoder.
→separators=(',', ':') verwijdert alle witruimte — gebruik voor netwerktransmissie of URL-inbedding.
→orjson is 5–10× sneller dan de stdlib en verwerkt datetime en uuid.UUID natief.
→pprint.pprint() produceert Python-syntaxis (True/None), geen geldige JSON — gebruik nooit voor bestanden of API-antwoorden.
→Gebruik voor JSON-bestanden groter dan 50 MB streamen met ijson in plaats van json.load() om MemoryError te vermijden.

Wat is JSON pretty printing?

Pretty printing transformeert een dichte, geminificeerde JSON-string naar een voor mensen leesbaar formaat met consistente inspringing en regeleinden. De transformatie is puur cosmetisch: de data is identiek, alleen de presentatie verandert. De json module van Python verwerkt dit volledig in de standaardbibliotheek — niets om te installeren.

Before · json

After · json

{"id":"usr_9f3a2b","name":"Jan de Vries","roles":["admin","editor"],"prefs":{"theme":"dark","lang":"nl"}}

{
    "id": "usr_9f3a2b",
    "name": "Jan de Vries",
    "roles": [
        "admin",
        "editor"
    ],
    "prefs": {
        "theme": "dark",
        "lang": "nl"
    }
}

json.dumps() — De standaard manier om JSON te formatteren

json.dumps() maakt deel uit van Python's standaardbibliotheek sinds Python 2.6 — voeg gewoon import json toe, geen installatie nodig. Het serialiseert elk JSON-compatibel Python-object naar een opgemaakte string. De sleutelparameter is indent: stel het in op 4 (of 2) voor leesbare uitvoer.

Python 3.8+ — minimaal voorbeeld

import json

gebruiker = {
    "id": "usr_9f3a2b",
    "name": "Jan de Vries",
    "roles": ["admin", "editor"],
    "prefs": {"theme": "dark", "lang": "nl"}
}

print(json.dumps(gebruiker, indent=4))
# Uitvoer:
# {
#     "id": "usr_9f3a2b",
#     "name": "Jan de Vries",
#     "roles": [
#         "admin",
#         "editor"
#     ],
#     "prefs": {
#         "theme": "dark",
#         "lang": "nl"
#     }
# }

Voor productiegebruik wilt u vaak sort_keys=True (consistente uitvoer over runs) en ensure_ascii=False (niet-ASCII-tekens leesbaar houden):

Python 3.8+ — met sort_keys en ensure_ascii

import json

api_antwoord = {
    "timestamp": "2024-05-01T10:30:00Z",
    "status": "succes",
    "data": {
        "user_id": "usr_9f3a2b",
        "weergavenaam": "Emma Bakker",
        "stad": "Amsterdam",
        "score": 4892.5,
        "tags": ["python", "backend", "api"]
    }
}

print(json.dumps(api_antwoord, indent=4, sort_keys=True, ensure_ascii=False))
# Uitvoer (sleutels gesorteerd, tekens bewaard):
# {
#     "data": {
#         "score": 4892.5,
#         "stad": "Amsterdam",
#         "tags": ["api", "backend", "python"],
#         "user_id": "usr_9f3a2b",
#         "weergavenaam": "Emma Bakker"
#     },
#     "status": "succes",
#     "timestamp": "2024-05-01T10:30:00Z"
# }

Opmerking:json.dumps() geeft een string terug. Gebruik json.dump(data, f, indent=4) (zonder s) om opgemaakte JSON direct naar een bestand te schrijven — het schrijft naar een bestandsobject en vermijdt het aanmaken van een tussenliggende string in het geheugen.

json.dumps() Parameterreferentie

Alle parameters zijn optioneel behalve het object zelf. De standaardwaarden produceren compacte, ASCII-veilige JSON — geef parameters expliciet mee voor voor mensen leesbare uitvoer.

Parameter

Type

Standaard

Beschrijving

obj

any

—

Python-object om te serialiseren naar een JSON-opgemaakte string.

indent

int | str | None

None

Spaties per inspringingsniveau. None = compacte enkele regel, 0 = alleen regeleinden, 4 = standaard.

sort_keys

bool

False

Sorteert woordenboeksleutels alfabetisch op alle geneste niveaus.

ensure_ascii

bool

True

Vervangt niet-ASCII-tekens door \uXXXX. Stel in op False om Unicode-tekens te bewaren.

separators

tuple | None

None

Paar (item_sep, key_sep). Gebruik (",", ":") voor de meest compacte uitvoer zonder spaties.

default

callable | None

None

Aangeroepen voor typen die standaard niet serialiseerbaar zijn. Gooi TypeError om de waarde te weigeren.

allow_nan

bool

True

Serialiseert float("nan") en float("inf") als JS-literals. Stel in op False om ValueError te gooien.

Compacte JSON-uitvoer met de separators-parameter

Standaard scheidt json.dumps() items met ", " en sleutels van waarden met ": ". De parameter separators overschrijft beide. Het doorgeven van (',', ':') verwijdert alle witruimte om de meest compacte geldige JSON te produceren — handig voor netwerktransmissie, URL-inbedding of het opslaan van JSON in een databasekolom waar elke byte telt.

Python 3.8+

import json

lading = {
    "endpoint": "/api/v2/events",
    "filters": {"status": "actief", "limiet": 100},
    "sortering": "desc"
}

# Standaard — spaties na scheidingstekens (leesbaar)
standaard_uitvoer = json.dumps(lading, ensure_ascii=False)
# {"endpoint": "/api/v2/events", "filters": {"status": "actief", "limiet": 100}, "sortering": "desc"}
# len = 88

# Compact — geen witruimte
compacte_uitvoer = json.dumps(lading, separators=(',', ':'), ensure_ascii=False)
# {"endpoint":"/api/v2/events","filters":{"status":"actief","limit":100},"sortering":"desc"}
# len = 80  (9% kleiner; besparingen groeien bij grotere, dieper geneste ladingen)

# Compact + gesorteerde sleutels voor reproduceerbare cachesleutels
canoniek = json.dumps(lading, separators=(',', ':'), sort_keys=True, ensure_ascii=False)
print(canoniek)
# {"endpoint":"/api/v2/events","filters":{"limiet":100,"status":"actief"},"sortering":"desc"}

Opmerking:Wanneer u indent= doorgeeft samen met separators=, beheert het separators-argument alleen de inline scheidingstekens — regeleinden en inspringing van indent blijven behouden. Voor compacte uitvoer op één regel, laat indent weg (of geef None mee) en stel separators=(',', ':') in.

Aangepaste Python-objecten serialiseren met de default-parameter

De standaard json module serialiseert dicts, lijsten, strings, getallen, booleans en None — maar gooit een TypeError voor elk ander type. De twee meest voorkomende problemen in productiecode zijn datetime-objecten en UUID's.

Python 3.8+ — TypeError zonder aangepaste verwerking

import json
from datetime import datetime, timezone
import uuid

bestelling = {
    "bestelling_id": uuid.uuid4(),              # ❌ TypeError: UUID is not JSON serializable
    "geplaatst_op": datetime.now(timezone.utc), # ❌ TypeError: datetime is not JSON serializable
    "totaal_eur": 142.50,
    "items": ["pro-abonnement", "opslag-addon"]
}

json.dumps(bestelling)  # gooit TypeError

Aanpak 1 — de default=-parameter

Geef een aanroepbaar object mee aan default=. json.dumps() roept het aan voor elk object dat het niet kan verwerken. Geef een serialiseerbare representatie terug of gooi TypeError voor typen die u niet expliciet ondersteunt — slik onbekende typen nooit stilzwijgend door.

Python 3.8+

import json
from datetime import datetime, timezone, date
import uuid
from decimal import Decimal

def json_standaard(obj):
    if isinstance(obj, (datetime, date)):
        return obj.isoformat()
    if isinstance(obj, uuid.UUID):
        return str(obj)
    if isinstance(obj, Decimal):
        return float(obj)
    raise TypeError(f"Type {type(obj).__name__!r} is niet JSON-serialiseerbaar")

bestelling = {
    "bestelling_id": uuid.uuid4(),
    "geplaatst_op": datetime(2024, 5, 1, 10, 30, 0, tzinfo=timezone.utc),
    "totaal_eur": Decimal("142.50"),
    "items": ["pro-abonnement", "opslag-addon"]
}

print(json.dumps(bestelling, indent=4, default=json_standaard, ensure_ascii=False))
# {
#     "bestelling_id": "a3f1c2d4-e5b6-7890-abcd-ef1234567890",
#     "geplaatst_op": "2024-05-01T10:30:00+00:00",
#     "totaal_eur": 142.5,
#     "items": ["pro-abonnement", "opslag-addon"]
# }

Aanpak 2 — subklasse van json.JSONEncoder

Voor herbruikbare coderingslogica die wordt gedeeld tussen meerdere modules is het overerven van json.JSONEncoder overzichtelijker dan een default functie overal door te geven. Overschrijf de default methode en roep super().default(obj) aan als laatste fallback — dit behoudt het juiste foutgedrag voor niet-ondersteunde typen.

Python 3.8+

import json
from datetime import datetime, timezone
import uuid
from decimal import Decimal

class AppEncoder(json.JSONEncoder):
    def default(self, obj):
        if isinstance(obj, datetime):
            return obj.isoformat()
        if isinstance(obj, uuid.UUID):
            return str(obj)
        if isinstance(obj, Decimal):
            return float(obj)
        return super().default(obj)  # gooit TypeError voor onbekende typen

bestelling = {
    "bestelling_id": uuid.uuid4(),
    "geplaatst_op": datetime(2024, 5, 1, 10, 30, 0, tzinfo=timezone.utc),
    "totaal_eur": Decimal("142.50"),
}

# Geef de encoderklasse mee via cls=
print(json.dumps(bestelling, indent=4, cls=AppEncoder, ensure_ascii=False))
# Identieke uitvoer als de default=-aanpak hierboven

Opmerking:Roep altijd super().default(obj) aan (of gooi expliciet TypeError) voor niet-herkende typen. Stilzwijgend str(obj) teruggeven voor alles beschadigt objecten die een fout hadden moeten gooien — een bug die moeilijk te traceren is in productie.

Terug decoderen — object_hook

Coderen is slechts de helft van het verhaal. Om een aangepast Python-object te reconstrueren vanuit JSON, geef een object_hook functie mee aan json.loads() of json.load(). De hook wordt aangeroepen voor elk gedecodeerd JSON-object (dict) en kan elke Python-waarde teruggeven — wat een volledige codeer ↔ decodeer-cyclus mogelijk maakt.

Python 3.8+

import json
from datetime import datetime
from dataclasses import dataclass

@dataclass
class Gebeurtenis:
    naam: str
    opgetreden_op: datetime
    user_id: str

def codeer_gebeurtenis(obj):
    if isinstance(obj, Gebeurtenis):
        return {
            "__type__": "Gebeurtenis",
            "naam": obj.naam,
            "opgetreden_op": obj.opgetreden_op.isoformat(),
            "user_id": obj.user_id,
        }
    raise TypeError(f"Kan {type(obj)} niet serialiseren")

def decodeer_gebeurtenis(d):
    if d.get("__type__") == "Gebeurtenis":
        return Gebeurtenis(
            naam=d["naam"],
            opgetreden_op=datetime.fromisoformat(d["opgetreden_op"]),
            user_id=d["user_id"],
        )
    return d

# Codeer
gebeurtenis = Gebeurtenis("inloggen", datetime(2024, 5, 1, 10, 30), "usr_9f3a2b")
json_str = json.dumps(gebeurtenis, default=codeer_gebeurtenis, indent=4)

# Decodeer terug naar een Gebeurtenis-instantie
hersteld = json.loads(json_str, object_hook=decodeer_gebeurtenis)
print(type(hersteld))           # <class 'Gebeurtenis'>
print(hersteld.opgetreden_op)   # 2024-05-01 10:30:00

Opmerking:De object_hook wordt aangeroepen voor elke geneste dict in het document — niet alleen op het hoogste niveau. Voeg een discriminatorveld toe (zoals "__type__") zodat de hook uw aangepaste objecten kan onderscheiden van gewone dicts die ongewijzigd moeten blijven.

pprint — De alternatieve module (en wanneer u hem niet moet gebruiken)

Python's pprint module (pretty printer) formatteert Python-datastructuren voor leesbaarheid in de terminal. Het werkt op geparsede Python-objecten, niet op JSON-strings — en de uitvoer gebruikt Python-syntaxis, niet JSON-syntaxis.

Python 3.8+

import json, pprint

raw = '{"sensor_id":"s-441","readings":[23.1,23.4,22.9],"unit":"celsius","active":true}'
data = json.loads(raw)

# pprint — geldige Python repr, GEEN geldige JSON
pprint.pprint(data, sort_dicts=False)
# {'sensor_id': 's-441',
#  'readings': [23.1, 23.4, 22.9],
#  'unit': 'celsius',
#  'active': True}        ← Python True, niet JSON true

# json.dumps — geldige JSON
print(json.dumps(data, indent=4))
# {
#     "sensor_id": "s-441",
#     "readings": [23.1, 23.4, 22.9],
#     "unit": "celsius",
#     "active": true      ← geldige JSON
# }

Waarschuwing:Stuur pprint-uitvoer nooit naar een API-eindpunt of schrijf het naar een .json bestand — het breekt elke JSON-parser die standaardsyntaxis verwacht. Gebruik json.dumps(indent=4) voor alle uitvoer die geldige JSON moet zijn.

Wanneer pprint zinvol is: snelle terminalinspectie van Python-objecten in een REPL of debuglog, vooral wanneer het object typen bevat die niet JSON-serialiseerbaar zijn (sets, aangepaste klasse-instanties, dataclasses voor conversie).

Hoe druk ik een JSON-antwoord van Requests mooi af?

Het meest voorkomende praktijkscenario: u heeft een JSON-bestand op schijf of een HTTP-antwoord van een API en wilt het formatteren voor debugging of logging. Beide gevallen gebruiken dezelfde aanpak — parseer naar een Python-dict, formatteer dan met json.dumps().

Lezen uit een bestand

Python 3.8+

import json

try:
    with open("config.json", "r", encoding="utf-8") as f:
        data = json.load(f)

    # Mooi afdrukken naar console
    print(json.dumps(data, indent=4, ensure_ascii=False))

    # Of de opgemaakte versie terugschrijven naar schijf
    with open("config.pretty.json", "w", encoding="utf-8") as f:
        json.dump(data, f, indent=4, ensure_ascii=False)

except json.JSONDecodeError as e:
    print(f"Ongeldige JSON: {e}")
except FileNotFoundError:
    print(f"Bestand niet gevonden: config.json")

Een API-antwoord formatteren

Python 3.8+ (vereist: pip install requests)

import json, requests
from requests.exceptions import HTTPError, ConnectionError, Timeout

def mooi_afdrukken_api(url: str) -> None:
    try:
        resp = requests.get(url, timeout=10)
        resp.raise_for_status()
        print(json.dumps(resp.json(), indent=4, ensure_ascii=False))
    except HTTPError as e:
        print(f"HTTP {e.response.status_code}: {e}")
    except (ConnectionError, Timeout) as e:
        print(f"Netwerkfout: {e}")
    except json.JSONDecodeError:
        print(f"Antwoordtekst is geen JSON:\n{resp.text[:500]}")

mooi_afdrukken_api("https://api.github.com/repos/python/cpython")

Opmerking:response.json() parseert al de antwoordtekst — u hoeft niet apart json.loads() aan te roepen. Voeg altijd raise_for_status() toe voor het openen van .json() om 4xx/5xx-fouten op te vangen voordat ze een verwarrende parsefout veroorzaken.

Mooi afdrukken via de commandoregel

Python wordt geleverd met json.tool, een CLI-module voor het formatteren van JSON direct vanuit de terminal — geen Python-script vereist. Het is beschikbaar op elke machine met Python geïnstalleerd.

bash

# Formatteer een lokaal bestand
python -m json.tool config.json

# Stuur API-antwoord door de formatter
curl -s https://api.github.com/users/gvanrossum | python -m json.tool

# Formatteer vanuit stdin
echo '{"dienst":"api-gateway","versie":"2.1.0","gezond":true}' | python -m json.tool

# Sorteer sleutels alfabetisch
python -m json.tool --sort-keys data.json

# Aangepaste inspringing (Python 3.9+)
python -m json.tool --indent 2 data.json

Opmerking:Python 3.9 voegde de vlaggen --indent en --no-indent toe. Voor krachtigere terminal JSON-filtering, overweeg jq — maar python -m json.tool dekt de formatterings-use case zonder extra afhankelijkheden.

Als u helemaal niet in een terminal zit — bij het plakken van een Postman-respons of een logbestand — laat de ToolDeck JSON Formatter u plakken, formatteren en kopiëren in één stap met ingebouwde syntaxismarkering en validatie.

Alternatieve bibliotheken: orjson en rich

orjson — 5–10× sneller met natieve type-ondersteuning

De standaard json module is snel genoeg voor de meeste gevallen, maar als u duizenden objecten per seconde serialiseert — logpijplijnen, high-throughput API's, grote data-exports — is orjson 5–10× sneller. Het verwerkt ook native typen die de standaardbibliotheek niet kan serialiseren zonder een aangepaste default functie: datetime, uuid.UUID, numpy-arrays en dataclasses.

bash — installeren

pip install orjson

Python 3.8+

import orjson
from datetime import datetime, timezone
import uuid

gebeurtenis = {
    "gebeurtenis_id": uuid.uuid4(),              # geen str() nodig — orjson verwerkt UUID
    "timestamp": datetime.now(timezone.utc),     # geen isoformat() nodig
    "dienst": "auth-service",
    "niveau": "INFO",
    "lading": {
        "user_id": "usr_9f3a2b",
        "actie": "inloggen",
        "ip": "192.168.1.42",
        "latentie_ms": 34
    }
}

# orjson.dumps geeft bytes terug; .decode() converteert naar str
print(orjson.dumps(gebeurtenis, option=orjson.OPT_INDENT_2).decode())
# {
#   "gebeurtenis_id": "a3f1c2d4-e5b6-7890-abcd-ef1234567890",
#   "timestamp": "2024-05-01T10:30:00+00:00",
#   "dienst": "auth-service",
#   ...
# }

Twee dingen om te weten: orjson.dumps() geeft bytes terug, geen string — roep .decode() aan als u een string nodig heeft. Het ondersteunt alleen 2-spatie inspringing via OPT_INDENT_2; gebruik voor 4-spatie uitvoer de standaard json.dumps(indent=4).

rich — Syntaxiskleuring in de terminal

Als u regelmatig JSON inspecteert in een terminal of REPL, rich rendert gekleurde, syntaxis-gemarkeerde uitvoer die diep geneste structuren in één oogopslag leesbaar maakt. Sleutels, strings, getallen en booleans krijgen elk een andere kleur — veel gemakkelijker te scannen dan een muur monochrome tekst. Het is alleen een hulpmiddel voor debugtijd, niet voor productieserialisatie.

bash — installeren

pip install rich

Python 3.8+

from rich import print_json
import json

# print_json() accepteert een JSON-string
raw = '{"gebeurtenis":"inloggen","user_id":"usr_9f3a2b","timestamp":"2024-05-01T10:30:00Z","succes":true,"meta":{"ip":"192.168.1.42","pogingen":1}}'
print_json(raw)

# Om een Python-dict mooi af te drukken, converteer eerst naar string
data = {
    "status": "succes",
    "aantal": 42,
    "tags": ["python", "api", "backend"]
}
print_json(json.dumps(data, ensure_ascii=False))

Waarschuwing:rich.print_json() geeft ANSI-escapecodes voor terminalkleur — vang deze uitvoer nooit op en schrijf hem niet naar een .json bestand of stuur hem als API-antwoord. Gebruik json.dumps(indent=4) voor elke machineleesbare uitvoer.

simplejson — Directe compatibele stdlib-vervanging

simplejson is de bibliotheek die is geworden tot Python's standaard json module — het wordt nog steeds onafhankelijk onderhouden en blijft de stdlib voor op kleine functies. Het is een echte directe vervanging: verwissel de import en de rest van uw code blijft ongewijzigd. Handig wanneer u Decimal ondersteuning nodig heeft zonder een aangepaste encoder, of bij oudere Python-omgevingen.

bash — installeren

pip install simplejson

Python 3.8+

import simplejson as json  # identieke API als de stdlib
from decimal import Decimal

bestelling = {
    "item": "API-abonnement Rotterdam",
    "prijs": Decimal("49.99"),   # stdlib json gooit hier TypeError
    "hoeveelheid": 3,
}

# simplejson serialiseert Decimal natief — geen default= nodig
print(json.dumps(bestelling, indent=4, use_decimal=True, ensure_ascii=False))
# {
#     "item": "API-abonnement Rotterdam",
#     "prijs": 49.99,
#     "hoeveelheid": 3
# }

Opmerking:Voor pure prestaties is orjson de betere keuze. Grijp naar simplejson wanneer u native Decimal-serialisatie nodig heeft zonder een aangepaste encoder te schrijven, of bij het onderhouden van een codebase die het al gebruikt.

Grote JSON-bestanden verwerken zonder geheugen te verbruiken

json.load() leest het gehele bestand in het geheugen voordat u toegang krijgt tot één veld. Bij een bestand met miljoenen records of een payload groter dan een gigabyte veroorzaakt dit een MemoryError — of dwingt het proces in het beste geval naar wisselgeheugen te wisselen en te kruipen.

Streamen met ijson

ijson is een streamende JSON-parser die items één voor één genereert vanuit een bestandsobject. U itereert over array-elementen zonder ooit de volledige dataset in het geheugen te houden — het piekgeheugengebruik blijft evenredig aan één object, niet aan de bestandsgrootte.

bash — installeren

pip install ijson

Python 3.8+

import ijson
from decimal import Decimal

# events.json structuur: {"events": [...miljoenen objecten...]}
totale_omzet = Decimal("0")
inlog_telling = 0

with open("events.json", "rb") as f:   # ijson vereist binaire modus
    for event in ijson.items(f, "events.item"):
        if event.get("type") == "aankoop":
            totale_omzet += Decimal(str(event["bedrag_eur"]))
        elif event.get("type") == "inloggen":
            inlog_telling += 1

print(f"Omzet: €{totale_omzet:.2f}  |  Inlogpogingen: {inlog_telling}")
# Verwerkt een bestand van 2 GB met ~30 MB piekgeheugengebruik

Opmerking:Schakel over van json.load() naar ijson wanneer uw bestand ongeveer 50–100 MB overschrijdt. Onder die drempel is json.load() eenvoudiger en aanzienlijk sneller omdat het intern een C-extensie-parser gebruikt. Boven 100 MB wegen de geheugenbesparingen van streamen zwaarder dan de extra overhead.

NDJSON — één JSON-object per regel

NDJSON (Newline Delimited JSON, ook JSON Lines of .jsonl genoemd) slaat één compleet JSON-object per regel op. Logexporters, Kafka-consumers en datapijplijnen produceren dit formaat vaak omdat elke regel onafhankelijk kan worden toegevoegd en gelezen — geen noodzaak om het gehele bestand te parsen om een record toe te voegen. De standaardbibliotheek verwerkt het zonder extra afhankelijkheden.

Python 3.8+

import json
from pathlib import Path

# Schrijf NDJSON — één event per regel
events = [
    {"ts": "2024-05-01T10:00:00Z", "gebruiker": "usr_9f3a2b", "actie": "inloggen"},
    {"ts": "2024-05-01T10:01:03Z", "gebruiker": "usr_9f3a2b", "actie": "aankoop", "sku": "pro-plan"},
    {"ts": "2024-05-01T10:15:42Z", "gebruiker": "usr_4ab1d9", "actie": "inloggen"},
]

with open("events.ndjson", "w", encoding="utf-8") as f:
    for event in events:
        f.write(json.dumps(event, ensure_ascii=False) + "\n")

# Lees NDJSON — constant geheugen, ongeacht de bestandsgrootte
aankoop_telling = 0
with open("events.ndjson", "r", encoding="utf-8") as f:
    for regel in f:
        regel = regel.strip()
        if not regel:           # sla lege regels over
            continue
        event = json.loads(regel)
        if event.get("actie") == "aankoop":
            aankoop_telling += 1
            print(f"{event['ts']} — {event['gebruiker']} kocht {event['sku']}")

Veelgemaakte fouten

Ik heb deze vier fouten in bijna elke code review gezien waarbij JSON-serialisatie betrokken is — vooral van ontwikkelaars afkomstig uit JavaScript waar JSON.stringify codering automatisch afhandelt.

❌ print(data) gebruiken in plaats van json.dumps()

Probleem: print() op een dict gebruikt Python repr — uitvoer toont True/None (Python-syntaxis), niet true/null (JSON-syntaxis). Het is geen geldige JSON.

Oplossing: Gebruik altijd json.dumps(data, indent=4) voor geldige, leesbare JSON-uitvoer.

Before · Python

After · Python

data = {"actief": True, "aantal": None}
print(data)
# {'actief': True, 'aantal': None}

print(json.dumps(data, indent=4))
# {
#     "actief": true,
#     "aantal": null
# }

❌ ensure_ascii=False vergeten bij niet-ASCII-tekst

Probleem: Speciale tekens (letters met accenten, CJK, emoji) worden vervangen door \\uXXXX-reeksen, waardoor de uitvoer onleesbaar wordt.

Oplossing: Geef ensure_ascii=False mee om de originele Unicode-tekens te bewaren.

Before · Python

After · Python

gebruiker = {"stad": "Köln", "naam": "François"}
json.dumps(gebruiker, indent=2)
# {"stad": "K\u00f6ln", "naam": "Fran\u00e7ois"}

json.dumps(gebruiker, indent=2, ensure_ascii=False)
# {"stad": "Köln", "naam": "François"}

❌ json.dumps() gebruiken om naar een bestand te schrijven

Probleem: json.dumps() geeft een string terug; u heeft dan een apart f.write()-aanroep nodig, wat een onnodige tussenliggende string aanmaakt.

Oplossing: Gebruik json.dump(data, f, indent=4) — het schrijft direct naar het bestandsobject.

Before · Python

After · Python

with open("uitvoer.json", "w") as f:
    f.write(json.dumps(data, indent=4))

with open("uitvoer.json", "w", encoding="utf-8") as f:
    json.dump(data, f, indent=4, ensure_ascii=False)

❌ Mooi afdrukken met pprint en geldige JSON verwachten

Probleem: pprint.pprint() gebruikt Python-syntaxis (True, None, enkele aanhalingstekens) die JSON-parsers afwijzen.

Oplossing: Gebruik json.dumps(indent=4) voor alle uitvoer die als JSON moet kunnen worden geparsed.

Before · Python

After · Python

import pprint
pprint.pprint({"actief": True, "laatste_fout": None})
# {'actief': True, 'laatste_fout': None}

import json
print(json.dumps({"actief": True, "laatste_fout": None}, indent=4))
# {"actief": true, "laatste_fout": null}

Methodevergelijking — json.dumps, orjson, simplejson, rich

Gebruik json.dumps() voor dagelijks formatteren en bestandswrites — het dekt 95% van de gevallen zonder afhankelijkheden. Grijp naar orjson bij serialisatie in een hot path of wanneer uw objecten datetime en UUID velden bevatten. Gebruik simplejson wanneer u directe stdlib-compatibiliteit nodig heeft met kant-en-klare Decimal ondersteuning. Bewaar rich.print_json() en pprint strikt voor lokale terminalinspectie — geen van beide produceert machineleesbare uitvoer.

Methode

Uitvoer

Geldige JSON

Snelheid

Non-ASCII

Aangepaste typen

Installatie

json.dumps(indent=4)

String

✅

Standaard

ensure_ascii=False

default= / JSONEncoder

Ingebouwd

json.dump(f, indent=4)

Bestand

✅

Standaard

ensure_ascii=False

default= / JSONEncoder

Ingebouwd

pprint.pprint()

Python repr

❌

Standaard

Natief

✅ (elke repr)

Ingebouwd

orjson.dumps(OPT_INDENT_2)

Bytes

✅

5–10× sneller

Natief

datetime, UUID, numpy

pip install orjson

python -m json.tool

CLI stdout

✅

Standaard

✅

❌

Ingebouwd

simplejson.dumps()

String

✅

~1.5× sneller

ensure_ascii=False

Decimal natief

pip install simplejson

rich.print_json()

Alleen terminal

✅ (invoer)

Standaard

✅

❌

pip install rich

Veelgestelde vragen

Hoe druk ik JSON mooi af in Python?

Roep json.dumps(data, indent=4) aan. De indent-parameter stelt het aantal spaties per nestniveau in. Importeer eerst de json-module — die wordt meegeleverd met de standaardbibliotheek van Python, geen pip install nodig. Geef ensure_ascii=False mee als uw data niet-ASCII-tekens bevat zoals letters met accenten of CJK-tekens.

python

import json

gebruiker = {"username": "jdevries", "plan": "enterprise", "rechten": ["lezen", "schrijven", "deployen"]}
print(json.dumps(gebruiker, indent=4, ensure_ascii=False))

Wat is het verschil tussen json.dumps() en json.dump()?

json.dumps() (met een "s") geeft een opgemaakte string terug in het geheugen. json.dump() (zonder "s") schrijft direct naar een bestandsachtig object — geef de geopende bestandshandle mee als tweede argument. Voor het schrijven van opgemaakte JSON naar schijf is json.dump(data, f, indent=4) de idiomatische aanpak en vermijdt het aanmaken van een tussenliggende string.

python

# dumps → string in geheugen
opgemaakt = json.dumps(data, indent=4)

# dump → schrijf direct naar bestand
with open('uitvoer.json', 'w', encoding='utf-8') as f:
    json.dump(data, f, indent=4)

Waarom toont json.dumps() \u00f6\u00e0\u00fc in plaats van het werkelijke teken?

Standaard vervangt ensure_ascii=True elk niet-ASCII-teken door een \uXXXX-reeks. Stel ensure_ascii=False in om de originele Unicode-tekens te bewaren. Dit is vooral belangrijk voor namen, adressen en door gebruikers gegenereerde inhoud met tekens buiten het Latijnse schrift.

python

data = {"stad": "Köln", "naam": "François", "regio": "Zürich"}

# Standaard — vervangen
json.dumps(data, indent=4)
# {"stad": "K\u00f6ln", "naam": "Fran\u00e7ois", "regio": "Z\u00fcrich"}

# Leesbaar
json.dumps(data, indent=4, ensure_ascii=False)
# {"stad": "Köln", "naam": "François", "regio": "Zürich"}

Hoe druk ik een JSON-string (geen dict) mooi af?

Parseer eerst de string met json.loads(), formatteer dan met json.dumps(). De twee aanroepen kunnen worden samengevoegd op één regel voor snelle terminalinspectie.

python

import json

rauw = '{"endpoint":"/api/v2/gebruikers","timeout":30,"opnieuw_proberen":true}'
print(json.dumps(json.loads(rauw), indent=4))

Kan ik pprint gebruiken om JSON op te maken in Python?

pprint.pprint() produceert Python-objectrepresentatie, geen geldige JSON. Het gebruikt True/False/None (Python-syntaxis) in plaats van true/false/null (JSON-syntaxis). Stuur pprint-uitvoer nooit naar een API of JSON-parser — gebruik json.dumps(indent=4) voor alles wat geldige JSON moet zijn.

python

import pprint, json

data = {"actief": True, "score": None}

pprint.pprint(data)        # {'actief': True, 'score': None}  ← geen JSON
json.dumps(data, indent=4) # {"actief": true, "score": null}  ← geldige JSON

Hoe sorteer ik JSON-sleutels alfabetisch in Python?

Voeg sort_keys=True toe aan json.dumps(). Gebruik op de commandoregel python -m json.tool --sort-keys data.json. Gesorteerde sleutels maken JSON-diffs leesbaar en helpen u in één oogopslag te zien wat er tussen versies is veranderd.

python

import json

server = {"workers": 4, "host": "0.0.0.0", "port": 8080, "debug": False}
print(json.dumps(server, indent=4, sort_keys=True))
# {
#     "debug": false,
#     "host": "0.0.0.0",
#     "port": 8080,
#     "workers": 4
# }

Python geeft u volledige controle — aangepaste serializers, streaming, pipeline-integratie. Wanneer u alleen een geformatteerd fragment wilt inspecteren of delen, is de ToolDeck JSON Formatter de snellere route: plak uw JSON en krijg een ingesprongen, gemarkeerd resultaat zonder enige omgevingsinstellingen.

Gerelateerde tools

JSON Formatter

Formatteer elke JSON direct in de browser — geen Python-omgeving nodig. Plakken, formatteren en kopiëren met één klik.

JSON Validator

Valideer uw JSON-structuur voor het formatteren — vangt syntaxfouten op die json.loads() een JSONDecodeError zouden laten gooien.

JSON Diff

Vergelijk twee JSON-antwoorden naast elkaar om te zien wat er is veranderd tussen API-versies of configuratie-implementaties.

JWT Decoder

Decodeer en inspecteer JWT-tokens die door uw API worden geretourneerd — handig naast JSON-opmaak bij het debuggen van authenticatiestromen.

YAML to JSON

Converteer YAML-configuratiebestanden naar JSON — handig wanneer u een op YAML gebaseerd API-antwoord als JSON mooi wilt afdrukken.

Ook beschikbaar in:Go JavaScript Bash

Maria SantosBackend Developer

Maria is a backend developer specialising in Python and API integration. She has broad experience with data pipelines, serialisation formats, and building reliable server-side services. She is an active member of the Python community and enjoys writing practical, example-driven guides that help developers solve real problems without unnecessary theory.

Dmitri VolkovTechnisch beoordelaar

Dmitri is a DevOps engineer who relies on Python as his primary scripting and automation language. He builds internal tooling, CI/CD pipelines, and infrastructure automation scripts that run in production across distributed teams. He writes about the Python standard library, subprocess management, file processing, encoding utilities, and the practical shell-adjacent Python that DevOps engineers use every day.