Conversor JSON a XML

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

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

const data = {
  catalog: {
    product: {
      '@_id': 'P01',
      '@_category': 'electronics',
      name: 'Wireless Headphones',
      price: {
        '@_currency': 'USD',
        '#text': '79.99'
      }
    }
  }
};

const builder = new XMLBuilder({
  attributeNamePrefix: '@_',   // @_ keys become XML attributes
  textNodeName: '#text',       // #text key becomes element text content
  ignoreAttributes: false,     // process @_ attribute keys
  format: true,                // pretty-print with indentation
  indentBy: '  ',              // 2-space indent
});

const xml = builder.build(data);
console.log(xml);
// <catalog>
//   <product id="P01" category="electronics">
//     <name>Wireless Headphones</name>
//     <price currency="USD">79.99</price>
//   </product>
// </catalog>

Características principales

Ejemplos

{"user":{"id":42,"name":"Alice Kim","email":"alice@example.com","role":"admin","address":{"city":"Seoul","country":"KR"}}}

[{"id":1,"name":"Widget A","price":9.99},{"id":2,"name":"Widget B","price":14.99},{"id":3,"name":"Widget C","price":4.49}]

{"catalog":{"product":{"@_id":"P01","@_category":"electronics","name":"Wireless Headphones","price":{"@_currency":"USD","#text":"79.99"}}}}

Cómo usar

1. 1

   Pega tu JSON

   Introduce o pega tus datos JSON en el campo de entrada de arriba. También puedes hacer clic en 'Cargar ejemplo' para probar un ejemplo — un objeto de respuesta de API, una carga de array o un objeto que usa atributos @_ y #text.

2. 2

   Ve la salida XML en vivo

   El XML aparece instantáneamente en el panel de salida. Los objetos de una sola clave usan su clave como raíz; los objetos con múltiples claves se envuelven en ; las claves con prefijo @_ se convierten en atributos; los arrays se convierten en elementos hijos repetidos. Ajusta la sangría (2 o 4 espacios) según necesites.

3. 3

   Copia o descarga

   Haz clic en Copiar para llevar el XML al portapapeles, o en Descargar para guardarlo como archivo .xml. Para validar o reformatear el resultado, pégalo en el Formateador XML.

Errores comunes de conversión

// Input: { "status": 200, "data": { "id": 1 } }
// Output: <root><status>200</status><data><id>1</id></data></root>
// Root is <root> — may not match your schema

// Wrap in a named key to control the root element
// Input: { "response": { "status": 200, "data": { "id": 1 } } }
// Output: <response><status>200</status><data><id>1</id></data></response>

// Input: [{ "id": 1 }, { "id": 2 }]
// Output: <root><item><id>1</id></item><item><id>2</id></item></root>
// Tag names are generic

// Wrap in a named key for meaningful tag names
// Input: { "products": [{ "id": 1 }, { "id": 2 }] }
// Output: <root><products><id>1</id></products><products><id>2</id></products></root>
// Each array element reuses the key name "products" as its tag

// Input: { "tag": { "id": "42", "name": "Alice" } }
// Output: <tag><id>42</id><name>Alice</name></tag>  ← id is a child element

// Use @_ prefix for attributes
// Input: { "tag": { "@_id": "42", "name": "Alice" } }
// Output: <tag id="42"><name>Alice</name></tag>  ← id is an attribute

// Input: { "price": { "@_currency": "USD", "value": "29.99" } }
// Output: <price currency="USD"><value>29.99</value></price>
// Text is a child element, not text content

// Use #text for element text content
// Input: { "price": { "@_currency": "USD", "#text": "29.99" } }
// Output: <price currency="USD">29.99</price>  ← text content

// JSON key starts with digit — invalid XML element name
// Input: { "1stItem": "value" }
// Output: <1stItem>value</1stItem>  ← invalid XML

// Use a valid XML element name
// Input: { "firstItem": "value" }
// Output: <firstItem>value</firstItem>  ← valid XML

// JSON: { "query": "name = 'Alice' & role = 'admin'" }
// Converter outputs: <query>name = 'Alice' &amp; role = 'admin'</query>
// If double-processed: &amp;amp; — consumer is re-escaping

// Converter output is correct — consume it as XML, not as a raw string
// <query>name = 'Alice' &amp; role = 'admin'</query>
// XML parser decodes to: name = 'Alice' & role = 'admin'

Casos de uso comunes

Llamar a servicios web SOAP y XML heredados

Construye la carga JSON en tu aplicación, conviértela a XML y envíala mediante POST al endpoint SOAP. Esto evita construir cadenas XML a mano y te permite trabajar con los datos en una estructura JSON nativa hasta el momento en que necesitas serializarlos para el servicio heredado.

Generar archivos de configuración XML

Spring, Maven, Ant, Tomcat y Android usan todos formatos de configuración XML. Genera o transforma los datos de configuración como JSON — más fácil de comparar y controlar versiones — y luego convierte a XML para el despliegue.

Producir XML de Sitemap y feed RSS

Los sistemas de gestión de contenido y los generadores de sitios estáticos a menudo almacenan los metadatos de páginas como JSON. Convierte esos metadatos a XML de sitemap.xml o feed RSS para enviarlos a los motores de búsqueda o sindicar el contenido a los lectores de feeds.

Integración de datos empresariales (EDI / ERP / CRM)

Los sistemas ERP (SAP, Oracle), las plataformas CRM y las redes EDI comúnmente intercambian datos en XML. Convierte las exportaciones JSON de APIs REST modernas a XML para alimentar estos sistemas sin construir un serializador XML personalizado.

Archivos de recursos de Android

Los recursos de cadenas de Android, las restricciones de diseño y las entradas del manifiesto son todos XML. Genera o actualiza archivos de recursos de forma programática a partir de fuentes de datos JSON y conviértelos al formato XML requerido por el sistema de compilación de Android.

Generación de SVG y gráficos vectoriales

SVG es XML. Construye la estructura SVG como datos JSON — paths, formas, colores, transformaciones — y luego conviértela a XML para producir archivos SVG válidos para la web, impresión o herramientas de edición vectorial.

Detalles técnicos

Análisis JSON conforme a RFC 8259

La entrada JSON se analiza usando el JSON.parse() nativo del navegador, que es completamente conforme a RFC 8259. Proporciona mensajes de error de sintaxis precisos con información de posición del mejor esfuerzo (línea y columna) y gestiona todos los tipos de datos JSON: cadenas, números, booleanos, null, arrays y objetos.

Serializador recursivo personalizado de JSON a XML

Tras el análisis, un serializador recursivo personalizado recorre el árbol JSON. Las claves de objeto que comienzan con @_ se emiten como atributos XML en el elemento padre. La clave #text se emite como el contenido de texto del elemento. Las claves de objeto simples se convierten en elementos hijos. Los valores de array producen elementos hermanos repetidos con el mismo nombre. Los caracteres especiales (<, >, &, ", ') en el contenido de texto y los valores de atributos se escapan a sus referencias de entidad XML.

Normalización de la raíz

Dado que XML requiere exactamente un elemento raíz, el serializador aplica la normalización de la raíz antes de construir el documento: los objetos de una sola clave usan la clave como raíz; los objetos con múltiples claves y los arrays de nivel superior reciben un envoltorio sintético. Esto garantiza que la salida sea siempre XML bien formado independientemente de la forma de la entrada.

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 durante la serialización intensiva.

Buenas prácticas

Controla el elemento raíz con un objeto de una sola clave

La forma más limpia de producir XML con significado es asegurarse de que tu JSON de nivel superior sea un objeto de una sola clave cuya clave sea el nombre del elemento raíz deseado. Envolver los datos con múltiples claves bajo una clave con nombre te proporciona una raíz semánticamente significativa en lugar del genérico envoltorio .

Usa @_ y #text para XML con muchos atributos

Si tu esquema XML de destino usa muchos atributos (común en archivos de configuración, SVG y envelopes SOAP), reshapeea tu JSON para usar claves con prefijo @_ y #text antes de convertir. El XML resultante coincidirá exactamente con el esquema de destino sin postprocesamiento.

Envuelve los arrays en objetos con nombre para nombres de etiqueta con significado

Un array de nivel superior produce el patrón genérico ..., donde es un nombre literal fijo. Envolver el array bajo una clave con nombre — { "products": [...] } — produce elementos repetidos (el nombre de la clave se reutiliza para cada elemento del array) bajo un envoltorio . Esto te proporciona un nombre de etiqueta con significado de dominio y es casi siempre preferible para XML que será analizado o validado por un esquema.

Valida la salida con el Formateador XML

Después de convertir, pega la salida XML en el Formateador XML para validar la conformidad, comprobar la sangría e identificar cualquier problema estructural antes de enviar el XML a un servicio posterior o confirmarlo en el control de versiones.

Sanea las claves JSON antes de convertir

Los nombres de elementos XML deben comenzar con una letra o guión bajo y no pueden contener espacios ni la mayoría de los caracteres especiales. Si tus claves JSON provienen de una fuente externa (un nombre de columna de base de datos, un nombre de campo de API o entrada del usuario), audítalas para verificar la validez del nombre XML antes de convertir para evitar una salida malformada.

Preguntas frecuentes