JSON Minifier
Compress JSON by removing all unnecessary whitespace with our free JSON minifier tool. Reduce file sizes for faster network transmission, smaller storage, and optimized API responses.
What JSON Minification Does
| Aspect | Before | After |
|---|---|---|
| Whitespace | Present | Removed |
| Line breaks | Multiple | None |
| Indentation | Formatted | None |
| File size | Larger | Smaller |
Size Reduction Examples
| Original | Minified | Savings |
|---|---|---|
| 1 KB | 600 bytes | 40% |
| 10 KB | 6 KB | 40% |
| 100 KB | 60 KB | 40% |
Minification Code
``javascript
function minifyJSON(jsonString) {
try {
const parsed = JSON.parse(jsonString);
return JSON.stringify(parsed);
} catch (e) {
throw new Error('Invalid JSON: ' + e.message);
}
}
// Example
const formatted = {
"name": "John",
"age": 30
};
console.log(minifyJSON(formatted));
// Output: {"name":"John","age":30}
`
When to Minify JSON
| Use Case | Reason |
|---|---|
| API responses | Faster transmission |
| Configuration files | Smaller bundles |
| Storage | Reduced space |
| Caching | More data fits |
| Network transfer | Lower bandwidth |
Compression Comparison
| Format | Size | Readable |
|---|---|---|
| Beautified JSON | 100% | Yes |
| Minified JSON | ~60% | No |
| Gzipped minified | ~15% | No |
Best Practices
1. Minify for production - Reduce payload sizes
2. Keep source beautified - Maintain readability in version control
3. Combine with Gzip - Server compression adds more savings
4. Validate first - Ensure JSON is valid before minifying
Use this minifier to optimize your JSON for production deployments.
Numbers Are the Recurring Problem
A JSON number is an IEEE 754 double. Three consequences that bite in production:
| Value | What happens |
|---|---|
| Integers above 2⁵³ | Silently lose precision — send IDs as strings |
| Money as a float | 0.1 + 0.2 = 0.30000000000000004 |
| Leading zeros | 007 is invalid JSON; "007" is a string |
NaN and Infinity | Not valid JSON at all |
Twitter hit the first one publicly: 64-bit tweet IDs arrived in JavaScript rounded, so the
API began sending an id_str alongside every id.Keys, Order and Duplicates
Objects are formally unordered, though every JavaScript engine preserves insertion order for
string keys — with one exception: integer-like keys sort numerically and come first.
`javascript
JSON.stringify({ b: 1, 2: 2, a: 3 }); // {"2":2,"b":1,"a":3}
`
Duplicate keys are not an error in the spec, and JSON.parse keeps the last one. Two
parsers can legitimately disagree about which value wins, which has been the basis of real
request-smuggling attacks.
Before and After
`json
{"id":1,"name":"Ada","tags":["a","b"]}
`
becomes
`json
{
"id": 1,
"name": "Ada",
"tags": ["a", "b"]
}
`
Formatting changes only whitespace. The parsed value is identical, which is why a formatter can never fix invalid JSON — it has to parse it first.
Rules That Prevent Most JSON Bugs
| Rule | Why |
|---|---|
| No trailing commas | {"a": 1,} is invalid JSON, though JavaScript accepts it in object literals |
| Double quotes only | {'a': 1} is not JSON |
| Keys must be quoted | {a: 1} is a JavaScript object, not JSON |
| No comments | There is no comment syntax; JSON5 and JSONC are different formats |
No undefined, NaN, Infinity | JSON.stringify silently drops or nulls them |
| Numbers are IEEE 754 doubles | Integers above 2⁵³ lose precision — send them as strings |
Parsing Safely
`javascript
try {
const data = JSON.parse(text);
} catch (error) {
// The message names the character offset, which is the fastest way
// to find an unescaped quote in a large document.
console.error(error.message);
}
`
JSON.parse` throws on invalid input rather than returning null, so it always belongs in a try/catch when the source is a file, a request body or a clipboard paste.