XML vs JSON: Entendiendo los formatos de datos para APIs y archivos de configuración

Toda aplicación que se comunica con el mundo exterior intercambia datos en algún formato estructurado. XML dominó la década de 2000. JSON tomó el relevo en la de 2010. Pero XML no ha desaparecido: impulsa APIs SOAP, feeds RSS, gráficos SVG, layouts de Android e innumerables sistemas empresariales. Conocer ambos formatos te convierte en un desarrollador más versátil.

JSON en un vistazo

JSON (JavaScript Object Notation) es la lengua franca de las APIs web modernas. Se corresponde directamente con los tipos de datos presentes en la mayoría de los lenguajes de programación:

{
  "user": {
    "id": 42,
    "name": "Alice Chen",
    "roles": ["admin", "editor"],
    "active": true,
    "score": 98.6,
    "avatar": null
  }
}

Tipos: string, number, boolean, null, array, object.

JSON es conciso, legible por humanos y se parsea sin dificultad en cualquier lenguaje. Es el formato predeterminado para REST APIs, archivos de configuración y almacenamiento en el navegador.

XML en un vistazo

XML (eXtensible Markup Language) representa los datos como un árbol de elementos etiquetados:

<?xml version="1.0" encoding="UTF-8"?>
<user id="42">
  <name>Alice Chen</name>
  <roles>
    <role>admin</role>
    <role>editor</role>
  </roles>
  <active>true</active>
  <score>98.6</score>
</user>

XML es verboso pero expresivo. Admite atributos (como id="42" arriba), namespaces (para combinar vocabularios), comentarios, instrucciones de procesamiento y esquemas para una validación estricta.

Comparación lado a lado

Característica	JSON	XML
Verbosidad	Compacto	Verboso
Tipos de datos	6 tipos nativos	Todo es texto
Comentarios	❌ No admitido	✅ <!-- -->
Atributos	❌ No existe el concepto	✅ Sí
Namespaces	❌ No existe el concepto	✅ Sí
Esquemas	JSON Schema	XSD, DTD, RelaxNG
Lenguaje de consulta	JSONPath, jq	XPath, XQuery
Transformaciones XSLT	❌	✅
Legibilidad humana	Alta	Media
Complejidad de parseo	Baja	Mayor

Cuándo usar JSON

• REST APIs (uso prácticamente universal)
• localStorage / sessionStorage del navegador
• Archivos de configuración (package.json, tsconfig.json)
• Bases de datos NoSQL orientadas a documentos (MongoDB, Firestore)
• Comunicación entre servicios en microservicios
• Cualquier situación donde se necesite un intercambio de datos rápido y ligero

Cuándo usar XML

• Servicios web SOAP (finanzas, sanidad, administración pública)
• Feeds RSS y Atom
• Gráficos SVG
• Archivos de recursos de Android (layouts, strings, manifests)
• Formatos de documentos de Office (.docx, .xlsx son archivos ZIP que contienen XML)
• Cuando se necesita contenido mixto (texto con marcado en línea)
• Sistemas empresariales que aún no han migrado a JSON

Conversión entre formatos

Convertir XML a JSON raramente es una correspondencia 1:1 — XML tiene conceptos (atributos, nodos de texto, namespaces) que no existen en JSON. Estrategias habituales:

Los atributos se convierten en propiedades

<user id="42" active="true">Alice</user>

Podría convertirse en:

{ "@id": "42", "@active": "true", "#text": "Alice" }

O aplanado:

{ "id": 42, "active": true, "name": "Alice" }

El enfoque adecuado depende de tu caso de uso. Usa nuestro Conversor de XML a JSON para gestionar la conversión con opciones para el tratamiento de atributos.

Validación de JSON con JSON Schema

JSON Schema permite definir la estructura esperada de un documento JSON:

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "required": ["id", "name", "email"],
  "properties": {
    "id": { "type": "integer", "minimum": 1 },
    "name": { "type": "string", "minLength": 1 },
    "email": { "type": "string", "format": "email" },
    "roles": {
      "type": "array",
      "items": { "type": "string" }
    }
  }
}

Valida tus documentos JSON contra esquemas con nuestro Validador de JSON Schema — detecta errores estructurales antes de que lleguen a producción.

JSONPath: consulta de datos anidados

JSONPath es para JSON lo que XPath es para XML. Sintaxis de consulta:

$.store.book[*].author          — todos los autores
$.store.book[0].title           — título del primer libro
$.store.book[?(@.price < 10)]   — libros por menos de $10
$..price                        — todos los valores de precio en cualquier lugar

Equivalentes en XPath para XML:

/store/book/author               — todos los autores
/store/book[1]/title             — título del primer libro
/store/book[@price < 10]         — libros por menos de $10
//price                          — todos los valores de precio en cualquier lugar

Formateo y pretty-printing

Ambos formatos se vuelven ilegibles cuando se minifican. Usa siempre el pretty-print para depuración y revisión humana.

JSON minificado:

{"user":{"id":42,"name":"Alice Chen","roles":["admin","editor"]}}

JSON con formato (sangría de 2 espacios):

{
  "user": {
    "id": 42,
    "name": "Alice Chen",
    "roles": [
      "admin",
      "editor"
    ]
  }
}

Usa nuestro JSON Formatter para aplicar pretty-print, minificar y validar JSON al instante. Para comparar dos bloques de JSON, JSON Diff muestra exactamente qué ha cambiado.

Errores comunes

JSON

• Comas finales — no son válidas en JSON (pero sí en JavaScript)
• Comillas simples — JSON exige comillas dobles para las cadenas
• Números como cadenas — "42" ≠ 42; sé consistente
• Anidamiento profundo — difícil de leer y consultar; aplana donde sea posible

XML

• Caracteres sin escapar — <, >, &, ", ' deben escaparse como entidades
• BOM al inicio — algunos parsers fallan con el BOM de UTF-8
• Confusión con namespaces — es fácil equivocarse en documentos con vocabularios mixtos

Ambos formatos están bien consolidados, cuentan con herramientas maduras y han llegado para quedarse. Saber cuándo usar cada uno y validar tus datos hará que tus integraciones sean mucho más fiables.