Minificar JSON para producción: ahorro real, Gzip y minificadores que cambian tus datos

Minificar JSON elimina los espacios que lo hacen legible: sangrías, saltos de línea y los espacios después de `:` y `,`. Los datos siguen siendo los mismos y el archivo suele reducirse en un tercio o más. Que eso importe depende de otra cosa: si la respuesta ya va comprimida. Y no todos los minificadores se limitan a quitar espacios: algunos cambian números y claves sin avisar.

Qué elimina la minificación

JSON permite espacios entre tokens y los ignora. Minificar los quita todos, dejando solo los espacios dentro de los strings, que son datos.

{
  "id": 42,
  "nombre": "Ada Lovelace",
  "roles": [
    "admin",
    "editor"
  ]
}

{"id":42,"nombre":"Ada Lovelace","roles":["admin","editor"]}

Un minificador sin pérdidas trabaja con tokens: copia strings, números y literales tal como están escritos y descarta todo lo que hay entre ellos. La distinción importa más adelante, porque muchos "minificadores" populares funcionan de otra manera.

Cuánto se ahorra de verdad

Esta es una respuesta de API realista, 200 productos con campos anidados, medida con sangría de dos espacios y minificada, y después comprimida como lo haría un servidor web:

                    sin comprimir   gzip      brotli
con sangría         52.1 KB         3.5 KB    1.9 KB
minificado          29.3 KB         3.2 KB    1.6 KB
ahorro              44%             ~9%       ~16%

Sin comprimir, minificar redujo el tamaño casi a la mitad, porque la sangría crece con la profundidad del anidamiento. Con compresión, la mayor parte de esa diferencia desaparece: las secuencias repetidas de espacios son justo lo que gzip y Brotli eliminan mejor. Tus números variarán, pero el patrón se mantiene.

Por eso minificar vale más donde no hay compresión: JSON guardado en bases de datos, cachés y colas; incrustado en HTML dentro de <script type="application/json">; guardado en localStorage, con su cuota de unos 5 MB; enviado por servidores que no comprimen, y en logs JSON Lines. En las API HTTP, activa primero la compresión: ahorra mucho más que minificar.

Cómo minificar JSON en cada entorno

# jq: -c para salida compacta
jq -c . formateado.json > minificado.json

# Python (sin paquetes externos)
python3 -c "import json,sys; json.dump(json.load(sys.stdin), sys.stdout, separators=(',',':'))" < formateado.json

# Node.js
node -e "process.stdout.write(JSON.stringify(JSON.parse(require('fs').readFileSync(0,'utf8'))))" < formateado.json

import json
json.dumps(datos)                          # '{"a": 1, "b": 2}' - espacios tras : y ,
json.dumps(datos, separators=(',', ':'))   # '{"a":1,"b":2}'    - totalmente compacto

json.dumps de Python no es totalmente compacto por defecto: añade un espacio después de cada : y ,. Pasa separators de forma explícita. En PHP, json_encode ya es compacto por defecto y solo formatea con JSON_PRETTY_PRINT. También escapa / como \/ y los caracteres no ASCII como \uXXXX salvo que añadas JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE, lo que a menudo ahorra más bytes que quitar espacios.

Minificadores que cambian tus datos

Los comandos anteriores analizan el JSON a valores nativos y lo vuelven a serializar. Eso no es solo un cambio de espacios, y las diferencias son silenciosas. El mismo texto pasado por JSON.stringify(JSON.parse(…)) en Node.js:

entrada: {"id":12345678901234567890,"precio":1.0,"a":1,"a":2,"s":"\u00e9"}
salida:  {"id":12345678901234567000,"precio":1,"a":2,"s":"é"}

Los enteros grandes pierden precisión, porque los números de JavaScript son flotantes de 64 bits, exactos solo hasta 9007199254740991. 1.0 pasa a 1, las claves duplicadas se reducen al último valor y los escapes se normalizan, así que pueden cambiar los bytes de cualquier string.

jq conserva los enteros grandes desde la versión 1.7 mientras no haga cálculos con ellos, y el módulo json de Python conserva enteros de cualquier tamaño. Ninguno conserva claves duplicadas. Cuando los bytes exactos importan, porque se calcula una firma o un hash sobre el JSON, no lo reserialices: firma los bytes minificados que envías o usa una forma canónica como JSON Canonicalization Scheme (RFC 8785) en ambos lados.

Minificar no es validar, ni convierte JSONC

Un minificador por tokens puede dejar pasar JSON inválido tal cual, y uno basado en parser lo rechaza. Ninguno lo corrige. Si el origen es JSON con comentarios (JSONC, como tsconfig.json) o JSON5, elimina comentarios y comas finales con una herramienta que entienda ese formato, o el resultado no será JSON válido.

Valida después de minificar en tu pipeline: jq empty minificado.json termina con error si el JSON es inválido y no imprime nada si es correcto.

Mantén legible el desarrollo

Minifica en el borde, no en el código fuente. Guarda configuración, fixtures y snapshots de tests con formato en el repositorio para que los diffs sean legibles, y minifica durante el build o al serializar. Para depurar una respuesta minificada, formatéala en local con jq . o con el visor JSON del navegador en vez de pedir al servidor una versión con formato.

Fuentes y lecturas recomendadas

RFC 8259 define JSON y sus espacios no significativos. RFC 8785 define el JSON Canonicalization Scheme. MDN documenta JSON.stringify y Number.MAX_SAFE_INTEGER. Las notas de la versión 1.7 de jq describen la conservación de números, y la documentación de json en Python y de json_encode en PHP cubre separators y las opciones de escape.

Frequently asked questions

¿Qué hace un minificador de JSON?

Elimina los espacios entre tokens (sangrías, saltos de línea y espacios después de `:` y `,`) sin cambiar los datos. El resultado es una sola línea compacta.

¿Cuánto reduce minificar un JSON?

A menudo un 30–50 % en JSON con sangría antes de comprimir. Con gzip o Brotli la diferencia suele bajar a un 5–15 %, porque la compresión ya elimina bien los espacios repetidos.

¿Debo minificar las respuestas JSON de mi API?

Activa primero la compresión HTTP, que ahorra mucho más. La mayoría de los frameworks ya envían JSON compacto. Minificar importa sobre todo en JSON guardado o enviado sin compresión.

¿Cómo minifico JSON en la línea de comandos?

`jq -c . archivo.json`, o en Python `json.dump(obj, f, separators=(',', ':'))`. En Node.js, `JSON.stringify(obj)` sin argumento de espaciado ya produce JSON minificado.

¿Minificar JSON puede cambiar los datos?

Los minificadores que analizan y reserializan, sí. En JavaScript los enteros mayores de 9007199254740991 pierden precisión, `1.0` pasa a `1` y las claves duplicadas se reducen. Usa un minificador por tokens cuando los valores exactos importan.

¿Puedo minificar JSON con comentarios?

JSON estándar no tiene comentarios. En archivos JSONC o JSON5, elimina primero comentarios y comas finales con una herramienta de ese formato, o el resultado no será JSON válido.