Hoe formatteer en valideer je JSON: gids voor developers

JSON is overal: API-responses, config-bestanden, logs, message queues, request-payloads, databasekolommen. Voor zo’n simpel formaat is het verrassend hoe vaak we er last mee hebben — een ontbrekende komma breekt een deployment, een extra whitespace-karakter maakt twee bestanden “verschillend” terwijl ze identiek zouden moeten zijn, een diep geneste structuur is onmogelijk te debuggen omdat niemand hem heeft ingesprongen.

Wat JSON eigenlijk toestaat

De JSON-spec is bewust piepklein. Een JSON-document is een van:

• Een object: { "key": value, ... }
• Een array: [ value, ... ]
• Een string: "text" (altijd dubbele aanhalingstekens, nooit enkele)
• Een number: 42, 3.14, -2.5e10
• Een boolean: true of false
• null

Dat is alles. Geen comments. Geen trailing commas. Geen unquoted keys. Geen enkel-quoted strings. Geen undefined, geen NaN, geen functies.

Als je je ooit hebt afgevraagd waarom een JSON-parser je “duidelijk geldige” bestand weigerde, is het meestal een van deze:

{
  "name": "Alice",
  "age": 30, // ← comment: NIET geldige JSON
  "email": 'alice@...', // ← enkele quotes: NIET geldige JSON
  role: "admin", // ← unquoted key: NIET geldige JSON
  "active": true, // ← trailing comma: NIET geldige JSON
}

De formaten die wel deze versoepelingen toestaan zijn JSON5 (staat comments, trailing commas, unquoted keys toe) en JSONC (JSON met Comments, gebruikt door VS Code config-bestanden). Het zijn supersets van JSON maar vereisen speciale parsers.

Formatteringsregels die JSON leesbaar maken

Geminifiede JSON ziet er zo uit:

{"users":[{"id":1,"name":"Alice","roles":["admin","editor"]},{"id":2,"name":"Bob","roles":["viewer"]}]}

Geformatteerde JSON ziet er zo uit:

{
  "users": [
    {
      "id": 1,
      "name": "Alice",
      "roles": ["admin", "editor"]
    },
    {
      "id": 2,
      "name": "Bob",
      "roles": ["viewer"]
    }
  ]
}

Dezelfde data, compleet andere leesbaarheid.

De formatteringsregels die ertoe doen: gebruik 2 spaties als inspringen (verreweg de meest gebruikelijke conventie), één key per regel binnen objecten, een spatie na de dubbele punt ("key": value), en arrays van objecten altijd op meerdere regels. Arrays van primitives op één regel wanneer kort is prima.

Onze JSON Formatter past dit allemaal automatisch toe als je op Format klikt.

JSON valideren: waar moet je op letten

1. Ontbrekende of extra komma

Verreweg de meest voorkomende. Syntactisch ongeldige JSON heeft bijna altijd een komma-probleem.

{
  "a": 1,
  "b": 2 ← ontbrekende komma
  "c": 3
}

Let op: de parser wijst naar de regel na de ontbrekende komma, wat misleidend kan zijn.

2. Niet-gesloten string

Een verdwaalde newline binnen een string, of een ontbrekend sluitend aanhalingsteken:

{ "name": "Alice
} 

JSON staat geen letterlijke newlines in strings toe. Je moet ze escapen als \n.

3. Niet-overeenkomende brackets

Een extra } of ] ergens in een bestand. De meeste parsers melden de eerste bracket die niet matcht, wat ver van de werkelijke fout kan liggen.

4. Ongeldig nummer

JSON-nummers volgen strikte regels: geen leidende +, geen leidende nullen (behalve 0.x), geen 1. zonder trailing digit, geen .5 zonder leidende nul.

{ "a": +5, "b": 07, "c": 1., "d": .5 } ← allemaal ongeldig

5. Ge-escapete karakters in strings

Backslashes en quotes binnen strings moeten worden ge-escapet:

{ "path": "C:\Users\Alice" } ← ongeldig (backslash niet ge-escapet)
{ "path": "C:\\Users\\Alice" } ← geldig

6. Dubbele keys

Technisch zegt de JSON-spec dat dubbele keys “toegestaan maar afgeraden” zijn. In de praktijk nemen de meeste parsers stilzwijgend de laatste waarde. Dit is vrijwel altijd een bug.

{ "name": "Alice", "name": "Bob" }

Hoe je formatteert en valideert in de praktijk

De snelste workflow:

1. Plak de verdachte JSON in een formatter
2. Klik op Format
3. Als het accepteert, lees de geformatteerde output om de structuur te begrijpen
4. Als het weigert, lees de foutmelding zorgvuldig — het regelnummer ligt meestal dichtbij, maar niet precies op, het echte probleem

Onze JSON Formatter gebruikt de ingebouwde JSON.parse van de browser — dezelfde parser die elke Node.js-API en webservice gebruikt. Elke foutmelding die je ziet is dezelfde die een echte JSON-API zou geven.

De minify / format toggle

Formatters hebben meestal twee knoppen:

• Format (of Beautify, Pretty-print): voegt whitespace en inspringen toe voor menselijke leesbaarheid
• Minify (of Compact): verwijdert alle onnodige whitespace

Geminifiede JSON wordt gebruikt wanneer byte-grootte telt — verzenden over het netwerk, opslaan in een database, insluiten in een URL. Het is functioneel identiek aan geformatteerde JSON maar merkbaar kleiner voor grote documenten.

Geformatteerd: 1.240 bytes
Geminifieerd: 680 bytes (-45%)

Voor productie-API-responses: altijd minifiëren. Voor config-bestanden, logs en alles wat mensen lezen: altijd formatteren.

Tools buiten de formatter

Zodra je JSON geformatteerd en geldig is, zijn deze tools het weten waard:

JSON schema — een manier om te definiëren welke velden een geldig document moet hebben, met types en constraints. Als je een JSON-shape hebt die je over meerdere documenten wilt afdwingen, schrijf een schema en valideer ertegen.

JMESPath / jq — query-talen voor het extraheren of transformeren van JSON. jq is de de-facto command-line tool.

JSON diff — tools die laten zien wat er is veranderd tussen twee JSON-documenten, nuttiger dan een tekst-diff.

Snelle referentie-cheatsheet

Nodig	Wat te doen
JSON leesbaar maken	Formatteren met 2-spaties indent
Verkleinen voor transport	Minifiëren
Syntax-fout vinden	Plak in een formatter, noteer fout-locatie
Checken of twee documenten “hetzelfde” zijn	Minifiëer beide en vergelijk byte-voor-byte, of gebruik een echte JSON diff
Structuurvalidatie toevoegen	Gebruik JSON Schema
Opslaan in een URL of cookie	Minifiëren en URI-encoden

Een workflow-tip

Plak nooit ruwe JSON in een e-mail, chatbericht of issue tracker zonder eerst te formatteren. Geminifiede JSON in een GitHub-issue is op het randje van onleesbaar en verspilt de tijd van de lezer. Dertig seconden in een formatter verandert een muur van tekst in een leesbare structuur.

En wanneer je een echte API-response debugt, pipe hem door een formatter voordat je hem probeert te begrijpen. console.log(JSON.stringify(data, null, 2)) is het universeel correcte patroon voor debuggen.

Onze JSON Formatter draait in je browser — geen uploads, nergens iets gelogd. Plak JSON erin, klik op Format of Minify, klik op Copy, klaar. Schonere commits, duidelijkere bugs, snellere reviews. De dertig seconden per document waard.