Hoe los je snel misvormde JSON-bestanden op: een praktische gids voor ontwikkelaars

Je API-aanroep faalde zojuist met JSONDecodeError: Expecting property name enclosed in double quotes. De klok tikt. De data kwam van een LLM, en ergens in dat 2.000-token-antwoord heeft één enkele afsluitende komma je hele pijplijn gedood.

Per mei 2026 is de snelste manier om misvormde JSON-bestanden te herstellen het gebruik van geautomatiseerde bibliotheken zoals json_repair (Python) of jsonrepair (npm). Deze tools zijn specifiek gebouwd om door LLM’s gegenereerde syntactische fouten direct te herstellen. Voor handmatige reparaties zijn de gebruikelijke verdachten afsluitende komma’s, enkele aanhalingstekens of ongegenoteerde sleutels — de drie meest voorkomende schendingen van de RFC 8259-standaard.

De snelste oplossing: json_repair voor LLM-uitvoer

Standaardparsers zoals de json.loads() van Python zijn strikt ontworpen. Eén verkeerd geplaatst teken leidt tot een JSONDecodeError en alles stopt. Dit is in 2026 een dagelijks probleem, omdat LLM’s routinely JSON in conversationele tekst wikkelen, antwoorden midden in een zin afbreken, of opmerkingen toevoegen die de specificatie breken.

De bibliotheek json_repair is de standaardoplossing. Volgens GitHub heeft dit project meer dan 4.700 sterren in 2026. Het werkt door de intentie van de string te “raden” — ontbrekende haakjes sluiten, aanhalingstekens toevoegen en overtollige tekst rond het JSON-blok verwijderen.

Python: voor en na

Installeren: pip install json-repair

De kapotte invoer:

import json_repair

bad_json = '{"user": "Alice", "status": tru'
decoded_object = json_repair.loads(bad_json)

Wat er achter de schermen gebeurde: json_repair zag dat tru waarschijnlijk true was, voegde het ontbrekende sluithaakje toe en gaf een geldige Python-dictionary terug. Nul handmatige tussenkomst.

Salvage-modus: wanneer de data echt lelijk is

Voor lastigere gevallen bevat json_repair (v0.59.5+) een Salvage-modus. Zoals beschreven in de projectdocumentatie, is deze modus specifiek gebouwd voor afgekapte AI-antwoorden of beschadigde logs. Het kan arrays forceren naar objecten of items die te kapot zijn om te redden laten vallen, zodat de uitvoer in je schema past.

import json_repair

# Salvage mode for severely truncated data
result = json_repair.loads(
    '{"items": [{"id": 1, "name": "Widget"}, {"id": 2, "na',
    salvage_mode=True
)
# Result: {'items': [{'id': 1, 'name': 'Widget'}, {'id': 2}]}
# Dropped the incomplete 'na' but saved everything else

npm-alternatief

Voor Node.js-projecten doet de jsonrepair CLI hetzelfde:

# Fix a file in place
npx jsonrepair broken.json > fixed.json

# Fix a string in a script
const { jsonrepair } = require('jsonrepair');
const fixed = jsonrepair('{"name": "test",}');

Handmatig debuggen: vinden wat de specificatie brak

Wanneer automatisering niet volstaat, moet je precies vinden waar het bestand RFC 8259 schendt. JSON is veel minder vergevingsgezind dan YAML of JavaScript. Zoals het JSONParser Diagnostics Team uitlegt: “De parser faalt bij het eerste teken dat hij niet kan interpreteren, wat vaak een downstream-symptoom is van een probleem enkele regels eerder.”

De drie JSON-moordenaars

Moordenaar 1: afsluitende komma’s

Volgens DEV Community zijn afsluitende komma’s de nummer één oorzaak van parse-fouten. Ze zijn prima in JavaScript, maar illegaal na het laatste item in een JSON-array of -object.

// BROKEN - trailing comma after "active"
{
  "name": "Alice",
  "status": "active",
}

// FIXED - no comma before closing brace
{
  "name": "Alice",
  "status": "active"
}

Moordenaar 2: enkele aanhalingstekens

JSON vereist dubbele aanhalingstekens (") voor zowel sleutels als stringwaarden. Veel Python- en JavaScript-ontwikkelaars gebruiken per ongeluk enkele aanhalingstekens ('). Zoals TidyCode opmerkt, is dit een verplichte reparatie.

// BROKEN - single quotes
{'name': 'Alice'}

// FIXED - double quotes
{"name": "Alice"}

Moordenaar 3: ontegenoteerde sleutels

In JavaScript kun je { name: "Alice" } schrijven. In JSON heeft elke sleutel dubbele aanhalingstekens nodig.

// BROKEN - unquoted key
{name: "Alice"}

// FIXED - quoted key
{"name": "Alice"}

De “Unexpected Token”-fout

Wanneer een validator een “Unexpected Token” markeert, betekent dit dat de parser NaN, Infinity of undefined tegenkwam — JavaScript-constanten die JSON niet ondersteunt. JSON staat alleen null, true, false en getallen toe.

// BROKEN - NaN is not valid JSON
{"score": NaN, "result": Infinity}

// FIXED - replace with null or valid values
{"score": null, "result": null}

Strikt parsen vs. reparatie-parsen: wanneer gebruik je wat

De juiste aanpak hangt af van waar je data vandaan komt. Door mensen bewerke configuratiebestanden verdienen strikt parsen om de auteur te dwingen fouten te herstellen. Door machines gegenereerde data van LLM’s of API-logs heeft op reparatie gebaseerd parsen nodig.

Schema-geleide reparaties met Pydantic

Je kunt het reparatieproces geleiden met Pydantic v2 of JSON Schema. Door json_repair een schema te geven, doet de tool meer dan alleen syntax herstellen — het kan typen corrigeren (string "1" omzetten naar getal 1) en ontbrekende verplichte velden met standaardwaarden invullen.

from pydantic import BaseModel
import json_repair

class User(BaseModel):
    id: int
    name: str
    active: bool = True

# Broken JSON with wrong types
raw = '{"id": "42", "name": "Alice"}'
repaired = json_repair.loads(raw)

# Validate against schema
user = User(**repaired)
# user.id is now int(42), user.active defaults to True

Zoals Stefano Baccianella opmerkte in zijn projectcitaat uit 2025, is deze aanpak geoptimaliseerd voor de “meestal correcte maar technisch ongeldige” JSON die taalmodellen doorgaans produceren.

Multi-gigabyte bestanden verwerken zonder crashen

Een fragment van 10KB repareren is eenvoudig. Een bestand van 2GB herstellen vereist een strategie die niet al je RAM opeet. Het hele bestand in het geheugen laden leidt tot Out-of-Memory (OOM)-fouten.

Strategie 1: streamen met ijson

Voor enorme datasets gebruik je ijson om data stuk voor stuk te verwerken. Zoals Scrapfly vermeldt, verwerkt ijson data incrementeel. Combineer het met een opschonings-script dat problemen regel voor regel oplost vóór het parsen.

import ijson

# Stream through a large JSON file
with open('huge_broken.json', 'r') as f:
    for item in ijson.items(f, 'records.item'):
        # Process each item individually
        process(item)

Strategie 2: CLI-pipe voor maximale efficiëntie

De meest geheugenefficiënte aanpak voor grote bestanden is om de jsonrepair CLI te gebruiken en de uitvoer direct naar een nieuw bestand te pipen:

# Streams repair, never loads full file into memory
jsonrepair large_broken.json > fixed.json

Dit is aanzienlijk geheugenefficiënter dan het bestand in Python of een browser laden.

Conclusie

Misvormde JSON herstellen is geen handmatig karwei meer dankzij AI-bewuste bibliotheken zoals json_repair. Je moet nog steeds de basis van RFC 8259 begrijpen — geen afsluitende komma’s, geen enkele aanhalingstekens, geen ontegenoteerde sleutels — maar automatisering is de enige praktische aanpak voor data op schaal in 2026.

De workflow is eenvoudig: probeer eerst een reparatiebibliotheek. Als dat faalt, gebruik je een validator om de exacte syntaxfout te pinpointen. Zo blijven je applicaties draaien, zelfs als inkomende data minder dan perfect is.

Veelgestelde vragen

Ondersteunt JSON officieel opmerkingen of enkele aanhalingstekens?

Nee. De RFC 8259-standaard verbiedt opmerkingen strikt. Enkele aanhalingstekens zijn ook ongeldig — alleen dubbele aanhalingstekens zijn toegestaan voor sleutels en strings. Tools zoals json_repair kunnen opmerkingen echter automatisch verwijderen en aanhalingstekens converteren om bestanden parseerbaar te maken voor standaardbibliotheken.

Hoe verwerk ik zeer grote misvormde JSON-bestanden zonder te crashen?

Gebruik een streaming-parser zoals ijson om data in blokken te verwerken. Vermijd het laden van de hele misvormde string in één variabele. Voor de snelste resultaten gebruik je CLI-reparatietools die uitvoer direct naar een nieuw bestand op schijf pipen zonder alles in het geheugen te houden.

Wat is het verschil tussen misvormde JSON en ongeldige JSON?

Misvormde JSON schendt syntaxregels — ontbrekende haakjes, ontegenoteerde sleutels, afsluitende komma’s — waardoor het onmogelijk te parsen is. Ongeldige JSON volgt alle syntaxregels, maar komt niet overeen met een specifiek JSON Schema (bijv. een veld is een string terwijl het schema een geheel getal verwacht). Misvormde JSON herstellen is structurele reparatie; ongeldige JSON herstellen gaat over data-integriteit.

Kan ik json_repair combineren met Pydantic-validatie?

Ja. Voer eerst json_repair.loads() uit om syntaxfouten te herstellen, en geef de gerepareerde dictionary vervolgens door aan je Pydantic-model voor typevalidatie en schema-afhandeling. Deze tweestaps-aanpak behandelt zowel structurele als semantische problemen.

Hoe zit het met JSON met JavaScript-stijl opmerkingen?

Standaard JSON ondersteunt geen opmerkingen, maar json_repair kan //– en /* */-opmerkingen automatisch verwijderen. Als je opmerkingen in je configuratiebestanden nodig hebt, overweeg dan het JSONC-formaat (JSON met opmerkingen) en een compatibele parser zoals json5 voor Python.