Herramienta / Texto y Dev

Formateador de JSON

Usa el Formateador de JSON de Kitly para ordenar respuestas de API, archivos de configuración, logs y datos estructurados localmente en el navegador. Un formateo correcto significa sintaxis JSON válida, no que un schema haya pasado.

Salida
El JSON formateado aparecerá aquí.
Guía publicada por Kitly

Cómo formatear y validar JSON

Usa el formato para inspeccionar la estructura y minifica solo después de que los datos se analicen correctamente.

  1. Pega el JSON

    Inserta el objeto, array, respuesta de API o configuración. Evita pegar secretos que no necesites inspeccionar.

  2. Formatea o minifica

    Formatea para añadir indentación y resaltado, o minifica cuando necesites JSON válido y compacto.

  3. Resuelve errores y exporta

    Si el análisis falla, usa la posición indicada como punto de partida. Tras validar, copia o descarga el resultado.

Problemas comunes de JSON

  • JSON exige comillas dobles en nombres de propiedades y strings; las comillas simples no son JSON válido.
  • Las comas después de la última propiedad o elemento de un array hacen fallar el análisis estricto.
  • Los comentarios, undefined, NaN y las funciones JavaScript no forman parte del formato JSON.

Alcance de la validación

  • Un análisis correcto confirma la sintaxis, no que los datos cumplan un contrato de API o JSON Schema.
  • La herramienta no repara automáticamente entradas inválidas porque los cambios silenciosos pueden alterar el significado.
  • Los payloads muy grandes pueden consumir mucha memoria y funcionar mejor con herramientas de línea de comandos o streaming.

Guía práctica

Estos ejemplos muestran un documento anidado después de formatear y minificar, un error de sintaxis con el detalle observado del analizador y enteros en el límite del rango seguro de JavaScript. El último ejemplo es JSON válido que aun así fallaría en un esquema.

El formateo necesita JavaScript porque el navegador analiza y reescribe el texto localmente. Los ejemplos medidos, las decisiones y el diagnóstico de abajo siguen siendo legibles sin JavaScript.

Muestras JSON medidas

Los resultados se produjeron con el formateador de esta página en Node.js 22.19.0: JSON.parse, después la comprobación de enteros y luego JSON.stringify. Las muestras son originales y no contienen secretos.

JSON anidado, formateado y minificado

Un objeto anidado compacto crece al formatearlo con dos espacios y vuelve al mismo texto compacto al minificarlo.

Entrada, 111 B

{"kit":"sample","ready":true,"count":2,"note":null,"tags":["pdf","json"],"nested":{"locale":"en","weight":1.5}}
Ajustes
Formatear JSON.stringify con 2 espacios
Minificar JSON.stringify sin espacio extra

Resultados observados

Formatear, 164 B
{
  "kit": "sample",
  "ready": true,
  "count": 2,
  "note": null,
  "tags": [
    "pdf",
    "json"
  ],
  "nested": {
    "locale": "en",
    "weight": 1.5
  }
}

Minificar, 111 B
{"kit":"sample","ready":true,"count":2,"note":null,"tags":["pdf","json"],"nested":{"locale":"en","weight":1.5}}

Qué revisar

Formatear cambió 111 B a 164 B. Minificar ese texto formateado devolvió 111 B, idéntico a la entrada. Las claves, true, null y 1.5 se mantuvieron. El estado “JSON válido” aquí significa que el texto se analizó. No significa que se haya comprobado un esquema.

Advertencias

  • Minificar coincidió con la entrada porque ya estaba compacta. No reduce todos los documentos.
  • Los archivos formateado y minificado son las cadenas exactas, sin salto extra al final.

Archivos del ejemplo

Los enteros fuera del rango seguro se rechazan

Un entero sin comillas por encima de 9007199254740991 se rechaza para que el formateador no escriba otro número.

Entrada rechazada, 47 B

{"reference":9007199254740993,"label":"unsafe"}
Ajustes
Límite seguro, inclusive ±9007199254740991
Token rechazado 9007199254740993

Resultado de la herramienta

Este JSON contiene un número entero fuera del rango seguro de JavaScript. Para evitar que cambien sus dígitos, guarda ese valor como texto entre comillas antes de formatear.

Qué revisar

La salida formateada quedó vacía. JSON.parse por sí solo convirtió 9007199254740993 en 9007199254740992. Después, el formateador encuentra ese token original y no escribe el número cambiado. El mismo rechazo ocurrió con 9007199254740992 y con -9007199254740993. El entero 9007199254740991 se formateó sin cambios, en un documento de 35 B.

Advertencias

  • Poner los dígitos entre comillas funciona. quoted-large-integer.json se formatea a un documento de 58 B y conserva 9007199254740993 como string.
  • Un token decimal omite la comprobación de enteros. decimal-large-number.json usa 9007199254740993.0 y el formateador escribe 9007199254740992. Pon el valor entre comillas, o déjalo como entero dentro del límite seguro, cuando cada dígito importa.

Archivos del ejemplo

Una coma final es JSON no válido

El formateador muestra el detalle del analizador y no inventa una corrección.

Entrada, 24 B

{
  "label": "sample",
}

Resultado de la herramienta

Este JSON no es válido. Expected double-quoted property name in JSON at position 23 (line 3 column 1)

Qué revisar

La salida quedó vacía. La frase después del punto es el detalle del analizador V8 observado en Node.js 22.19.0. Otro motor de navegador puede redactar ese detalle de otra forma. La posición 23 es la llave de cierre en la línea 3, después de la coma final.

Advertencias

  • La herramienta no quita la coma por ti. Una corrección silenciosa podría cambiar otro documento.

Archivos del ejemplo

Una sintaxis válida puede tener la forma incorrecta

Un objeto cuyo valor de pages es la string “two” se formatea correctamente.

Entrada, 29 B

{"status":"ok","pages":"two"}

JSON formateado, 38 B

{
  "status": "ok",
  "pages": "two"
}

Qué revisar

El formateador aceptó este texto. Un esquema que exigiera pages como número rechazaría la string “two”. Esta página comprueba solo la sintaxis JSON. Los nombres de campos, los tipos y los contratos de API necesitan una comprobación de esquema aparte.

Advertencias

  • El estado “JSON válido” describe el análisis. No es una aprobación de la forma de los datos.

Archivos del ejemplo

Formatear, minificar, usar comillas o validar un esquema

Formatear y minificar exigen que el texto se analice. Ninguno de los dos comprueba un esquema.

Formatear

Úsalo cuando: Necesitas leer la estructura anidada, como en la muestra de 111 B.

Compromisos: La muestra pasó de 111 B a 164 B. Los valores no cambiaron.

Minificar

Úsalo cuando: Necesitas JSON compacto después de que el texto se haya analizado.

Compromisos: La muestra que ya estaba compacta siguió en 111 B. Minificar quita el espacio extra; no acorta los datos en sí.

Entero grande entre comillas

Úsalo cuando: Los dígitos son un identificador fuera de ±9007199254740991 y deben permanecer intactos.

Compromisos: El valor se convierte en una string JSON, como en la muestra citada de 58 B. Un consumidor que espera un número recibirá una string.

Validación de esquema

Úsalo cuando: Necesitas saber si los nombres y tipos de campos coinciden con un contrato.

Compromisos: Este formateador sigue aceptando syntax-not-schema.json. Usa un comprobador de JSON Schema para esa pregunta.

Cuando el formateo se detiene

Problema: Pega un JSON primero.

Causa probable: La entrada está vacía o solo tiene espacios.

Qué hacer: Pega un valor JSON y luego elige Formatear o Minificar.

Problema: Este JSON no es válido. Expected double-quoted property name in JSON at position 23 (line 3 column 1)

Causa probable: invalid-trailing-comma.json tiene una coma después de la última propiedad.

Qué hacer: Quita la coma final y formatea de nuevo. La herramienta deja la salida vacía y no reescribe la entrada.

Problema: Este JSON contiene un número entero fuera del rango seguro de JavaScript. Para evitar que cambien sus dígitos, guarda ese valor como texto entre comillas antes de formatear.

Causa probable: Un entero sin comillas está fuera de ±9007199254740991. Las muestras son 9007199254740993, 9007199254740992 y -9007199254740993.

Qué hacer: Pon los dígitos entre comillas si deben permanecer exactos. Una forma decimal como 9007199254740993.0 sí se formatea, y la muestra cambia a 9007199254740992.

Problema: Los datos se analizaron, pero un campo tiene el tipo incorrecto.

Causa probable: syntax-not-schema.json es JSON válido y pages es la string “two”.

Qué hacer: Comprueba el contrato o el JSON Schema por separado. Un formateo correcto no confirma esa forma.

Fuentes relevantes

Separan la sintaxis JSON, el rango de enteros de JavaScript y JSON Schema.

  • RFC 8259 La sintaxis de intercambio JSON que analiza este formateador.
  • Number.MAX_SAFE_INTEGER El límite inclusivo de JavaScript, 9007199254740991, usado por la comprobación de enteros.
  • JSON Schema Una especificación aparte para comprobar la forma de datos que ya son JSON válido.

Preguntas frecuentes

¿El formateador de JSON sube mis datos?

No. El formato, la minificación, la comprobación de sintaxis, la copia y la descarga se generan en tu navegador.

¿Esta herramienta corrige JSON inválido automáticamente?

No. Comprueba la sintaxis JSON y muestra errores del parser para que puedas corregir el origen sin adivinar qué cambió. No reescribe JSON inválido y no valida un schema.

¿Cuál es la diferencia entre formatear y minificar?

Formatear agrega indentación legible y tokens resaltados para revisar, mientras que minificar elimina espacios extra para snippets y payloads compactos.

¿Por qué se rechazó 9007199254740993?

Como entero sin comillas está fuera del rango seguro de JavaScript. JSON.parse lo convertiría en 9007199254740992, así que el formateador lo rechaza y deja la salida vacía. Guárdalo como texto entre comillas cuando cada dígito deba permanecer igual.

¿Un formateo correcto significa que mi esquema pasó?

No. Formatear y minificar confirman la sintaxis JSON. La muestra con pages definido como la string “two” se formatea bien y aun así fallaría en un esquema que exige un número.