Formateador y validador de JSON: encuentra el error y te dice cómo arreglarlo

Pega un JSON y la herramienta comprueba si es válido. Si no lo es, te dice en qué línea y columna está el error, qué significa y cómo arreglarlo: una coma de más al final, comillas simples, claves sin comillas, un True de Python… Si es válido, lo formatea con la sangría que elijas o lo compacta en una sola línea. Todo ocurre en tu navegador: el JSON no se envía a ningún sitio.

No cambia tus números. Muchos formateadores pasan el texto por JSON.parse, que convierte todos los números en coma flotante: un identificador como 12345678901234567890 acaba como 12345678901234567000. Este no: conserva cada número y cada cadena tal como los escribiste, y además avisa de los números que perderán precisión al leerlos en JavaScript y de las claves repetidas.

Los errores más comunes en JSON

JSON es más estricto que JavaScript y que Python. Estos son los fallos que más se repiten, casi siempre por copiar un objeto de uno de esos lenguajes:

Qué admite JSON y qué no

JSON (JavaScript Object Notation) lo define la norma RFC 8259. Solo tiene seis tipos de valor: objetos ({ }, con claves que siempre son cadenas entre comillas dobles), listas ([ ]), cadenas, números, true/false y null. Todo lo demás se representa con esos seis.

• Las fechas no existen como tipo: se escriben como cadenas, casi siempre en ISO 8601 ("2027-01-15T08:00:00Z") o como un número con la fecha Unix.
• Los números se escriben en decimal, sin ceros a la izquierda, sin + delante y sin hexadecimales. La norma no fija un límite de tamaño, pero cada lenguaje los lee a su manera, y ahí empiezan los problemas.
• Las claves repetidas están permitidas, aunque la norma dice que los nombres «deberían» ser únicos. Casi todos los programas se quedan con el último valor sin avisar.
• El texto va en UTF-8. Un carácter especial se puede escribir tal cual ("ñ") o como secuencia de escape ("\u00f1"): el formateador conserva la forma que usaste.

Por qué 12345678901234567890 cambia al leerlo

JavaScript guarda todos los números como coma flotante de 64 bits (double), que solo representa con exactitud los enteros hasta 2⁵³ − 1, es decir, 9007199254740991. Por encima, el número se redondea al más cercano que sí puede guardar:

const texto = '{"id": 12345678901234567890, "nombre": "Ana"}';
const datos = JSON.parse(texto);
console.log(JSON.stringify(datos, null, 2));

$ node numeros.js{
  "id": 12345678901234567000,
  "nombre": "Ana"
}

El identificador ha cambiado sin ningún error. Por eso muchas API envían los identificadores largos como texto, con "id": "12345678901234567890". Python no tiene este problema con los enteros, pero sí cualquier programa que lea el JSON con JavaScript o que guarde los números como double.

Validar y formatear JSON en Python

El módulo json de la biblioteca estándar basta. Si el texto no es válido, la excepción JSONDecodeError dice la línea y la columna, aunque el mensaje está en inglés:

import json

texto = '{"nombre": "Ana", "lenguajes": ["Python", "Go"], "activa": true,}'

try:
    datos = json.loads(texto)
except json.JSONDecodeError as e:
    print(f"Error en la línea {e.lineno}, columna {e.colno}: {e.msg}")
    datos = json.loads(texto.replace(",}", "}"))

print(json.dumps(datos, indent=2, ensure_ascii=False, sort_keys=True))

$ python3 validar.pyError en la línea 1, columna 64: Illegal trailing comma before end of object
{
  "activa": true,
  "lenguajes": [
    "Python",
    "Go"
  ],
  "nombre": "Ana"
}

ensure_ascii=False deja la ñ y los acentos tal cual en lugar de convertirlos en \u00f1, y sort_keys=True ordena las claves, que es útil para comparar dos JSON.

Desde la terminal

Con un archivo datos.json que contiene {"nombre":"Ana","lenguajes":["Python","Go"],"ciudad":"Monterrey"}, Python lo formatea sin instalar nada:

$ python3 -m json.tool datos.json
{
    "nombre": "Ana",
    "lenguajes": [
        "Python",
        "Go"
    ],
    "ciudad": "Monterrey"
}

Y jq, la herramienta de referencia para trabajar con JSON en la terminal, lo formatea, lo compacta o extrae un campo:

$ jq . datos.json
{
  "nombre": "Ana",
  "lenguajes": [
    "Python",
    "Go"
  ],
  "ciudad": "Monterrey"
}
$ jq -c . datos.json
{"nombre":"Ana","lenguajes":["Python","Go"],"ciudad":"Monterrey"}
$ jq -r .lenguajes[0] datos.json
Python

Más herramientas para desarrolladores: el formateador de JSON, el decodificador de JWT y el conversor de fecha Unix. Todas, en decodigo.com/herramientas.

Norma: RFC 8259. El analizador se comprobó con JSONTestSuite: acepta los 95 documentos válidos y rechaza los 188 inválidos, igual que JSON.parse, y formatea 4 000 documentos al azar exactamente igual que json.dumps de Python. Salidas reales con Python 3.13.16 y Node v22.23.3.