How much smaller does minified JSON get?

It depends entirely on indentation width and nesting depth, since that's exactly what the removed whitespace scales with; the data itself never shrinks. Lightly indented, shallow JSON often saves around 25-30%, while deeply nested JSON with 4-space indentation can shrink by 70% or more, because every additional nesting level multiplies the amount of leading whitespace on every line. A flat, single-level object with short keys might barely shrink at all, since there was very little whitespace to remove in the first place. The tool computes and shows the exact original size, minified size, and percentage saved after every run using the Blob API, so you don't have to estimate. You can see precisely what you gained for your specific document instead of relying on a rule of thumb.

Does minifying change the data itself?

No. Minifying only removes insignificant whitespace between tokens, the spaces, tabs, and line breaks that exist purely for human readability. Keys, values, array items, and their order are all preserved exactly, including whitespace that appears inside a quoted string value, which is data, not formatting, and is left untouched. The tool parses your input with JSON.parse() and re-serializes it with JSON.stringify() and no indentation argument, so the output is guaranteed to parse to a value that is deeply equal to the input's parsed value. If you ever need to confirm that minifying didn't alter anything, running the original and minified versions through our JSON Diff tool will show zero differences.

Should I minify JSON before sending it over an API?

If bandwidth matters (mobile clients, high request volume, metered connections) it can help, but for most APIs gzip or Brotli compression at the HTTP layer already eliminates most of the benefit of manual minification, since compression algorithms are extremely good at collapsing repeated whitespace patterns like indentation on their own. Where minification still earns its keep is in contexts that never go through HTTP compression at all: config files read directly by an application, values embedded in a URL query string, or JSON stored in a database column where every byte counts toward a column limit. As a rule, minify for storage and transport contexts without compression, and don't bother minifying JSON that's about to be gzipped anyway.

Is my JSON uploaded to a server when I minify it?

No. Minification runs entirely client-side using your browser's built-in JSON.parse() and JSON.stringify(), the exact same functions any JavaScript runtime uses internally, so there's no backend endpoint this page calls and no custom parsing logic to trust. Your document is never sent over the network, logged, or stored. Watch your browser's network panel while minifying and you can verify this yourself. This matters most when you're minifying production config, embedded credentials in a sample payload, or real user data pulled from a bug report, since none of it ever leaves your machine, and it's also why there's no practical file-size limit imposed by the tool itself, only the memory available to your browser tab.

What's the difference between the JSON Minifier and the JSON Formatter?

They're inverses built on the same parse-then-reserialize approach, just pointed at opposite goals for the whitespace argument passed to JSON.stringify(). The formatter adds indentation and line breaks to make JSON easy for a human to read; the minifier removes all of it to make the same data as small as possible for storage or transfer. Neither tool changes the underlying value, so minifying already-formatted JSON and formatting already-minified JSON both round-trip to an identical parsed result. Use the formatter while you're actively reading or editing JSON by hand, and switch to the minifier only at the point you're about to store or ship it.

Can I minify JSON that contains multi-byte or emoji characters correctly?

Yes. The tool measures both the original and minified size with the Blob API rather than JavaScript string length, so a character like é or an emoji, which occupies more than one byte in UTF-8, is counted correctly in the reported savings instead of being undercounted as a single character. The minification itself is unaffected either way: JSON.stringify() preserves Unicode string content exactly regardless of byte width, only the whitespace between tokens is removed. If your data is heavy on non-ASCII text, expect the percentage saved to be a bit lower than a similarly indented all-ASCII document, since a larger share of the original size was already character data rather than removable whitespace.

Why does minifying already-minified JSON show 0% savings?

Because there's no insignificant whitespace left to remove. Minification is idempotent: it parses the input into a JavaScript value and re-serializes it with JSON.stringify() and no indentation argument, so running it again on output that has already gone through this process (or was never indented to begin with, like most real API responses) produces byte-identical output. A 0% result isn't an error, it's confirmation that your input was already in its most compact valid form. It's a useful quick check too, since pasting a document and seeing near-zero savings tells you its size is coming from the data itself, not from formatting overhead.

JSON Minifier - Compress & Minify JSON Online

Overview

Introduction

Every space, tab, and newline in a pretty-printed JSON file is bytes that add no meaning for a machine reading it. This tool strips all of that out, leaving the smallest valid JSON representation of the same data.

It matters most in places where every byte is counted rather than just skimmed: an environment variable with a length limit, a URL query parameter, a CSV cell holding a serialized object. Indentation that makes a config file pleasant to read in an editor is pure overhead once that file is loaded by a parser, and this tool removes it in one pass instead of asking you to hand-edit the string.

What Is JSON Minifier?

A JSON minifier removes insignificant whitespace, such as indentation, line breaks, and extra spaces around punctuation, without altering the structure or values of the document.

The result is a single unbroken line that parses to exactly the same value as the formatted input. Nothing about the data itself changes: key order, value types, and nesting are all preserved, only the whitespace between tokens disappears.

How JSON Minifier Works

The input is parsed with JSON.parse to confirm validity, then re-serialized with JSON.stringify and no indentation argument, which produces the most compact valid JSON string possible. The tool also reports the original size, the minified size, and the percentage saved.

Because minification round-trips through a real parser rather than stripping whitespace with a regex, it's safe even against whitespace-like characters that happen to sit inside a quoted string. Those are left untouched since the parser treats them as data, not formatting. The size comparison is computed with the Blob API so multi-byte UTF-8 characters are counted correctly rather than by raw string length.

When To Use JSON Minifier

Reach for this when you need to embed JSON in a single-line context, an environment variable, a URL query string, a CSV cell, or when you're hand-optimizing the size of a config file that will be checked into source control or shipped in a build.

It's also useful as a quick sanity check on how much a document's formatting is costing you. Pasting a deeply nested, heavily indented file and seeing an 80%+ reduction tells you the indentation, not the data, is what's driving the file size.

Often used alongside JSON Formatter & Beautifier and JSON Validator.

Features

Advantages

Produces a byte-for-byte valid, smaller JSON payload.
Shows exact size savings so you can judge whether it's worth it.
Fully client-side, so there are no size limits imposed by an upload endpoint.
Safe to run repeatedly; minifying already-minified JSON is a no-op.

Limitations

Cannot minify invalid JSON: input must parse successfully first.
Does not shorten key names or restructure data; it only removes whitespace.
For payloads sent over HTTP, gzip/Brotli compression usually outperforms manual minification, so the practical benefit is context-dependent.

Typical Savings by JSON Style

Typical Savings by JSON Style
JSON style	Original size	Minified size	Saved
Shallow, 2-space indent	48 B	35 B	27%
Typical API response, 2-space indent	250 B	153 B	39%
Deeply nested, 4-space indent	550 B	79 B	86%

Examples

Pretty JSON to compact JSON

Input

{
  "id": 1,
  "active": true
}

Output

{"id":1,"active":true}

All indentation and line breaks are removed while the data stays identical.

Nested object with an array

Input

{
  "user": {
    "name": "Ana",
    "roles": [
      "admin",
      "editor"
    ]
  }
}

Output

{"user":{"name":"Ana","roles":["admin","editor"]}}

Whitespace is removed at every nesting level, not just the outermost one. 89 bytes shrink to 50, a 43.8% reduction, all of it coming from indentation and line breaks rather than any change to the data.

Multi-byte and emoji characters

Input

{
  "city": "Zürich",
  "emoji": "🚀",
  "note": "café"
}

Output

{"city":"Zürich","emoji":"🚀","note":"café"}

Non-ASCII string content is preserved exactly; only the whitespace between tokens is removed. Because sizes are measured with the Blob API, the reported savings (61 bytes to 48, 21.3%) correctly account for the extra UTF-8 bytes multi-byte characters like ü, 🚀, and é occupy, unlike a naive character-count comparison.

Whitespace inside a string value is left untouched

Input

{
  "text": "line1\nline2   with   spaces"
}

Output

{"text":"line1\nline2   with   spaces"}

Only whitespace between JSON tokens is insignificant and removable. The \n escape and the literal spaces inside the "text" string are data, not formatting, so the parser preserves them exactly even though the surrounding structural whitespace disappears.

Already-minified input is a no-op

Input

{"id":1,"active":true}

Output

{"id":1,"active":true}

Minification is idempotent: with no insignificant whitespace left to strip, the output is byte-identical to the input and the reported savings are 0%, confirming rather than failing the operation.

Trailing comma prevents minification entirely

Invalid input

{"a":1,"b":2,}

Parser error

Expected double-quoted property name in JSON at position 13 (line 1 column 14)

Minification requires the input to parse successfully first. A trailing comma after the last property is not valid JSON, so parsing fails and no output is produced, only the exact position of the syntax error.

Corrected version

{"a":1,"b":2}

Best Practices & Notes

Best Practices

Minify JSON that will live in a single-line environment variable or .env file.
Keep a formatted copy in version control and minify only at build/deploy time for readability during review.
Pair minification with HTTP compression rather than treating it as a replacement.
Check the reported savings before deciding it's worth doing. If a document is already near-flat with short keys, minification may only save a handful of bytes and isn't worth adding a build step for.
When embedding JSON in a URL query parameter, minify first and then percent-encode the result, since minifying after encoding won't remove the whitespace hidden inside the encoded string.
For JSON that's about to be gzipped or Brotli-compressed at the HTTP layer anyway, skip manual minification. Compression already collapses repeated whitespace far more effectively than stripping it by hand.

Developer Notes

Byte sizes are computed with the Blob API on the raw string ('new Blob([input]).size'), which correctly accounts for multi-byte UTF-8 characters rather than simply counting JavaScript string length (which counts UTF-16 code units and would misreport the size of any non-ASCII content). Minification itself is JSON.parse() followed by JSON.stringify(parsed) with no space argument, the most compact serialization JSON.stringify() can produce. There's no custom whitespace-stripping regex involved, which is what guarantees whitespace inside quoted string values is never touched. Because the operation is a full parse-and-reserialize round trip rather than a token-level rewrite, minifying is exactly as safe as formatting: if the input parses, the output is guaranteed valid and semantically identical.

JSON Minifier Use Cases

Shrinking a JSON config file before bundling it into a build artifact
Fitting JSON into a single-line environment variable
Reducing the size of JSON stored in localStorage or a cookie
Preparing compact JSON fixtures for unit tests
Shortening a JSON blob embedded in a URL query parameter or a QR code payload
Comparing minified sizes across a few JSON documents to see which is driving the most bloat from indentation versus actual data

Common Mistakes

Assuming minification alone solves large-payload performance problems, when server-side compression usually matters more.
Minifying JSON that a human still needs to edit by hand, making future changes error-prone.
Expecting minification to shorten key names or restructure data; it only removes whitespace between tokens, key names and nesting stay exactly as they were.
Re-minifying an already-minified file and being surprised by a 0% savings result, when that's simply confirmation there was no whitespace left to remove.

Tips

Check the reported savings percentage: if it's near zero, the JSON was likely already compact.
Keep an un-minified source file and regenerate the minified version as a build step instead of editing minified JSON directly.
If savings seem lower than expected for a document with lots of non-ASCII text, remember the Blob-based byte count reflects UTF-8 encoding, not character count, so the ratio of whitespace to data content matters more than raw character totals.
Use the JSON Diff tool on the original and minified output if you ever want independent confirmation that minifying didn't alter any values.

JSON Minifier

Overview

Introduction

What Is JSON Minifier?

How JSON Minifier Works

When To Use JSON Minifier

Features

Advantages

Limitations

Typical Savings by JSON Style

Examples

Pretty JSON to compact JSON

Nested object with an array

Multi-byte and emoji characters

Whitespace inside a string value is left untouched

Already-minified input is a no-op

Trailing comma prevents minification entirely

Best Practices & Notes

Best Practices

Developer Notes

JSON Minifier Use Cases

Common Mistakes

Tips

References

Frequently Asked Questions