JSON to XML Converter

About converting JSON to XML

JSON and XML are the two dominant text formats for structured data, and you frequently need to move between them. JSON (JavaScript Object Notation) is compact and maps directly onto objects and arrays, which is why modern web APIs default to it. XML (Extensible Markup Language) is more verbose but carries attributes, namespaces, schemas, and a long legacy of enterprise tooling, so SOAP services, configuration files, RSS feeds, and many financial and government systems still demand it. This converter takes valid JSON and emits clean, indented, well-formed XML so you can feed JSON data into an XML-only consumer.

There is no single official JSON-to-XML standard, because the two data models do not line up perfectly. JSON has ordered arrays and a handful of primitive types; XML has elements, attributes, text nodes, and exactly one root. Any converter therefore picks a convention for the awkward cases. This tool uses the widely adopted rules below: object keys become element tags, arrays become repeated tags, and a special @attributes key becomes XML attributes.

How the JSON to XML mapping works

The converter parses your input with the browser's native JSON parser, then walks the resulting tree and writes an XML string with two-space indentation.

object key      -> <key>...</key>        (one element per key)
array [a, b]    -> <key>a</key><key>b</key>  (repeated tag)
"@attributes"   -> attributes on the parent element
string / number -> escaped text inside the element
null            -> self-closing <key/>
single root key -> used as the root; else wrapped in <root>

• Objects recurse: every nested object produces nested child elements.
• Arrays repeat the parent tag, because XML has no native list type.
• Attributes come from the @attributes convention, a pattern popularised by common json2xml libraries.
• Escaping handles the five XML predefined entities so the output is always valid.

Worked example

Paste this JSON, which has a single root key, an array of users, and an id attribute:

{"root":{"user":[{"@attributes":{"id":"1"},"name":"Alice"},
                  {"@attributes":{"id":"2"},"name":"Bob"}]}}

1. Root: the single top-level key root becomes the root element.
2. Array: the two user array items each emit a separate <user> tag.
3. Attributes: each @attributes object becomes id="1" and id="2" on the user tags.
4. Text: the name values become child elements with escaped text.

The output is well-formed XML you can hand straight to any parser:

<?xml version="1.0" encoding="UTF-8"?>
<root>
  <user id="1">
    <name>Alice</name>
  </user>
  <user id="2">
    <name>Bob</name>
  </user>
</root>

JSON to XML mapping reference

Common pitfalls

• Multiple top-level keys. XML allows only one root. If your JSON has several top-level keys, wrap them in a single outer object first, or the converter adds a synthetic <root>.
• Keys that are not valid XML names. XML element names cannot start with a digit or contain spaces. A JSON key like "123" or "first name" produces invalid XML; rename the key before converting.
• Expecting a perfect round trip. Because JSON and XML data models differ, converting JSON to XML and back will not always reproduce byte-identical JSON. Type information (number versus string) is lost in XML, which stores everything as text.
• Forgetting the @attributes convention. Without it, every value becomes a child element. If you need attributes, structure your JSON with the @attributes key.
• Invalid JSON in, no XML out. The tool does not repair malformed JSON. A trailing comma or unquoted key triggers a parse error rather than guessing your intent.

When you would use this

Frequently asked questions