Como validar JSON online: guia para desarrolladores con ejemplos practicos

JSON (JavaScript Object Notation) es el formato de intercambio de datos mas utilizado en el desarrollo web moderno. Practicamente todas las APIs REST devuelven datos en JSON, las configuraciones de herramientas como package.json o tsconfig.json usan este formato, y bases de datos como MongoDB almacenan documentos en formato JSON.

El problema es que un solo caracter fuera de lugar (una coma extra, una comilla faltante, un corchete sin cerrar) hace que todo el JSON sea invalido y cause errores en tu aplicacion. Un JSON invalido en una respuesta de API puede romper tu frontend. Un tsconfig.json con un error de sintaxis impide que TypeScript compile.

Validar JSON antes de usarlo evita horas de depuracion. Con el validador JSON de NexTools, puedes pegar cualquier JSON, ver errores con la linea exacta donde ocurren, y obtener el formato embellecido automaticamente.

JSON tiene reglas estrictas de sintaxis. Romper cualquiera de ellas produce un JSON invalido:

• Las claves deben estar entre comillas dobles: {"nombre": "Ana"} es valido. {nombre: "Ana"} NO lo es.
• Los strings usan comillas dobles, nunca simples: "valor" es valido. 'valor' NO lo es.
• No se permiten comas finales (trailing commas): {"a": 1, "b": 2} es valido. {"a": 1, "b": 2,} NO lo es.
• No se permiten comentarios: No puedes usar // ni /* */ dentro de JSON. Para configuraciones que necesiten comentarios, usa JSONC o JSON5.
• Los numeros no llevan comillas: {"edad": 25} es valido. {"edad": "25"} funciona pero el valor es un string, no un numero.

Tipos de datos permitidos en JSON:

Tipo	Ejemplo	Notas
String	"hola mundo"	Siempre comillas dobles
Number	42, 3.14, -7	Enteros o decimales, sin comillas
Boolean	true, false	Minusculas, sin comillas
Null	null	Minusculas, sin comillas
Array	[1, 2, 3]	Valores separados por comas
Object	{"clave": "valor"}	Pares clave-valor

Estos son los errores que encuentras con mas frecuencia al trabajar con JSON:

1. Coma al final del ultimo elemento:
   {"items": [1, 2, 3,]} — La coma despues del 3 es invalida.
2. Comillas simples en vez de dobles:
   {'nombre': 'Juan'} — Debe ser {"nombre": "Juan"}.
3. Claves sin comillas:
   {edad: 30} — Debe ser {"edad": 30}.
4. Caracteres de control sin escapar:
   Tabs y saltos de linea literales dentro de strings deben escribirse como y .
5. Comillas sin escapar dentro de strings:
   {"texto": "dijo "hola""} — Debe ser {"texto": "dijo "hola""}.
6. Comentarios:
   JSON no soporta comentarios de ningun tipo.
7. NaN, Infinity o undefined:
   Estos valores de JavaScript NO son validos en JSON. Usa null en su lugar.
8. Valores hexadecimales:
   {"color": 0xFF0000} no es valido. Usa {"color": "#FF0000"} o {"color": 16711680}.
9. Mezclar tipos en un array esperando un tipo:
   [1, "dos", true] es JSON valido, pero muchas APIs esperan arrays homogeneos.
10. BOM (Byte Order Mark):
    Algunos editores agregan bytes invisibles al inicio del archivo que invalidan el JSON. Guarda siempre como UTF-8 sin BOM.

Todos estos errores son detectados automaticamente por el validador JSON, que te muestra la linea y posicion exacta del error.

JSON se puede presentar de dos formas: embellecido (pretty-print) para lectura humana, y minificado para transmision eficiente.

JSON embellecido:

{
  "usuario": {
    "nombre": "Maria",
    "edad": 28,
    "activo": true
  }
}

JSON minificado (mismos datos, menos bytes):

{"usuario":{"nombre":"Maria","edad":28,"activo":true}}

La version minificada ocupa menos espacio (ideal para APIs y almacenamiento), mientras la embellecida es mucho mas facil de leer y depurar. En el ejemplo anterior, el JSON minificado es 52 bytes vs 87 bytes del embellecido — un ahorro del 40%.

En JavaScript, puedes formatear JSON con:

JSON.stringify(data, null, 2)  // embellecido con 2 espacios
JSON.stringify(data)           // minificado

Para minificar archivos JSON grandes, usa el minificador de codigo que maneja JSON, CSS y JavaScript.

Antes de JSON, XML era el formato dominante para intercambio de datos. Ambos siguen en uso, pero para propositos distintos:

Caracteristica	JSON	XML
Legibilidad	Mas conciso	Mas verboso
Tamano	30-50% mas pequeno	Mas grande
Tipos de datos	String, number, boolean, null, array, object	Todo es texto
Comentarios	No soportados	Soportados
Esquemas	JSON Schema	XSD, DTD
Uso principal	APIs REST, configuracion	SOAP, documentos, RSS
Parseo	JSON.parse() nativo	Requiere parser XML

En 2026, JSON domina en desarrollo web, APIs y aplicaciones moviles. XML se mantiene en sistemas empresariales legacy, feeds RSS/Atom, y formatos de documentos como DOCX (que internamente es XML comprimido).

Ademas de validar JSON, estas herramientas complementarias te facilitan el trabajo:

• Validador JSON: Verifica sintaxis, muestra errores con numero de linea, y embellece automaticamente.
• Minificador de codigo: Comprime JSON eliminando espacios y saltos de linea para reducir tamano.
• Codificador Base64: Codifica JSON a Base64 para transmitirlo en URLs o headers HTTP.
• Comparador de texto: Compara dos versiones de un JSON para encontrar diferencias.

En el navegador:

• JSON.parse(jsonString) — Convierte un string JSON a un objeto JavaScript. Lanza error si el JSON es invalido.
• JSON.stringify(obj, null, 2) — Convierte un objeto a JSON formateado.
• console.dir(JSON.parse(json)) — Muestra la estructura del JSON de forma interactiva en la consola.

Validar la sintaxis solo verifica que el JSON este bien formado. Pero en aplicaciones reales, tambien necesitas verificar que los datos tengan la estructura correcta (que los campos requeridos existan, que los tipos sean correctos, que los valores esten dentro de rangos esperados).

Para esto existe JSON Schema, un estandar para describir la estructura de documentos JSON:

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "type": "object",
  "required": ["nombre", "edad", "email"],
  "properties": {
    "nombre": { "type": "string", "minLength": 1 },
    "edad": { "type": "integer", "minimum": 0, "maximum": 150 },
    "email": { "type": "string", "format": "email" }
  }
}

Con este schema, puedes validar automaticamente que cualquier JSON de usuario tenga nombre (string no vacio), edad (entero entre 0 y 150) y email (formato valido). Bibliotecas como Ajv (JavaScript), jsonschema (Python) y Newtonsoft (.NET) implementan validacion con JSON Schema.

En desarrollo profesional, definir JSON Schemas para tus APIs es una de las mejores practicas para prevenir errores y documentar tu API automaticamente.

Estas practicas te ayudaran a evitar problemas comunes en proyectos reales:

• Siempre valida JSON de fuentes externas: Cualquier JSON que recibas de una API, un archivo subido por un usuario, o un webhook debe pasar por JSON.parse() dentro de un try-catch antes de procesarlo.
• Usa camelCase para claves: Es la convencion estandar en JavaScript/TypeScript. userName en vez de user_name o UserName.
• Evita anidar mas de 3-4 niveles: JSON profundamente anidado es dificil de leer, recorrer y mantener. Aplana la estructura cuando sea posible.
• No guardes datos sensibles en JSON sin cifrar: Tokens, contrasenas y claves privadas nunca deben ir en JSON plano en logs o respuestas de API.
• Usa null en vez de omitir campos opcionales: Es mejor {"middle_name": null} que omitir el campo, porque el consumidor de la API sabe explicitamente que el campo existe pero no tiene valor.
• Maneja errores de parseo con gracia: No muestres el error completo de JSON.parse al usuario final. Registralo en logs y muestra un mensaje amigable.