JSON to XML Converter Online - Fast, Secure & Private
Updated
Convert JSON data to XML format instantly. Transform structured data for API integration. 100% client-side privacy. Free online tool.
Key Features
- ✅ Recursive mapping
- ✅ Automatic <root> wrapper when needed
- ✅ Attribute support
- ✅ Array handling
- ✅ Safe character escaping
How to Use
- Paste your JSON data into the input area
- The tool automatically detects the structure
- Arrays become repeated elements named after their key; a top-level array is wrapped in <root> with one <row> per item
- Click Convert to generate XML output
- Review the XML structure in the output panel
- Copy or download the converted XML file
- Use in your XML parser or system integration
- Validate against XML schema if required
Expert FAQ
- JSON has no concept of "attribute" — does everything become a child element, or can I get XML attributes out?
By default every JSON key becomes a child element, since JSON's flat key/value model has no native equivalent to an XML attribute. If a key is prefixed with "@" (matching the same convention used by this site's XML to JSON converter), it's emitted as an attribute on the parent element instead — this only works if your JSON was originally produced by an XML-aware tool using that convention; plain hand-written JSON won't have it. - My JSON has an array of 5 items — does the output wrap them in a container tag, or just repeat the tag 5 times?
Arrays are emitted as repeated sibling elements using the array's own key as the tag name, without an extra wrapper — {"item": [1,2,3]} becomes <item>1</item><item>2</item><item>3</item>, not <item><value>1</value>...</item>. This matches how most XML schemas represent repeatable elements, but be aware it means a single-item array and a non-array value with the same key produce visually similar XML — round-tripping back through XML to JSON requires that converter to know which elements are meant to be arrays. - What happens to JSON keys that aren't valid XML element names — like keys with spaces, or keys starting with a number?
XML element names can't start with a digit, can't contain spaces, and can't start with the reserved prefix "xml". Any JSON key that violates these rules is sanitized (spaces replaced, a leading underscore added if the key starts with a digit) so the output is well-formed XML — which means the round-trip isn't always perfectly reversible if your JSON relies on keys XML simply can't represent as element names. - How does it handle null values and special characters like & and < inside strings?
A null value becomes an empty, self-closing element (<field/>) rather than literal text "null", which matches how most XML schemas represent absent data. String values are escaped per the XML spec — & becomes &, < becomes <, and so on — so any text containing markup-like characters still produces valid, parseable XML rather than corrupting the document structure.
Technical Details
Converting JSON to XML requires resolving an asymmetry between the two formats: JSON has exactly one way to nest data (objects and arrays of values), while XML distinguishes between child elements and attributes, and additionally needs every element name to be a valid XML identifier. By default, every JSON key becomes a child element rather than an attribute, since there's no information in plain JSON to indicate attribute intent — the "@key" convention (matching this site's XML to JSON tool) is supported for cases where the JSON was originally derived from XML and needs to round-trip back to attributes. Arrays are flattened to repeated sibling elements sharing the array's key as the tag name, without an enclosing wrapper element — this mirrors how most real-world XML schemas (RSS items, SOAP repeating elements) represent lists, but means a length-1 array and a scalar value under the same key can look identical in the output XML; if exact array-vs-scalar fidelity matters for a downstream consumer, that information needs to be preserved separately (e.g. in an XML schema) rather than inferred from a single converted document. JSON keys are sanitized as needed to produce valid XML element names — no spaces, no leading digits, no reserved "xml" prefix — and string values are escaped for the five XML predefined entities (& < > ' ") so that any text content, including markup-like characters, survives as valid XML rather than breaking the document. Once converted, validate the result with the XML Validator, or reformat it for readability with the XML Formatter.