Formateador y minificador JSON – ordenar claves

Pega el JSON y se ordena al instante; elige entre cinco formatos viendo su tamaño

El formateador y minificador de JSON despliega un JSON apretado en una sola línea para que se lea bien (formatear, embellecer, «pretty print») o quita los espacios y saltos de línea para dejarlo corto (minificar). El resultado cambia mientras escribes, y las cinco tarjetas de muestra de la parte superior enseñan cómo queda con 2 espacios, 4 espacios, tabulación, ajuste al ancho y una línea, junto con su tamaño, su número de líneas y su tamaño tras gzip. Elige el formato que encaje con el destino del JSON y cópialo o guárdalo como archivo.

La herramienta no toca los valores. Los números como 9007199254740993 o 1.50 se copian tal como están escritos, y si una clave aparece dos veces se conservan las dos. Solo cambian los espacios y los saltos de línea, además del orden de las claves y de la notación de las cadenas cuando tú lo eliges. Además, convierte en caracteres normales el texto que PHP envió como \u00e9\u00f1, repara los archivos de configuración con comentarios y comas finales, y quita las barras invertidas del JSON copiado de un registro con la forma {\"a\":1}.

Cuándo hay que desplegar o reducir un JSON

JSON se creó para que los programas intercambien datos, así que muchas veces llega con una forma difícil de leer. Estas son las situaciones en las que esta herramienta resulta útil.

Revisar la respuesta de una API: la respuesta copiada de las herramientas de desarrollo del navegador o de curl suele venir en una sola línea. Al desplegarla con 2 espacios se ve de inmediato qué valor está dentro de qué objeto.
Ver el texto como \u00e1\u00f3: json_encode de PHP y json.dumps de Python escriben por defecto los caracteres fuera de ASCII como secuencias \u. Si cambias Caracteres a «Decodificar \u», lees los mismos valores como texto real.
Comparar archivos de configuración o resultados esperados de pruebas: si solo cambia el orden de las claves, una herramienta de comparación marca casi todas las líneas como distintas. Formatea los dos archivos con «Alfabético» y solo quedarán los valores que de verdad difieren.
Sacar un JSON de un registro: los registros y las celdas de bases de datos suelen guardar el JSON envuelto otra vez en una cadena, como {\"event\":\"login\"}. Quita las barras invertidas o extrae el JSON de dentro de la cadena y luego formatéalo.
Reducir el tamaño que se envía o se guarda: minificar a una línea reduce los bytes sin duda, pero la diferencia se acorta si el servidor envía la respuesta con gzip. Mira antes el tamaño gzip de las tarjetas de muestra para conocer el efecto real.

Cómo se usa

Pega el JSON en el cuadro de entrada. También puedes pulsar «Abrir archivo» o arrastrar un archivo .json al cuadro; se abren archivos de hasta 5 MB.
Elige el formato del resultado en las tarjetas de muestra. Pulsa una tarjeta o muévete entre ellas con las flechas del teclado cuando una tenga el foco.
Si hace falta, cambia el orden de las claves (Original o Alfabético), los caracteres (Como está, Decodificar \u, A ASCII) y el largo de línea de Ajustar ancho (60, 80, 100 o 120 columnas). Las cifras de las tarjetas cambian con ellos.
Si hay un error de sintaxis, el cuadro de resultado pasa a mostrar el diagnóstico. Indica la línea y la columna donde se detuvo y el fragmento original, y si la notación se puede reparar aparece el botón «Corregir N lugares y formatear».
Con «Copiar resultado» lo llevas al portapapeles y con «Guardar como archivo» lo descargas. El formato de una línea se guarda con la terminación .min.json.

Comparación de los cinco formatos

Los cinco formatos contienen los mismos valores y solo se diferencian en los espacios y saltos de línea. La tabla siguiente muestra el primer ejemplo de la pantalla, «Respuesta API en una línea» (un pedido de 468 bytes), convertido a cada formato. El tamaño se da en bytes UTF-8, y gzip es el tamaño medido con la compresión gzip del navegador.

Formato	Saltos de línea y sangría	Líneas	Tamaño	gzip
2 espacios	Una línea por valor, 2 espacios por nivel	38	686 B	396 B
4 espacios	Una línea por valor, 4 espacios por nivel	38	840 B	406 B
Tabulación	Una línea por valor, 1 tabulación por nivel	38	609 B	391 B
Ajustar ancho	Los objetos y arrays que caben en 80 columnas quedan en una línea; los más largos se despliegan con 2 espacios	23	598 B	390 B
Una línea	Sin espacios ni saltos de línea	1	468 B	348 B

Minificar a una línea ahorra un 32 % de los bytes frente a 2 espacios, pero el tamaño con gzip baja solo un 12 %. Eso ocurre porque gzip ya sustituye las series repetidas de espacios por códigos cortos. Por eso, cuando el servidor web comprime sus respuestas, borrar espacios aporta menos de lo que parece, y los registros o configuraciones que una persona volverá a leer pueden quedarse con formato. En cambio, donde no hay compresión, como un campo de entrada con límite de caracteres, una variable de entorno o una sola celda de base de datos, el formato de una línea es claramente más corto. La tabulación usa un solo byte por nivel, así que es el más pequeño de los formatos con sangría.

Cómo divide las líneas «Ajustar ancho»

«Ajustar ancho» mira primero el valor más externo y se pregunta si cabría en el largo de línea escrito en una sola línea. Si cabe, lo escribe en una línea, como {"x": 1, "y": 2}. Si no, lo despliega y revisa de la misma manera los valores de su interior. El largo de línea incluye la sangría, el nombre de la clave y la coma final. Los caracteres coreanos, chinos, kana y de ancho completo, y los emoji, ocupan dos columnas en una fuente monoespaciada, por lo que cuentan como 2 (los caracteres W y F del ancho de caracteres de Asia oriental de Unicode, UAX #11).

Resulta especialmente útil con datos que tienen muchos arrays cortos. El formato de mapas GeoJSON escribe cada posición como un array numérico [longitud, latitud] (RFC 7946 §3.1.1), así que al desplegar con 2 espacios cada número ocupa su propia línea. El ejemplo «Coordenadas (GeoJSON)» ocupa 53 líneas con 2 espacios, pero con Ajustar ancho cada posición ocupa una línea y el total baja a 25 líneas.

Cómo obtener el mismo formato en otras herramientas

Estas son las opciones que se usan cuando un programa tiene que producir la misma forma. Con datos cuya notación numérica y orden de claves no cambian y cuyas cadenas no llevan secuencias de escape como \u o \/, la correspondencia siguiente da exactamente los mismos caracteres que esta herramienta. JavaScript puede cambiar los números y el orden de las claves al leer los valores, así que consulta también la sección sobre números y claves duplicadas.

Esta herramienta	JavaScript	Python (json)	jq
2 espacios	`JSON.stringify(v, null, 2)`	`json.dumps(v, indent=2, ensure_ascii=False)`	`jq .`
4 espacios	`JSON.stringify(v, null, 4)`	`indent=4`	`jq --indent 4 .`
Tabulación	`JSON.stringify(v, null, "\t")`	`indent="\t"`	`jq --tab .`
Una línea	`JSON.stringify(v)`	`separators=(",", ":")`	`jq -c .`
Alfabético	Sin opción estándar (ordena tú)	`sort_keys=True`	`jq -S .`
A ASCII	Sin opción estándar	`ensure_ascii=True` (valor por defecto)	`jq -a .`
Ajustar ancho	Sin opción estándar	Sin opción estándar	Sin opción

La sangría de JSON.stringify solo crece hasta 10 espacios, y el --indent de jq acepta hasta 7. Cuando indicas indent, Python quita el espacio tras la coma ((",", ": ")), y sin indent usa (", ", ": "). El json_encode de PHP formatea con 4 espacios si pasas JSON_PRETTY_PRINT, y por defecto escribe los caracteres fuera de ASCII como secuencias \u y las barras como \/. Para obtener los caracteres tal cual, pasa juntos JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES.

Caracteres: decodificar o crear secuencias \u

Un carácter dentro de una cadena JSON puede escribirse tal cual o como una barra invertida y una u seguidas de cuatro dígitos hexadecimales (RFC 8259 §7). Las dos notaciones son el mismo valor, de modo que elijas la que elijas, el programa que lo recibe lee lo mismo. El valor por defecto, «Como está», no toca la notación que escribiste, y solo las dos opciones siguientes cambian los caracteres de una cadena.

Entrada (Como está)	Decodificar \u	A ASCII	Nota
`"\u65e5\u672c\u8a9e"`	`"日本語"`	`"\u65e5\u672c\u8a9e"`	Tres caracteres japoneses, una forma habitual en la salida por defecto de PHP y Python
`"\ud83d\ude4f"`	`"🙏"`	`"\ud83d\ude4f"`	Un carácter por encima de U+FFFF se escribe como par sustituto, es decir, dos secuencias (12 caracteres)
`"https:\/\/example.com"`	`"https://example.com"`	`"https:\/\/example.com"`	`\/` es el mismo carácter que `/`. A ASCII deja tal cual la secuencia que ya existe
`"caf\u00e9"`	`"café"`	`"caf\u00e9"`	Las tildes de las letras latinas funcionan igual
`"é😀"`	`"é😀"`	`"\u00e9\ud83d\ude00"`	A ASCII convierte todos los caracteres desde el 127 (DEL) en notación \u en minúsculas
`"año\nmes"`	`"año\nmes"`	`"a\u00f1o\nmes"`	Un salto de línea `\n` no puede ir sin escapar dentro de una cadena, así que sigue como secuencia de escape en ambos casos
`"a\u0009b"`	`"a\u0009b"`	`"a\u0009b"`	Los caracteres de control, como la tabulación, no se decodifican
`"\u200b"`	`"\u200b"`	`"\u200b"`	Los caracteres invisibles, como el espacio de ancho cero, tampoco se decodifican

«Decodificar \u» deja como secuencias de escape los caracteres que no se distinguen en pantalla: los de control, los espacios de ancho cero, los separadores de línea y de párrafo y los espacios especiales que se parecen a un espacio normal (U+00A0 y similares). Si se decodificaran, el resultado no te permitiría saber si ese carácter está ahí. «A ASCII» va en sentido contrario y convierte todos los caracteres fuera de ASCII en notación \u en minúsculas. Coincide con la salida por defecto de json.dumps de Python (ensure_ascii=True) y con la opción -a de jq, y sirve para sistemas antiguos o vías de transferencia que solo dejan pasar ASCII sin problemas.

Si la entrada contiene caracteres escritos como secuencias \u, debajo del resultado aparecen «N caracteres escritos como secuencias \u o \/» y un botón «Pasar a caracteres». El ejemplo «Respuesta PHP (\u)» se muestra desde el principio con «Decodificar \u», así que compara el cuadro de entrada con el de resultado.

Ordenar las claves por nombre

Un objeto JSON es un conjunto sin orden de nombres y valores (RFC 8259 §1). Por eso, cambiar el orden de las claves deja los valores iguales, y fijar un único orden hace que, al comparar dos JSON o al revisar un historial de versiones, solo destaquen las líneas que realmente cambiaron. «Alfabético» ordena las claves de los objetos de todos los niveles con estas reglas.

Se compara por punto de código Unicode. El orden es dígitos, mayúsculas, guion bajo, minúsculas, letras latinas con tilde y después caracteres CJK, por ejemplo 2024, Zip, _id, age, é, 名前. El -S de jq y el sort_keys=True de Python dan el mismo orden.
El orden dentro de los arrays no se cambia, porque un array es una lista en la que el propio orden tiene significado.
Si la misma clave aparece dos veces, se conservan las dos en su orden relativo original.
Las claves se comparan con sus secuencias de escape ya decodificadas. "\u0041" y "A" cuentan como el mismo nombre.

Eso sí, en los archivos de configuración cuyas entradas se ordenaron a mano para que se lean mejor, conviene mantener el orden original. La propia RFC 8259 señala que las bibliotecas JSON difieren en si muestran al programa el orden de los miembros de un objeto, de modo que si algún programa depende del orden, no uses tal cual el resultado ordenado.

Los números y las claves duplicadas se copian tal cual

Leer un JSON como valores de un programa y volver a escribirlo puede cambiar el contenido aunque a simple vista parezca igual. JSON.parse de JavaScript convierte los números en coma flotante de 64 bits (IEEE 754 binary64), por lo que cambian las últimas cifras de un entero largo, las claves con forma de entero pasan al principio y, de una clave que aparece dos veces, solo sobrevive el último valor. Esta herramienta lee los caracteres directamente y solo vuelve a colocar los espacios, así que lo que escribiste permanece, como muestra la tabla siguiente.

Entrada	Esta herramienta (una línea)	Reescrito tras JSON.parse	Qué cambia
`{"id":9007199254740993}`	`{"id":9007199254740993}`	`{"id":9007199254740992}`	La última cifra de un entero superior a 2⁵³
`{"price":1.50}`	`{"price":1.50}`	`{"price":1.5}`	El cero tras el punto decimal
`{"n":1E3}`	`{"n":1E3}`	`{"n":1000}`	La notación exponencial
`{"x":-0}`	`{"x":-0}`	`{"x":0}`	El signo del cero negativo
`{"b":1,"2024":2}`	`{"b":1,"2024":2}`	`{"2024":2,"b":1}`	La clave con forma de entero pasa al principio
`{"a":1,"a":2}`	`{"a":1,"a":2}`	`{"a":2}`	Desaparece el primer valor de la clave duplicada

Que el programa que recibe el resultado tenga el mismo problema es otra cuestión. La RFC 8259 indica que los números dentro de la precisión y el rango de binary64 son los que las partes leen como el mismo valor (§6), y que, ante un objeto con nombres repetidos, el software receptor se comporta de forma distinta: unos usan solo el último valor, otros dan error y otros informan de todos (§4). Envía los identificadores largos como cadenas y unifica las claves duplicadas antes de enviar. Los avisos que aparecen debajo del resultado señalan esos valores, y si pulsas uno se selecciona ese punto en el cuadro de entrada.

Cuando no se puede formatear: errores frecuentes y correcciones automáticas

Cuando el cuadro de resultado pasa a mostrar el diagnóstico, indica la línea y la columna donde se detuvo la comprobación y un fragmento del original. El error real suele estar justo antes del punto marcado. Las notaciones siguientes se pueden convertir a sintaxis JSON de una vez con «Corregir y formatear» o «Quitar barras y formatear»; la disposición de las líneas no cambia y solo se modifican los lugares marcados.

Entrada	Cuál es el problema	Resultado corregido
`{"a": 1,}`	Coma tras el último elemento	`{"a": 1}`
`{"a": 1 /* nota */}`	Comentario (solo existe en JSONC y JSON5)	`{"a": 1 }`
`{'nombre': 'Lucía'}`	Cadena con comillas simples	`{"nombre": "Lucía"}`
`{nombre: "Lucía"}`	Clave sin comillas	`{"nombre": "Lucía"}`
`{"ok": True, "memo": None}`	Notación de Python	`{"ok": true, "memo": null}`
`[1, NaN, 3]`	Un valor numérico que JSON no tiene	`[1, null, 3]`
`{\"a\":1}`	Una barra invertida antes de cada comilla	`{"a":1}`

Hay casos que no se corrigen automáticamente. Si una respuesta se cortó y los paréntesis no están cerrados, no hay forma de saber hasta dónde llegaban los datos originales, así que el diagnóstico solo indica qué caracteres de cierre habría que añadir al final. Un número con ceros a la izquierda, como 007, no se toca, porque una persona debe decidir si es un número o un texto. En esos casos, usa «Ver en la entrada» para seleccionar el punto y corregirlo a mano, o recurre al validador de JSON, que muestra con más detalle la posición y la causa del error. Algunas correcciones cambian el valor, como convertir NaN en null, así que revisa el resultado una vez.

Errores frecuentes

Sobrescribir el archivo de configuración original con el resultado corregido: la corrección automática elimina los comentarios. Guarda aparte el original de un archivo JSONC y usa el resultado formateado solo donde se exija JSON simple.
Ordenar solo uno de los dos archivos antes de compararlos: la diferencia de orden hace que casi todas las líneas parezcan cambiadas. Formatea los dos archivos con las mismas opciones.
Enviar el resultado de «Decodificar \u» a un lugar que solo acepta ASCII: el texto decodificado sale en bytes UTF-8. Si el receptor no maneja UTF-8, elige «A ASCII».
Volver a leer el resultado con JSON.parse y fiarse de los números: esta herramienta conserva 9007199254740993, pero al leerlo de nuevo en JavaScript se obtiene 9007199254740992.
Intentar reducir el tráfico solo con la minificación a una línea: con respuestas gzip la diferencia es pequeña. Quitar los campos que no se usan ahorra más.
Pegar JSONL (un JSON por línea) como si fuera un único documento: da un error que indica que hay más caracteres después del primer valor. Conviértelo en un array con un conversor de array JSON a JSONL y luego formatéalo.

Límites y precauciones

El resultado es siempre JSON estándar (RFC 8259). Los comentarios y las comas finales de JSONC o JSON5 se pueden eliminar con la corrección automática y después formatear, pero la herramienta nunca formatea conservando los comentarios.
Procesa hasta 5 MB y 500 niveles de anidamiento. Si el resultado supera los 300 000 caracteres, se omite el coloreado de sintaxis para ir más rápido y solo se muestra texto plano.
Los anchos de carácter que usa Ajustar ancho son valores aproximados, contados para una fuente monoespaciada. Los caracteres combinados y algunos símbolos pueden tener un ancho real distinto según la fuente.
Solo comprueba la sintaxis. No verifica reglas de datos como claves obligatorias, tipos de valor o rangos (JSON Schema).
El tamaño gzip se mide con la compresión gzip por defecto de este navegador, así que cambia si se usa la etapa de compresión del servidor u otro método (como br).
La entrada no se guarda. Al recargar la página vuelve el primer ejemplo.

Fecha de referencia Las RFC 8259, RFC 7946 y RFC 9110, la documentación de PHP, Python, jq y MDN, y UAX #11 (Unicode 18.0.0) se contrastaron con los textos originales el 2026-10-22. La tabla de tamaños y la salida de PHP, jq y Python se generaron y compararon ese mismo día con Chromium, PHP 8.5.12, jq 1.7.1 y Python 3.14.

Fuentes

01IETF RFC 8259: The JavaScript Object Notation (JSON) Data Interchange Format§1 los objetos no tienen orden, §2 cuatro caracteres de espacio en blanco, §4 los nombres deberían ser únicos y las implementaciones tratan los duplicados de forma distinta, §6 binary64, §7 secuencias de escape y pares sustitutos, §8.1 UTF-8 y BOM
02Manual de PHP: constantes de JSONJSON_PRETTY_PRINT, JSON_UNESCAPED_SLASHES, JSON_UNESCAPED_UNICODE (por defecto se escapa como \uXXXX)
03Documentación de Python: módulo jsonensure_ascii es True por defecto, indent, separators por defecto, sort_keys
04MDN: JSON.stringify()El argumento space llega hasta 10
05Manual de jq--indent n (hasta 7), --tab, --sort-keys (-S), --compact-output (-c), --ascii-output (-a), claves ordenadas por punto de código Unicode
06Unicode UAX #11: East Asian WidthUnicode 18.0.0, caracteres anchos (W) y de ancho completo (F)
07IETF RFC 7946: The GeoJSON Format§3.1.1 una posición es un array numérico en el orden longitud, latitud
08IETF RFC 9110: HTTP Semantics§8.4 Content-Encoding, §8.4.1.3 gzip
09MDN: CompressionStreamAPI estándar para comprimir con gzip dentro del navegador, compatible con los principales navegadores desde mayo de 2023

Preguntas frecuentes

¿Qué diferencia hay entre formatear y minificar un JSON?

Formatear (embellecer, «pretty print») pone cada valor en su propia línea y añade sangría para que lo lea una persona, mientras que minificar elimina todos los espacios y saltos de línea fuera de las cadenas para dejar una sola línea corta. Los dos resultados contienen los mismos valores, y los espacios dentro de una cadena son datos, así que se conservan en ambos casos.

¿En qué se diferencia «Ajustar ancho» del formato con 2 espacios?

El formato con 2 espacios despliega cada valor en su propia línea, así que incluso un array corto como [1, 2, 3] ocupa cinco líneas. «Ajustar ancho» deja un objeto o array en una línea si cabe en el largo de línea elegido (80 columnas por defecto) y lo despliega solo cuando no cabe. En datos con muchos arrays cortos, como una lista de coordenadas, el número de líneas baja a la mitad o menos.

Mi texto aparece como secuencias \u. ¿Se puede cambiar?

Sí. Si pones Caracteres en «Decodificar \u», las secuencias \u y \/ se escriben como caracteres. json_encode de PHP y json.dumps de Python escriben así por defecto el texto fuera de ASCII. Las dos notaciones son el mismo valor, por lo que decodificar no cambia los datos. Los caracteres que no se ven, como los de control o los espacios de ancho cero, siguen escapados para que se puedan distinguir.

¿Cambia los datos ordenar las claves por nombre?

Un objeto JSON es un conjunto sin orden de nombres y valores, así que los valores no cambian. Ordenar coloca las claves de los objetos de todos los niveles por punto de código Unicode (dígitos, mayúsculas, minúsculas, luego letras con tilde y caracteres CJK) y mantiene el orden dentro de los arrays y el orden relativo de las claves con el mismo nombre. Si formateas dos JSON con las mismas opciones, solo destacan los valores que de verdad difieren.

¿Se conservan tal cual los números grandes y los ceros tras el punto decimal?

Sí. La herramienta no calcula con los números, sino que copia los caracteres que escribiste, así que 9007199254740993, 1.50 y 1E3 se quedan como están. Eso sí, si vuelves a leer el resultado con JSON.parse de JavaScript, puede convertirse en algo como 9007199254740992, por lo que es más seguro intercambiar los identificadores largos como cadenas.

¿Se puede formatear un JSON con comentarios o comas finales?

El JSON normal no tiene comentarios ni comas finales, así que tal cual da error. Cuando el diagnóstico del cuadro de resultado ofrece una notación reparable, pulsa «Corregir N lugares y formatear» para quitar los comentarios y convertir las comas finales, las comillas simples, las claves sin comillas, True, None y NaN en sintaxis JSON antes de formatear. Puedes deshacerlo con Ctrl+Z (⌘Z) en el cuadro de entrada.

¿Cómo formateo un JSON como {\"a\":1} copiado de un registro?

Un JSON con una barra invertida antes de cada comilla es la huella de haber estado envuelto otra vez en una cadena. Al pegarlo, el diagnóstico ofrece «Quitar barras y formatear», y si el valor más externo es una cadena entre comillas dobles ofrece «Extraer y formatear». En cualquier caso, con un clic se saca el JSON interior y se formatea.

¿Se envía a un servidor el JSON que escribo?

No. El formateo, la minificación, la comprobación de errores y la medición del tamaño gzip se ejecutan dentro de este navegador, y lo que escribes ni se envía a un servidor ni se guarda. Al recargar la página, la entrada desaparece y vuelve el primer ejemplo.