JSON VIEW PARSER

What Minification Removes

Minifying JSON deletes every character of whitespace that sits between tokens: the indentation at the start of lines, the newlines at the end of them, and the conventional spaces after colons and commas. What remains is a single unbroken line.

This is safe for one specific reason: JSON's grammar treats inter-token whitespace as insignificant, so a parser discards it anyway. Removing it in advance changes nothing about the resulting value. Whitespace inside a string is a different matter entirely — there it is data, and a correct minifier never touches it.

// Formatted
{
  "user": {
    "name": "Alex",
    "note": "two  spaces  inside  this  string",
    "scores": [10, 20, 30]
  }
}

// Minified — the spaces inside "note" survive, all others are gone
{"user":{"name":"Alex","note":"two  spaces  inside  this  string","scores":[10,20,30]}}

How Much It Actually Saves

Most minifier pages quote a raw byte reduction and stop there. That number is real but misleading, because it ignores the compression that sits between your server and your users. Here are measured figures for a realistic 50-record paginated API response:

The raw saving looks impressive. The saving that reaches your users is about a quarter of that, because gzip and Brotli are exceptionally good at exactly the thing minification removes — long runs of repeated identical characters. Indentation compresses almost to nothing on its own.

Two conclusions follow. First, enabling compression matters far more than minifying: it took this payload from 13.5 KB to under 900 bytes, a reduction minification cannot approach. If your API is not sending Content-Encoding: gzip, fix that before anything else. Second, minify anyway — an 11% saving on top of compression is free and requires no ongoing effort. Just size your expectations correctly.

Measured with Node's zlib at default settings on a synthetic 50-record response. Your ratios will differ with payload shape — documents with long string values compress differently from those with many short keys.

When Minifying Is Worth It

• API responses. The default for anything crossing a network. Most frameworks minify by default — you generally have to opt in to pretty-printed output.
• Data embedded in HTML. A JSON blob inside a <script> tag is part of your document's critical path, so its size directly delays rendering.
• Bulk storage and logging. When you are writing millions of structured log lines, whitespace is pure cost repeated millions of times.
• Message queues and caches. Redis values, Kafka messages and similar are usually size-capped, and whitespace consumes budget that carries no information.

When Not to Minify

• Files in version control. A minified file is one enormous line, so every change reports the whole line as modified and code review becomes impossible. Keep package.json, tsconfig.json and similar formatted.
• Anything a human edits. Config files are read and modified by people. Optimising them for bytes optimises for the wrong reader.
• Development-mode API responses. Many frameworks pretty-print in development and minify in production, which is exactly the right trade.
• When the real problem is payload design. If a response is genuinely too large, minification will not save you. Returning fewer fields, paginating, or dropping unused nested objects will — those cut information, not formatting.

Minifying in Code

Every standard library minifies by default. Compact output is simply what you get when you do not ask for indentation:

// JavaScript — no third argument means no whitespace
JSON.stringify(data);

// Python — the default separators still include spaces, so be explicit
json.dumps(data, separators=(",", ":"))

// PHP — omit the JSON_PRETTY_PRINT flag
json_encode($data);

// Go
out, err := json.Marshal(data)

// Java (Jackson) — writeValueAsString is compact unless configured otherwise
mapper.writeValueAsString(data);

Python deserves a footnote: json.dumps(data) without arguments still inserts a space after every comma and colon. To get genuinely minimal output you must pass separators=(",", ":"). On a large document that difference is worth a few percent on its own.

From the command line:

# jq: -c produces compact output
jq -c . data.json > data.min.json

# Compact an entire directory of JSON files
for f in *.json; do jq -c . "$f" > "$f.min"; done

Minifying on This Site

Paste your JSON into the input panel and press Alt + Shift + M, or use the minify action in the input toolbar. The document is parsed first — so an invalid document will report its error rather than being mangled — and then re-serialised without whitespace. You can copy the result or download it as a file.

The operation runs entirely in your browser. Nothing is uploaded, which makes it safe for real payloads. To go the other way, the formatter restores full indentation from any minified document.

Frequently Asked Questions