Minify JSON Payloads for CDN Cache Optimization

A catalog exported pretty for human review, then served from the edge as-is. Minifying before upload cuts stored bytes by about a third.

Before (pretty, 318 bytes):
{
  "products": [
    {
      "id": "sku-1",
      "price": 19.99,
      "stock": 42
    }
  ]
}

After (minified, 214 bytes · 33% smaller):
{"products":[{"id":"sku-1","price":19.99,"stock":42}]}

Exports often emit every optional attribute as null. With Also remove null values on, the unset attributes drop out — only enable it if clients treat absent and null identically.

Before:
{"id":"sku-2","name":"Widget","discount":null,"badge":null}

After (removeNulls on):
{"id":"sku-2","name":"Widget"}

Note: clients can no longer read discount/badge as null.

The same catalog always minifies to the same bytes, so its content hash is stable. Re-minifying an unchanged file produces an identical filename and keeps the cache warm.

products.json (minified, run 1):  {"v":3,"items":[1,2,3]}
products.json (minified, run 2):  {"v":3,"items":[1,2,3]}

Identical bytes → identical sha256 → products.<samehash>.json
No new cache object created; existing edge cache stays valid.

A feature-flag config with a trailing comma fails here, before it is deployed and cached against you for the full TTL.

Input (trailing comma):
{"flags":{"newCheckout":true,}}

Result: parse error — "Unexpected token } in JSON".
Fix the source (or run json-format-fixer), then minify and deploy.

Pricing data assembled from several sources mixes number forms. Minification canonicalises them; the values are unchanged.

Before:
{"USD":19.990,"EUR":18.50,"discount_pct":10.0}

Minified:
{"USD":19.99,"EUR":18.5,"discount_pct":10}

Numerically identical; only the textual form changed.

Also remove null values deletes null fields and null array elements from the file you upload. Clients that read record.discount === null to mean 'no discount' will instead get undefined. Only enable it if every consumer of the cached file treats absent and null the same — otherwise keep it off and let compression handle the whitespace.

Brotli/Gzip at the edge already strips whitespace before sending, so for compression-capable clients the egress saving from minified-vs-pretty is small. The durable wins from minifying are lower storage cost (objects are stored uncompressed) and smaller transfers to clients that do not send Accept-Encoding. Measure the storage delta, not just egress.

The tool parses before serializing, so a catalog with a trailing comma, comment, or truncated array is rejected — better here than after it is cached at the edge for the full TTL. Repair non-standard JSON with json-format-fixer first, then minify the clean output.

Numeric IDs above 2^53 lose precision on the round-trip. If your catalog carries 64-bit SKUs or order numbers as JSON numbers, store them as strings before minifying so the cached file is byte-exact. This is a JavaScript number limitation, not a CDN-specific one.

Minification itself is deterministic, but if your upstream export reorders keys or array elements between runs, the minified bytes differ each time and the content hash changes even when the data did not — re-fetching unchanged catalogs. Stabilise the export (sort keys/rows at the source) so minification produces a stable hash. The minifier preserves whatever order it receives.

Free accounts accept up to 2 MB. A large product catalog can exceed that; Pro raises the limit to 100 MB. For very large catalogs, consider splitting into per-category files (better cache granularity at the edge) rather than serving one giant JSON object.

A .ndjson/.jsonl snapshot with many top-level objects fails — the tool parses the whole input as one JSON value. To serve such data compactly, wrap the records in a single array or minify line by line. The extensions are accepted only when the file content is one valid JSON value.

A leading byte-order mark or non-UTF-8 encoding can make the input fail to parse. The tool trims leading whitespace but expects UTF-8 JSON. Re-export the file as UTF-8 without a BOM before minifying; the output is UTF-8 with non-ASCII characters preserved as literals.