JSON to XML Converter

What is JSON-to-XML Conversion and How Does It Work?

// 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>

Key Features

Examples

{"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"}}}}

How to Use

1. 1

   Paste Your JSON

   Enter or paste your JSON data into the input field above. You can also click 'Load example' to try a sample — an API response object, an array payload, or an object using @_ attributes and #text.

2. 2

   See Live XML Output

   XML appears instantly in the output panel. Single-key objects use their key as the root; multi-key objects wrap in ; @_-prefixed keys become attributes; arrays become repeated child elements. Adjust indent (2 or 4 spaces) as needed.

3. 3

   Copy or Download

   Click Copy to grab the XML to your clipboard, or Download to save it as a .xml file. To validate or reformat the result, paste it into the XML Formatter.

Common Conversion Pitfalls

// 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'

Common Use Cases

Calling SOAP and Legacy XML Web Services

Build the JSON payload in your application, convert it to XML, and POST it to the SOAP endpoint. This avoids hand-building XML strings and lets you work with the data in a native JSON structure up until the moment you need to serialize it for the legacy service.

Generating XML Configuration Files

Spring, Maven, Ant, Tomcat, and Android all use XML configuration formats. Generate or transform configuration data as JSON — easier to diff and version-control — then convert to XML for deployment.

Producing Sitemap and RSS Feed XML

Content management systems and static site generators often store page metadata as JSON. Convert that metadata to sitemap.xml or RSS feed XML to submit to search engines or syndicate content to feed readers.

Enterprise Data Integration (EDI / ERP / CRM)

ERP systems (SAP, Oracle), CRM platforms, and EDI networks commonly exchange data in XML. Convert JSON exports from modern REST APIs to XML to feed these systems without building a custom XML serializer.

Android Resource Files

Android string resources, layout constraints, and manifest entries are all XML. Generate or update resource files programmatically from JSON data sources and convert to the required XML format for the Android build system.

SVG and Vector Graphics Generation

SVG is XML. Build SVG structure as JSON data — paths, shapes, colors, transforms — then convert to XML to produce valid SVG files for web, print, or vector editing tools.

Technical Details

RFC 8259 Compliant JSON Parsing

JSON input is parsed using the browser's native JSON.parse(), which is fully RFC 8259 compliant. It provides accurate syntax error messages with best-effort position information (line and column) and handles all JSON data types: strings, numbers, booleans, null, arrays, and objects.

Custom Recursive JSON-to-XML Serializer

After parsing, a custom recursive serializer walks the JSON tree. Object keys that start with @_ are emitted as XML attributes on the parent element. The #text key is emitted as the element's text content. Plain object keys become child elements. Array values produce repeated same-named sibling elements. Special characters (<, >, &, ", ') in text content and attribute values are escaped to their XML entity references.

Root Normalization

Because XML requires exactly one root element, the serializer applies root normalization before building the document: single-key objects use the key as root; multi-key objects and top-level arrays receive a synthetic wrapper. This ensures output is always well-formed XML regardless of input shape.

100% Browser-Based — No Upload, No Server

All processing runs in your browser's JavaScript engine. No data is transmitted over the network at any point. Inputs larger than 200KB automatically switch from live mode to manual mode (requiring an explicit Convert click) to keep the browser responsive during heavy serialization.

Best Practices

Control the Root Element with a Single-Key Object

The cleanest way to produce meaningful XML is to ensure your top-level JSON is a single-key object whose key is the desired root element name. Wrapping multi-key data under one named key gives you a semantically meaningful root instead of the generic wrapper.

Use @_ and #text for Attribute-Heavy XML

If your target XML schema uses many attributes (common in configuration files, SVG, and SOAP envelopes), reshape your JSON to use @_-prefixed keys and #text before converting. The resulting XML will match the target schema exactly without post-processing.

Wrap Arrays in Named Objects for Meaningful Tag Names

A top-level array produces the generic ... pattern, where is a fixed literal name. Wrapping the array under a named key — { "products": [...] } — produces repeated elements (the key name is reused for every array element) under a wrapper. This gives you a domain-meaningful tag name and is almost always preferable for XML that will be parsed or validated by a schema.

Validate the Output with the XML Formatter

After converting, paste the XML output into the XML Formatter to validate well-formedness, check indentation, and identify any structural issues before sending the XML to a downstream service or committing it to version control.

Sanitize JSON Keys Before Converting

XML element names must start with a letter or underscore and may not contain spaces or most special characters. If your JSON keys come from an external source (a database column name, an API field name, or user input), audit them for XML name validity before converting to avoid malformed output.

Frequently Asked Questions