JSON-minificatie: wanneer het belangrijk is en wanneer niet
JSON minifiëren kan 30-50% bestandsgrootte besparen - maar alleen als het verderop in de keten uitmaakt. Dit is wanneer je de moeite neemt, wanneer je het overslaat, en hoe je het veilig doet.
Minificatie is het proces van alle onnodige whitespace uit een JSON-document halen. Een geprettified bestand van 2 KB krimpt doorgaans naar rond de 1,2 KB — een besparing van 35-45%. Simpel genoeg. De vraag is: maakt het voor jouw use case uit om die bytes te besparen?
Vaak niet. En JSON minifiëren die niet geminifieerd hoeft te worden maakt het alleen maar lastiger voor mensen om te lezen.
Wat minificatie echt doet
Minificatie verwijdert inspringen, newlines tussen keys en brackets, spaties na dubbele punten en komma’s, en trailing whitespace.
Het verwijdert niet: aanhalingstekens (vereist), keynamen (data, geen formattering), of dubbele en ongebruikte keys (ook data).
Geformatteerd:
{
"name": "Alice",
"role": "admin",
"active": true
}
Geminifieerd:
{"name":"Alice","role":"admin","active":true}
Beide parsen naar hetzelfde identieke JavaScript-object. Het enige verschil zijn bytes op disk of op de lijn.
Hoeveel je in de praktijk bespaart
De besparing varieert met hoe “dicht” de JSON is:
| Type content | Typische geformatteerde grootte | Geminifieerd | Besparing |
|---|---|---|---|
| Config-bestand (klein, mens-getweakt) | 800 B | 450 B | ~45% |
| API-response (veel kleine records) | 12 KB | 7 KB | ~40% |
| Document met lange strings | 50 KB | 43 KB | ~15% |
| Document met vooral nummers | 8 KB | 4,5 KB | ~45% |
De besparing is het grootst wanneer de JSON structureel complex is met korte waarden, en het kleinst wanneer het een handvol grote strings bevat.
Wanneer wel minifiëren
Productie-API-responses. Als je JSON van een server naar een client over het netwerk stuurt, minifieer het. Voor een high-traffic API betekent 40% kleinere payloads 40% minder uitgaande bandbreedte. De inspringing is dood gewicht in productie. Reserveer geformatteerde output voor development-omgevingen of debug-endpoints.
JSON ingebed in URL’s of cookies. URL’s hebben lengtelimieten (meestal is 2048 bytes veilig). Cookies hebben groottelimieten (4 KB per cookie). Elke byte telt.
JSON opgeslagen in databases of logs. Als je ruwe JSON opslaat in een TEXT-kolom, minifieer voor insert. Over miljoenen rijen bespaar je echte schijfruimte. Voor gestructureerde logs: minifieer om regels op één schermregel leesbaar te houden.
JSON gebundeld in JavaScript of HTML. Als je JSON inline zet in een JavaScript-bestand of HTML (bijv. een <script type="application/json">-blok), minifieer het. De bundler doet het niet betrouwbaar voor je, en de bespaarde bytes komen direct uit je paginagewicht.
Wanneer niet minifiëren
Configuratie-bestanden. Een package.json, tsconfig.json of elk ander config-bestand dat developers bewerken, moet geformatteerd blijven. Minifiëren maakt review, bewerking en debugging veel lastiger voor nul praktisch voordeel.
JSON opgeslagen in Git. Geformatteerde JSON levert bruikbare diffs op. Geminifieerde JSON levert één gigantische regel op die volledig verandert bij elke kleine bewerking.
# Geformatteerd:
- "version": "1.0.2",
+ "version": "1.0.3",
# Geminifieerd (één regel):
-{"name":"app","version":"1.0.2","dependencies":{...}}
+{"name":"app","version":"1.0.3","dependencies":{...}}
Commit geformatteerde JSON. Altijd.
Voorbeelddata in documentatie. Als je een JSON-structuur toont in docs, een blogpost of een README: formatteer het. Lezers moeten de shape begrijpen.
Debug-output. Wanneer je probeert te begrijpen wat er van een API terugkwam, is geformatteerd altijd beter. console.log(JSON.stringify(data, null, 2)) is het universeel correcte patroon voor debuggen.
Fixtures en testdata. Geminifieerde testfixtures maken falende tests moeilijker te diagnosticeren. Houd ze geformatteerd.
Compressie en minificatie samen
De meeste webservers passen automatisch gzip- of brotli-compressie toe op JSON-responses. Gzip comprimeert JSON doorgaans naar 15-25% van de originele grootte.
Na compressie krimpt het verschil tussen geformatteerde en geminifieerde JSON significant:
| Staat | Grootte |
|---|---|
| Geformatteerd | 12 KB |
| Geminifieerd | 7 KB |
| Geformatteerd + gzip | 3,5 KB |
| Geminifieerd + gzip | 2,8 KB |
Zodra je gzip in de pipeline hebt, bespaart minificatie ~20% in plaats van ~40%. Nog steeds de moeite waard voor high-traffic API’s, maar minder kritiek dan de naïeve getallen suggereren.
Gzip je niet je JSON-responses? Fix dat eerst. Gzip alleen al is een grotere win dan minificatie.
Hoe te minifiëren
In JavaScript/Node:
const minified = JSON.stringify(obj); // geen indent-arg = geminifieerd
const formatted = JSON.stringify(obj, null, 2); // 2-spaties indent
Command line met jq:
jq -c . input.json > minified.json # -c voor compact
Online: onze JSON Formatter heeft een Minify-knop. Alles draait in je browser — geen upload, geen data gelogd, gevoelige JSON blijft veilig.
Een simpele beslisstroom
- Gaat deze JSON over een netwerk in productie? → Minifiëer
- Gaat het in een URL, cookie of localStorage? → Minifiëer
- Leest of bewerkt een mens het? → Niet minifiëren
- Is het gecommit in Git? → Niet minifiëren
- Is het logs of opgeslagen data die tijdens een incident gelezen kan worden? → Niet minifiëren
- Nog steeds onzeker? → Niet minifiëren. Leesbaarheid is bijna altijd meer waard dan de bespaarde bytes.
Minifiëer wanneer het wordt geparsed door een machine en nooit gelezen door een mens; formatteer wanneer iemand er ooit naar zal kijken. De bytes bespaard door minificatie tellen in aggregaat op schaal; de tijd die verloren gaat aan onleesbare JSON telt voor elke persoon die het bestand opent.
Onze JSON Formatter heeft zowel Format- als Minify-knoppen, draait in je browser en stuurt niets ergens heen. Formatteren om te lezen, minifiëren om te shippen — één klik per richting.