Conversor XML a JSON

Pega XML, obtén JSON al instante. Convierte atributos a claves @_, gestiona elementos repetidos como arrays. 100% en el navegador, nada se sube, sin registro.

Sin rastreo Se ejecuta en el navegador Gratis

Opciones · 2 espacios · XML → JSON

Sangría

XML Entrada

0 caracteres

JSON Salida

0 líneas

Revisado para el manejo de conformidad XML 1.0, corrección de la convención @_/#text y precisión en la preservación de cadenas — Go Tools Engineering Team · May 29, 2026

¿Qué es la conversión de XML a JSON y cómo funciona?

XML (Extensible Markup Language) y JSON (JavaScript Object Notation) son ambos formatos de datos estructurados, pero tienen modelos fundamentalmente diferentes: XML es un árbol de elementos con atributos y contenido mixto (texto entrelazado con elementos hijos); JSON es un árbol de objetos, arrays, cadenas, números, booleanos y valores nulos. Convertir entre ellos requiere un conjunto de convenciones para tender un puente sobre esta incompatibilidad.

Esta herramienta usa la convención más ampliamente adoptada, la misma que usan librerías populares como fast-xml-parser (Node.js), xmltodict (Python) y JAXB (Java):

**1. Atributos → prefijo @_.** Los atributos XML no tienen equivalente directo en JSON. La convención es representarlos como claves con el prefijo @_. Así se convierte en { "@_id": "42", "@_role": "admin" } dentro del objeto user. Este prefijo es inequívoco: ningún nombre de elemento XML válido comienza con @, por lo que no hay colisión con los nombres de elementos hijos.

**2. Contenido de texto del elemento con atributos → #text.** Cuando un elemento tiene tanto atributos como contenido de texto — 29.99 — el texto debe compartir el mismo objeto JSON que los atributos. La convención es almacenarlo bajo la clave #text, produciendo { "@_currency": "USD", "#text": "29.99" }. Los elementos con solo contenido de texto y sin atributos se convierten en un valor de cadena simple.

**3. Elementos hermanos repetidos → arrays.** XML permite múltiples elementos hijos con el mismo nombre; los objetos JSON no pueden tener claves duplicadas. La solución es recopilar los hermanos con el mismo nombre en un array. Un hijo se convierte en un único objeto; dos o más hijos se convierten en un array de objetos. Este es el detalle de comportamiento más importante que hay que entender: la forma del JSON cambia según cuántos hermanos existan en el XML.

**4. Sin coerción de tipos — todos los valores permanecen como cadenas.** XML no tiene un sistema de tipos nativo para el contenido de texto. Un valor de "123" en XML es una cadena. Convertirlo al número JSON 123 requiere hacer una suposición sobre la intención del autor — una suposición errónea para los códigos postales ("01234" → 1234), los números de teléfono, los identificadores con relleno y las cadenas decimales sensibles a la precisión. Esta herramienta preserva todos los valores como cadenas. Aplica la coerción de tipos en tu propio código para los campos donde conoces el tipo.

**5. Con pérdida para comentarios, instrucciones de procesamiento y espacios de nombres.** XML admite características que JSON no tiene: comentarios (), instrucciones de procesamiento (), y semánticas de espacios de nombres. Estos se descartan o se aproximan durante la conversión. Para el trabajo XML sin pérdida — reformatear, minificar, validar — usa el Formateador XML. Para la conversión inversa — construir XML desde JSON — usa el Conversor JSON a XML.

**¿Por qué convertir XML a JSON?** JSON es el formato nativo de JavaScript y el formato de intercambio predeterminado para las APIs REST. Si recibes XML de un servicio SOAP heredado, un feed RSS, un sitemap o un sistema empresarial, convertirlo a JSON te permite trabajar con los datos usando acceso estándar a objetos JavaScript, consultas de ruta JSON y cualquier base de datos o API que reconozca JSON. La conversión es un puente de una sola dirección: útil para consumir datos XML en una pila moderna, pero no para preservar o hacer ida y vuelta con documentos XML.

// Convert XML to JSON in Node.js using fast-xml-parser
import { XMLParser } from 'fast-xml-parser';

const xml = `<catalog>
  <product id="P01">
    <name>Wireless Headphones</name>
    <price currency="USD">79.99</price>
  </product>
</catalog>`;

const parser = new XMLParser({
  ignoreAttributes: false,      // preserve attributes
  attributeNamePrefix: '@_',    // @_ prefix for attributes
  textNodeName: '#text',        // #text for mixed element content
  parseAttributeValue: false,   // no type coercion on attributes
  parseTagValue: false,         // no type coercion on element text
});

const result = parser.parse(xml);
console.log(JSON.stringify(result, null, 2));
// {
//   "catalog": {
//     "product": {
//       "@_id": "P01",
//       "name": "Wireless Headphones",
//       "price": {
//         "@_currency": "USD",
//         "#text": "79.99"
//       }
//     }
//   }
// }

Características principales

Conversión en vivo

La salida JSON se actualiza al instante mientras escribes o pegas XML — no se necesita botón Convertir. Las entradas grandes (>200 KB) cambian automáticamente al modo manual para mantener el navegador con capacidad de respuesta.

Convención de prefijo @_ para atributos

Los atributos XML se convierten en claves JSON con prefijo @_, siguiendo la convención de fast-xml-parser y xmltodict. se convierte en { "@_attr": "val" } — inequívoco y sin colisión con cualquier nombre de elemento válido.

Detección automática de arrays para elementos repetidos

Los elementos hermanos con el mismo nombre se convierten automáticamente en un array JSON. Un → objeto; dos o más elementos → array. No se necesita configuración — la herramienta detecta las repeticiones automáticamente.

Sin coerción de tipos — los valores permanecen como cadenas

Todos los valores XML se preservan como cadenas JSON. Los ceros iniciales, los números de teléfono, los códigos con relleno y las cadenas que parecen booleanos como "true" o "false" nunca se convierten silenciosamente en números o booleanos.

Privacidad 100% en el navegador

Toda la conversión se ejecuta localmente en tu navegador usando JavaScript. Tu XML — incluidas credenciales, configuraciones internas y cargas sensibles — nunca se envía a ningún servidor, nunca se registra y nunca se almacena.

Informe de errores de conformidad

Si tu XML no está bien formado, la herramienta informa el número exacto de línea y columna del primer error, para que puedas localizar y corregir el problema inmediatamente antes de convertir.

Ejemplos

Archivo de configuración

<?xml version="1.0" encoding="UTF-8"?>
<appConfig version="2.1" env="production">
  <database>
    <host>db.example.com</host>
    <port>5432</port>
    <name>myapp_prod</name>
    <pool max="10" min="2"/>
  </database>
  <cache enabled="true">
    <ttl>3600</ttl>
    <driver>redis</driver>
  </cache>
</appConfig>

Una pequeña configuración de aplicación con atributos y elementos anidados. Los atributos se convierten en claves con prefijo @_ en la salida JSON: version="2.1" se convierte en "@_version": "2.1" bajo appConfig, y los atributos max y min del elemento pool se convierten en "@_max": "10" y "@_min": "2". Todos los valores — incluyendo port y ttl — permanecen como cadenas, no como números, porque el conversor no realiza ninguna coerción de tipos.

Fragmento de Sitemap

<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
  <url>
    <loc>https://go-tools.org/tools/xml-to-json</loc>
    <lastmod>2026-05-29</lastmod>
    <changefreq>weekly</changefreq>
    <priority>0.8</priority>
  </url>
  <url>
    <loc>https://go-tools.org/tools/json-to-xml</loc>
    <lastmod>2026-05-29</lastmod>
    <changefreq>weekly</changefreq>
    <priority>0.8</priority>
  </url>
</urlset>

Un fragmento de sitemap.xml con dos URLs. Como hay dos elementos hermanos bajo , se convierten en un array JSON. La declaración de espacio de nombres xmlns se convierte en "@_xmlns" en el objeto urlset. El valor de priority "0.8" permanece como cadena — sin coerción numérica — por lo que valores con cero inicial como "0.08" también se preservarían exactamente.

Elemento RSS

<item>
  <title>XML to JSON: A Practical Guide</title>
  <link>https://go-tools.org/blog/xml-to-json-guide</link>
  <pubDate>Thu, 29 May 2026 00:00:00 GMT</pubDate>
  <category>Developer Tools</category>
  <description>Learn how XML attributes map to @_ keys, how repeated elements become arrays, and why values stay strings in any XML-to-JSON conversion.</description>
  <guid isPermaLink="true">https://go-tools.org/blog/xml-to-json-guide</guid>
</item>

Un elemento item de RSS 2.0. El elemento guid tiene un atributo isPermaLink, por lo que la salida JSON para guid se convierte en un objeto con "@_isPermaLink": "true" y "#text": "https://go-tools.org/blog/xml-to-json-guide" — el atributo y el contenido de texto del elemento coexisten como claves hermanas. Todos los demás elementos solo tienen contenido de texto y se convierten directamente en valores de cadena.

Cómo usar

1

Pega tu XML

Introduce o pega tu XML en el campo de entrada de arriba. También puedes hacer clic en 'Cargar ejemplo' para probar un ejemplo — un archivo de configuración, un fragmento de sitemap o un elemento RSS.
2

Ve la salida JSON en vivo

El JSON aparece instantáneamente en el panel de salida. Los atributos se convierten en claves con prefijo @_, el contenido de texto de elementos mixtos se convierte en #text y los elementos hermanos repetidos se convierten en arrays. Ajusta la sangría (2 o 4 espacios) según necesites.
3

Copia o descarga

Haz clic en Copiar para llevar el JSON al portapapeles, o en Descargar para guardarlo como archivo .json listo para tu aplicación, API o pipeline de datos.

Errores comunes de conversión

Olvidar que los valores permanecen como cadenas

El conversor no realiza ninguna coerción de tipos. Si tu código posterior espera números JSON pero el XML contiene cadenas numéricas, debes coaccionarlas explícitamente después de convertir. Confiar en la coerción implícita de cadena a número (el operador == de JavaScript o los operadores aritméticos) es propenso a errores — usa siempre parseInt(), parseFloat() o Number() de forma deliberada.

✗ Incorrecto

// XML: <timeout>30</timeout>
// JSON output: { "timeout": "30" }  ← string, not number
// Dangerous: comparing as-is
if (config.timeout > 25) { ... }  // "30" > 25 coerces, but fragile

✓ Correcto

// XML: <timeout>30</timeout>
// JSON output: { "timeout": "30" }
// Safe: explicit coercion where you know the type
if (parseInt(config.timeout, 10) > 25) { ... }

Desajuste de forma entre elemento único y array

Cuando solo hay un elemento , la salida es un objeto; cuando hay dos o más, se convierte en un array. El código consumidor que siempre hace result.items.forEach() fallará cuando items sea un único objeto. Normaliza siempre a un array después de convertir si tu esquema permite uno o varios.

✗ Incorrecto

// XML with one item: <root><item>a</item></root>
// JSON: { "root": { "item": "a" } }  ← string, not array
result.root.item.forEach(i => console.log(i));  // TypeError: not a function

✓ Correcto

// Normalize to array regardless of count
const items = [].concat(result.root?.item ?? []);
items.forEach(i => console.log(i));  // safe for 0, 1, or many

Contenido mixto: texto y clave #text

Cuando un elemento tiene tanto atributos como contenido de texto, el texto va bajo #text. Acceder al valor de texto como si fuera una cadena simple devolverá un objeto en su lugar. Comprueba siempre si el valor de un elemento es una cadena o un objeto con una clave #text cuando los atributos son posibles.

✗ Incorrecto

// XML: <price currency="USD">29.99</price>
// JSON: { "price": { "@_currency": "USD", "#text": "29.99" } }
const amount = result.price;  // { "@_currency": "USD", "#text": "29.99" }, not "29.99"

✓ Correcto

// Handle both plain string and @_/#text object
const raw = result.price;
const amount = typeof raw === 'object' ? raw['#text'] : raw;  // "29.99"

Entrada XML no bien formada

El conversor requiere XML bien formado. Causas comunes de errores de conformidad: & sin escapar en el contenido de texto (usa &), etiquetas no coincidentes ( vs — XML distingue mayúsculas de minúsculas), múltiples elementos raíz o etiquetas sin cerrar. El mensaje de error muestra la línea y columna del primer problema.

✗ Incorrecto

<!-- Unescaped & — well-formedness error -->
<query>name = 'Alice' & role = 'admin'</query>

✓ Correcto

<!-- Escaped & — valid XML -->
<query>name = 'Alice' &amp; role = 'admin'</query>

Valores con cero inicial corrompidos por coerción

Esta herramienta preserva los ceros iniciales porque no realiza ninguna coerción de tipos. Si postprocesas el JSON con una librería que sí coerciona (algunos validadores de esquemas JSON, mapeadores ORM), el cero inicial puede perderse. Declara siempre el tipo de campo explícitamente como cadena en tu esquema.

✗ Incorrecto

// XML: <zipCode>01234</zipCode>
// This tool outputs: { "zipCode": "01234" }  ← correct
// But if a downstream schema coerces:
// { zipCode: z.number() }  → 1234  ← leading zero lost

✓ Correcto

// Declare ZIP codes and other padded identifiers as strings
// { zipCode: z.string() }  → "01234"  ← correct

Casos de uso comunes

Consumir APIs SOAP / XML heredadas: Los servicios empresariales heredados (banca, seguros, logística) suelen exponer APIs SOAP que devuelven XML. Convierte la respuesta a JSON para trabajar con los datos usando las herramientas modernas de JavaScript, almacenarlos en una base de datos documental o reenviarlos a un consumidor de API REST.
Procesar feeds RSS y Atom: Los feeds RSS 2.0 y Atom 1.0 son XML. Convierte el XML del feed a JSON para extraer títulos, enlaces, fechas de publicación y descripciones para agregadores de feeds, pipelines de contenido y sistemas de notificación sin depender de una librería de análisis XML.
Analizar archivos de Sitemap: Los archivos sitemap.xml enumeran las URLs de un sitio con metadatos. Convierte un sitemap a JSON para analizar la cobertura de URLs, construir colas de rastreo, comparar sitemaps entre entornos o introducir URLs en una herramienta de verificación de enlaces o auditoría SEO.
Transformar archivos de configuración: Muchos sistemas empresariales (Spring, Maven, Ant, JBoss, Tomcat) usan archivos de configuración XML. Conviértelos a JSON para análisis, scripts de migración, generación de documentación o importación en herramientas que trabajan nativamente con JSON.
Desarrollo móvil y de Android: Los recursos de Android, los archivos de diseño y el AndroidManifest.xml son todos XML. Conviértelos a JSON para scripts de análisis, auditoría automatizada o generación de documentación sobre permisos declarados, actividades y valores de recursos.
Migración de datos y ETL: Las exportaciones de datos de sistemas empresariales (ERP, CRM, nóminas) suelen llegar en XML. Convierte a JSON como primer paso en un pipeline ETL para cargar los datos en un almacén de datos nativo de JSON como MongoDB, Firestore o una API REST.

Detalles técnicos

DOMParser del navegador para el análisis XML: La entrada XML se analiza usando el DOMParser nativo del navegador con el tipo MIME 'text/xml' — el mismo motor usado para renderizar SVG y XHTML. Es completamente compatible con XML 1.0 e informa errores de conformidad con información de línea y columna. Este enfoque gestiona correctamente los espacios de nombres, las secciones CDATA, las instrucciones de procesamiento y las referencias de entidades sin ninguna dependencia de terceros.
Serialización recursiva de DOM a JSON: Tras el análisis, la herramienta recorre el árbol DOM de forma recursiva. Los nodos de elementos se convierten en objetos JSON; sus atributos se convierten en claves con prefijo @_; los elementos de solo texto se convierten en valores de cadena simples; los elementos con tanto atributos como contenido de texto ganan una clave #text para el contenido de texto. Los elementos hermanos con el mismo nombre se recopilan y se emiten como un array JSON. Los nodos de texto de solo espacio en blanco entre elementos se descartan.
Sin coerción de tipos — preservación de cadenas: Todos los valores de atributos y el contenido de texto se escriben en la salida JSON como cadenas. No se aplica parseInt, parseFloat ni análisis booleano. Esta es una elección de diseño deliberada para evitar la corrupción silenciosa de datos para valores con cero inicial, decimales sensibles a la precisión y cadenas que parecen booleanos. La coerción de tipos, cuando sea necesaria, debe aplicarse explícitamente en el código posterior.
100% basado en el navegador — Sin carga, sin servidor: Todo el procesamiento se ejecuta en el motor JavaScript de tu navegador. No se transmiten datos por la red en ningún momento. Las entradas mayores de 200 KB cambian automáticamente del modo en vivo al modo manual (requiriendo un clic explícito en Convertir) para mantener el navegador con capacidad de respuesta y evitar el bloqueo del hilo principal durante el recorrido intensivo del DOM.

Buenas prácticas

Valida primero la conformidad del XML: Si tu fuente XML está escrita a mano o generada por un sistema que ocasionalmente produce salidas malformadas, valídala antes de convertir. Usa el botón Validar del Formateador XML para confirmar que el XML está bien formado y obtener ubicaciones precisas de errores para cualquier problema.
Normaliza los campos de uno o varios elementos a arrays: Cuando tu esquema XML permite uno o varios elementos hijos con el mismo nombre, la salida JSON será un objeto para un elemento y un array para varios. Normaliza siempre estos campos en tu código consumidor: const items = [].concat(result.items ?? []) — esto es seguro para cero, uno o varios y evita TypeErrors.
Aplica la coerción de tipos de forma explícita y selectiva: Dado que esta herramienta preserva todos los valores como cadenas, aplica la coerción de tipos de forma deliberada en tu código para los campos específicos que la necesiten. Usar parseInt(val, 10) para un campo entero conocido es seguro. Aplicar coerción de forma amplia con Number(val) arriesga corromper valores con cero inicial, cadenas vacías y decimales sensibles a la precisión.
Comprueba #text al acceder a los valores de elementos: Si un elemento puede tener atributos en algunas cargas y no en otras, su valor JSON será una cadena simple (sin atributos) o un objeto con claves @_ y una clave #text (con atributos). Escribe accesores robustos: const val = typeof node === 'object' ? node['#text'] : node. Este patrón gestiona ambas formas y evita valores undefined silenciosos.
Para el trabajo XML sin pérdida, usa el Formateador XML: La conversión de XML a JSON descarta comentarios, instrucciones de procesamiento y semánticas de espacios de nombres. Si necesitas preservar todo el contenido XML exactamente, usa el Formateador XML para embellecer, minificar y validar sin ninguna pérdida. Convierte a JSON solo cuando necesites trabajar con los datos en un contexto nativo de JSON.

Preguntas frecuentes

¿Se envían mis datos XML a un servidor cuando uso esta herramienta?

No. Toda la conversión ocurre completamente dentro de tu navegador usando JavaScript. Tu XML nunca se transmite por la red, nunca se almacena en ningún servidor y nunca es registrado ni analizado. Esto hace que la herramienta sea segura para usar con cargas XML que contengan credenciales de API, configuración interna de servicios, tokens SOAP WS-Security, datos HL7/FHIR de salud o cualquier otro contenido sensible. Puedes verificarlo abriendo la pestaña Red de tu navegador — verás cero solicitudes al pegar o convertir XML.

¿Cómo se mapean los atributos XML en la salida JSON?

Los atributos XML se convierten en claves JSON con el prefijo @_. Por ejemplo, produce un objeto JSON que contiene "@_id": "P01" y "@_category": "electronics" junto a las claves de elementos hijos. Cuando un elemento tiene tanto atributos como contenido de texto — como 29.99 — el contenido de texto se almacena bajo la clave especial "#text", por lo que el resultado es { "@_currency": "USD", "#text": "29.99" }. Esta convención es consistente y predecible: @_ siempre significa atributo, #text siempre significa contenido de texto del elemento.

¿El conversor coerciona números o booleanos?

No. Todo el contenido de texto XML y los valores de atributos se convierten en cadenas JSON, independientemente de su apariencia. 42 se convierte en "count": "42", no 42. true se convierte en "enabled": "true", no true. Esto es intencional e importante: preserva los ceros iniciales (números de teléfono, códigos de cuenta, códigos postales como "01234"), la precisión numérica para valores como "0.100" y los valores de cadena que parecen booleanos. Si necesitas números o booleanos en tu JSON posterior, aplica la coerción de tipos en tu propio código después de convertir — donde controlas exactamente qué campos se coaccionan.

¿Cómo se gestionan los elementos repetidos (hermanos con el mismo nombre)?

Un único elemento hijo se convierte en un objeto JSON. Dos o más elementos hijos con el mismo nombre de etiqueta bajo el mismo padre se convierten en un array JSON. Por ejemplo, a produce { "root": { "item": "a" } } — item es un objeto (cadena). Pero ab produce { "root": { "item": ["a", "b"] } } — item es un array. Esto significa que la estructura de tu salida JSON depende del número de elementos hermanos en el XML, que es una razón por la que la conversión de XML a JSON se basa en convenciones. Si tu esquema XML puede tener uno o varios elementos, tu código consumidor debe gestionar tanto el caso de objeto como el de array.

¿La conversión de XML a JSON es sin pérdida?

No. XML tiene características que no tienen equivalente en JSON y se pierden durante la conversión: los comentarios XML () se descartan, las instrucciones de procesamiento () se descartan, los enlaces de prefijos de espacio de nombres se preservan parcialmente como atributos @_ pero sus semánticas no, y el orden relativo de los nodos de contenido mixto (texto entrelazado con elementos hijos) puede no conservarse perfectamente. Para XML puramente estructural sin comentarios ni instrucciones de procesamiento, la conversión preserva todos los nombres de elementos, nombres de atributos, valores de atributos y contenido de texto. Para el trabajo XML sin pérdida — formatear, validar o inspeccionar XML sin ninguna pérdida de datos — usa el Formateador XML.

¿Cómo convierto JSON de vuelta a XML?

Usa nuestro Conversor JSON a XML complementario. Aplica las mismas convenciones a la inversa: las claves con prefijo @_ se convierten en atributos XML, las claves #text se convierten en contenido de texto del elemento y los arrays JSON se convierten en elementos hermanos repetidos con el mismo nombre. Esto hace que las dos herramientas sean simétricas para casos de uso de ida y vuelta.

¿Qué ocurre con los espacios de nombres XML?

Las declaraciones de espacios de nombres (xmlns="..." y xmlns:prefix="...") se tratan como atributos regulares y aparecen en la salida JSON como claves @_xmlns y @_xmlns:prefix. El prefijo de espacio de nombres en los nombres de elementos se preserva como parte de la clave del nombre de elemento (p. ej., se convierte en "soap:Body" en el JSON). El significado semántico de los espacios de nombres — que dos prefijos podrían apuntar al mismo URI — no se interpreta. Si el manejo preciso de los espacios de nombres importa para tu caso de uso, analiza el XML en un parser que reconozca los espacios de nombres en lugar de convertirlo a JSON.

¿Por qué 0123 se convierte en "0123" y no en 123?

Porque el conversor no realiza ninguna coerción de tipos. La cadena "0123" y el número 123 son valores diferentes: "0123" tiene un cero inicial que es significativo en muchos contextos (códigos de cuenta, códigos postales, números de identificación nacionales, identificadores con relleno). Eliminar silenciosamente ese cero inicial corrompería los datos. El comportamiento predeterminado seguro es preservar todos los valores como cadenas exactamente como aparecen en el XML. Aplica el análisis numérico de forma selectiva en tu propio código para los campos específicos donde sabes que el valor es siempre un entero simple.

¿Cuál es la diferencia entre esta herramienta y un formateador XML?

El Formateador XML reformatea XML — cambia la sangría y el espacio en blanco pero la salida sigue siendo XML. Este Conversor XML a JSON cambia el formato completamente: la salida es un documento JSON que representa la estructura XML usando la convención de atributos @_. Usa el formateador cuando quieras leer, editar, validar o minificar XML. Usa este conversor cuando necesites trabajar con los datos XML en una aplicación JavaScript, introducirlos en una API REST o almacenarlos en un almacén de documentos JSON.

¿Existe un límite de tamaño de archivo?

No hay un límite estricto, pero las entradas mayores de 200 KB cambian automáticamente del modo en vivo al modo manual. En el modo manual, aparece un botón Convertir y la conversión se ejecuta solo cuando haces clic en él — esto mantiene el navegador con capacidad de respuesta mientras se analizan documentos XML grandes. Para archivos XML muy grandes (exportaciones de datos de varios megabytes), considera herramientas de línea de comandos para mejor rendimiento: python3 -c "import sys, xmltodict, json; print(json.dumps(xmltodict.parse(sys.stdin.read()), indent=2))" o node -e con una librería XML a JSON dedicada.

¿El conversor gestiona las secciones CDATA?

Sí. El contenido de las secciones CDATA () se trata como contenido de texto del elemento y aparece como un valor de cadena simple en la salida JSON. Los propios delimitadores de CDATA se eliminan — solo se preserva el contenido interior. Por ejemplo, produce "note": "if (a < b) return;" en JSON. Este es el comportamiento correcto: CDATA es simplemente una forma de incrustar texto con caracteres especiales sin escaparlos; el significado semántico es el contenido de texto.

¿Puedo convertir XML con múltiples elementos raíz?

No. El XML con múltiples elementos raíz no está bien formado y esta herramienta requiere XML bien formado como entrada. Si tu parser XML te da múltiples elementos raíz (común al unir fragmentos XML), envuélvelos en un único elemento raíz antes de convertir. Por ejemplo, si tienes , conviértelo como . El mensaje de error indicará la posición del problema de conformidad para que puedas corregirlo rápidamente.

En esta página

¿Qué es la conversión de XML a JSON y cómo funciona?
Características principales
Ejemplos
Cómo usar
Errores comunes de conversión
Casos de uso comunes
Detalles técnicos
Buenas prácticas
Preguntas frecuentes

Herramientas relacionadas
Ver todas las herramientas →

Decodificador y Codificador Base64

Codificación y Formato

Decodifica y codifica Base64 online de forma gratuita. Conversión en tiempo real con soporte completo de UTF-8 y emojis. 100% privado — funciona en tu navegador. Sin registro.

Convertidor de CSV a JSON

Codificación y Formato

Convierte CSV a JSON en tu navegador. RFC 4180, inferencia de tipos, fila de cabecera, seguro para big-int. 100% privado, sin carga.

JSON Diff (Comparar)

Codificación y Formato

Compara dos archivos JSON al instante en tu navegador. Resaltado lado a lado, salida RFC 6902 JSON Patch, ignora campos ruidosos como marcas de tiempo e IDs. 100% privado, sin carga.

Formateador y Validador JSON

Codificación y Formato

Formatea, valida y embellece JSON al instante en tu navegador. Herramienta gratuita con validación sintáctica, detección de errores, minificación y copia con un clic. 100% privado.

Validador JSON Schema

Codificación y Formato

Valida JSON contra cualquier JSON Schema al instante en tu navegador. Compatible con Draft 2020-12, 2019-09 y Draft-07 con mensajes de error con ruta precisa. 100% privado, sin carga, sin cuenta, gratis.

Convertidor de JSON a CSV

Codificación y Formato

Convierte JSON a CSV en tu navegador. Presets RFC 4180, Excel-EU, TSV y Pipe. Aplana anidados o stringify. 100% privado, sin carga.

Conversor XML a JSON

¿Qué es la conversión de XML a JSON y cómo funciona?

Características principales

Conversión en vivo

Convención de prefijo @_ para atributos

Detección automática de arrays para elementos repetidos

Sin coerción de tipos — los valores permanecen como cadenas

Privacidad 100% en el navegador

Informe de errores de conformidad

Ejemplos

Archivo de configuración

Fragmento de Sitemap

Elemento RSS

Cómo usar

Pega tu XML

Ve la salida JSON en vivo

Copia o descarga

Errores comunes de conversión

Olvidar que los valores permanecen como cadenas

Desajuste de forma entre elemento único y array

Contenido mixto: texto y clave #text

Entrada XML no bien formada

Valores con cero inicial corrompidos por coerción

Casos de uso comunes

Detalles técnicos

Buenas prácticas

Preguntas frecuentes

Herramientas relacionadas

Decodificador y Codificador Base64

Convertidor de CSV a JSON

JSON Diff (Comparar)

Formateador y Validador JSON

Validador JSON Schema

Convertidor de JSON a CSV