Convert JSON to XML and Back

JSON vs. XML: Structural Differences

JSON and XML are both text-based data interchange formats, but they represent information differently. JSON uses key-value pairs, arrays, and a small set of data types (string, number, boolean, null, object, array). XML uses elements, attributes, text content, and namespaces within a hierarchical tag structure. These structural differences make conversion between them less straightforward than it might appear.

A simple JSON object like {"name": "Alice", "age": 30} can map to XML in multiple ways. It could become <person><name>Alice</name><age>30</age></person> with each property as a child element. Or it could become <person name="Alice" age="30"/> with properties as attributes. Both are valid XML, and different conversion tools make different choices.

XML has features that JSON lacks: attributes (metadata attached to elements), namespaces (for avoiding name collisions between different XML vocabularies), processing instructions, CDATA sections (for embedding raw text), and comments. When converting from XML to JSON, these features must be mapped to JSON structures, and there is no universally agreed-upon mapping.

JSON has features that XML handles differently: arrays are a native JSON concept ([1, 2, 3]), but XML represents sequences as repeated sibling elements with the same tag name. JSON's null type has no direct XML equivalent — an empty element, an absent element, or an element with an xsi:nil attribute could all represent "no value."

Mapping JSON to XML

Objects become elements: Each key in a JSON object becomes an XML child element. The key name becomes the element tag, and the value becomes the element content. Nested objects become nested elements, preserving the hierarchy naturally.

Arrays become repeated elements: A JSON array like "colors": ["red", "blue"] typically becomes <colors><item>red</item><item>blue</item></colors>. The wrapper element uses the property name, and each array element becomes a child with a generic tag (often "item" or the singular form of the property name). Some converters omit the wrapper and output sibling elements directly.

Primitive values become text content: Strings, numbers, and booleans become the text content of their parent element. JSON data types are lost in the conversion — 42 (a number) and "42" (a string) both become the text 42 in XML. If type preservation matters, you can add a type attribute: <age type="number">42</age>.

Root element requirement: XML requires a single root element wrapping the entire document. JSON has no such requirement — a JSON file can be an array or any single value at the top level. Converters typically wrap the output in a root element (commonly <root>) when the JSON structure does not naturally provide one.

Invalid XML names: JSON keys can contain characters that are not valid in XML element names — spaces, leading digits, most punctuation. Keys like "2024-data" or "first name" must be sanitized or encoded. Common approaches include replacing invalid characters with underscores or using a generic element with a name attribute: <field name="2024-data">.

Mapping XML to JSON

Converting XML to JSON requires handling attributes, mixed content, and namespaces. Several conventions exist:

Parker convention: The simplest approach — attributes are ignored, elements become properties, and text content becomes string values. Simple and readable but loses attribute data.

BadgerFish convention: Preserves everything. Attributes are prefixed with @, text content goes under $, and namespaces are represented as properties. Faithful to the XML but produces verbose, harder-to-read JSON.

Custom mapping: Most real-world conversions use a custom mapping tailored to the specific XML schema. You decide which elements become objects, which become arrays, how attributes map to properties, and what to do with namespaces. This produces the cleanest JSON but requires knowledge of the XML structure.

The trickiest XML-to-JSON issue is distinguishing arrays from single elements. If an XML document has one <item> child, should it become a JSON object or a single-element array? Without a schema, the converter cannot know whether the element can repeat. Most converters default to objects and require configuration to specify which elements should always be arrays.

When to Use JSON vs. XML

JSON dominates modern web APIs because it is lighter weight, maps naturally to JavaScript objects, and is simpler to parse and generate. Most REST APIs, single-page applications, and mobile backends use JSON exclusively.

XML remains essential in enterprise systems (SOAP web services, EDI), document formats (XHTML, SVG, DocBook, OOXML), configuration files (Maven, Android manifests, Spring), and industries with established XML standards (healthcare HL7, finance FpML, publishing ONIX). If you work with any of these systems, you will encounter XML and may need to convert it to JSON for modern frontends and APIs.

Conversion is a practical bridge between these worlds. A legacy SOAP service returns XML, but your React frontend expects JSON. A partner sends data as XML, but your pipeline processes JSON. In these scenarios, reliable conversion tools save hours of manual mapping.

Convert JSON to XML Online

Our JSON to XML Converter handles bidirectional conversion between JSON and XML in your browser. Paste JSON to get well-formed XML output, or paste XML to get clean JSON. The tool handles nested objects, arrays, attributes, and special characters automatically. You can customize the root element name, array item naming, and indentation style.

All processing is done locally — your data never leaves your browser. Use it for quick format conversions, API response transformation, or exploring how your data structures map between the two formats.