What is a JSON to XML converter?
A JSON to XML converter changes the notation of a document without changing the data inside it. The same object that is written as {"name": "John", "age": 30} in JSON becomes <name>John</name> and <age>30</age> in XML. Every key, every value, every type and the order of the entries survive the trip; what changes is the syntax around them.
The two formats describe the same shapes, but they write structure in completely different ways. JSON spells nesting with braces, brackets and commas, and marks a list by enclosing it in square brackets. XML spells nesting with tags - one opening tag, the children, one closing tag - and has no list marker at all: a JSON array becomes the same element repeated once per item. That is the single biggest difference to keep in mind when you read the output.
The conversion matters because plenty of systems still speak only XML. SOAP endpoints, older enterprise integrations, banking and insurance systems, government feeds, sitemap and RSS generators, office document formats and a long list of hardware and device protocols all take XML and nothing else. So does plenty of modern infrastructure: a JSON API feeding an XML consumer, or a config file that has to be written in both notations. Converting between them is how you get from one to the other without retyping anything by hand.
How to convert JSON to XML
The workflow is three steps: paste, convert, copy.
- Paste valid JSON into the JSON Input panel on the left. Use Load Example if you want to try one of the ready-made documents first, or Upload .json to read a file from your machine.
- Click Convert to XML. The document is parsed, checked and written out as indented XML with two spaces of indentation per level. Conversion also runs automatically while you type, so the button is a shortcut rather than a requirement.
- Read the generated XML in the XML Output panel, then use Copy XML or Download to take it. Download writes a .xml file that is ready to hand to a SOAP endpoint, an import routine or a document pipeline.
- If your JSON does not parse, the panel reports the line and column of the first syntax error and points at the offending line. Nothing is converted, and your input stays exactly as you typed it so you can fix it in place.
The conversion happens entirely in your browser. There is no upload step, no account and no usage limit, so it is equally usable for a three-line snippet and for a multi-megabyte API response.
JSON to XML example
The same document appears below as JSON and as the XML this converter produces. Nothing was added and nothing was removed: the nested object and the array are both still there, they are just written with tags and indentation instead of braces and commas.
Note how the array is handled. JSON gives you "skills": [...] as a list; XML has no list marker, so the two items are written as two separate <skill> elements. The key was singularised so each repeated element reads as one record rather than as a leftover of the JSON key - the same rule turns categories into category, while a key that is already singular keeps its exact name.
{
"name": "John",
"age": 30,
"active": true,
"skills": ["JavaScript", "Python"],
"address": {
"city": "Lahore",
"country": "Pakistan"
}
}<?xml version="1.0" encoding="UTF-8"?>
<root>
<name>John</name>
<age>30</age>
<active>true</active>
<skill>JavaScript</skill>
<skill>Python</skill>
<address>
<city>Lahore</city>
<country>Pakistan</country>
</address>
</root>What the converter preserves
Keys keep their order and their spelling, and nesting is preserved exactly, including the awkward cases: an array of objects, an object nested inside an array, an array of arrays, and empty objects and arrays, which are written as a single self-closing element so the document never contains an open tag that is never closed.
Values keep their type. A JSON number becomes an XML number, true and false stay booleans, and everything else stays text. Two JSON types have no exact XML equivalent, and the converter handles them the way XML forces it to: a null is written as an empty element such as <value/>, and an empty string is written as an empty pair of tags, so the two remain distinguishable in the output.
Text is escaped the way XML requires. The ampersand and the angle brackets are replaced with their entity references, so a value containing a & b becomes a & b and the document still parses. Characters that XML forbids outright, such as the control characters that arrive from JSON escapes, are replaced with the Unicode replacement character, and the note under the editor says how many were affected.
Element names are the one place XML cannot always follow JSON, because a JSON key can be any string while an XML name is restricted. A key such as "2024 sales" or "$id" is repaired into a legal name, and any key that had to change is listed in a note below the editor so you can see exactly what was renamed. Keys that are already legal are never touched.
JSON vs XML: when to use which
Neither format is universally better - they are built for different jobs, and choosing the right one is usually about who or what reads the data next.
| Aspect | JSON | XML |
|---|---|---|
| Typical use | APIs, data interchange, config and log payloads | SOAP and enterprise APIs, documents, feeds, legacy systems |
| Structure is written with | Braces, brackets and commas | Nested opening and closing tags |
| Key syntax | Always double-quoted | Element names, restricted to letters, digits, - . and _ |
| Lists | Written explicitly inside square brackets | The same element repeated once per item |
| Metadata on a value | No attributes - it becomes another key | Attributes on any element |
| Syntax strictness | Very strict - one shape, no extras | Permissive, with several ways to write the same thing |
| Comments | Not allowed | Allowed |
| Null value | A first-class null literal | No null - conventionally an empty element |
A practical rule: if a program on the other end parses the data, or if it travels over a network or gets stored in a database column, pick whichever format that program expects and convert at the boundary. JSON is the default for modern web APIs; XML is still the default for enterprise and document systems. Because the two carry the same data, converting between them is a formatting step rather than a migration.
Related JSON tools
Converting JSON to XML is only one of the jobs a JSON workflow involves. These are the other Calzyra tools you are most likely to reach for next.
- Need to make minified or compact JSON readable before you convert it?JSON Formatter
- Need to check whether a document is valid JSON and find the exact syntax error?JSON Validator
- Need the same prettifying job under its other name?JSON Beautifier
- Need to shrink JSON back to a single line for a URL or a payload?JSON Minifier
- Need to explore a deeply nested document as collapsible nodes?JSON Tree Viewer
- Need the output as rows for a spreadsheet instead of XML?JSON to CSV Converter
- Need a YAML document instead of XML?JSON to YAML Converter
- Need TypeScript types generated from your JSON structure?JSON to TypeScript Interface
Frequently Asked Questions
What is a JSON to XML converter?
A JSON to XML converter rewrites a data structure that is written in JSON syntax as an XML document with the same data inside it. Each JSON key becomes an XML element, each value becomes that element's text, and each level of nesting becomes another level of indentation. The data is unchanged - only the notation is. It is the tool you need when a system, partner or legacy integration accepts XML but the data you have arrived as JSON.
How do I convert JSON to XML?
Paste your JSON into the JSON Input panel, click Convert to XML, then read the result in the XML Output panel and copy it. Conversion also runs automatically as you type. Everything happens inside your browser, so there is nothing to install, no account to create and no data to upload.
Is this JSON to XML converter free?
Yes. It is free to use with no sign-up, no usage limit and no watermark. Because the conversion runs locally in your browser there is also no upload size limit, which makes it usable for a small config snippet and for a multi-megabyte API response alike.
Can I convert nested JSON to XML?
Yes, and nesting is the normal case. A JSON object becomes an XML element containing one child element per key, and each nested object adds another level of indentation, so a document of any depth converts in a single pass. The status line reports how many levels it found and how many elements it wrote.
Can I convert JSON arrays to XML?
Yes. XML has no list marker of its own, so an array becomes one repeated sibling element per item, using the key's own name. A plural key is singularised so the repeated name reads as a single record - skills becomes skill and categories becomes category - while a key that is already singular, such as address or status, keeps its exact name. An array at the very top of the document uses item, because every document needs exactly one root element.
Does the converter validate JSON?
Yes. The input is parsed with a strict JSON parser before anything is written, and if it does not parse the converter reports the first syntax error with its line, column and the offending line of text. No XML is produced in that case, and your input is left untouched so you can fix it in place.
What is the difference between JSON and XML?
JSON is a strict data interchange format: objects and arrays in braces and brackets, double-quoted keys, no comments, and no way to attach metadata to a value other than by adding a key. XML is a markup language: nested tags, attributes on any element, comments, and a name for the document type itself. XML is older and still required by many enterprise, government and document systems; JSON is what most modern web APIs speak. Neither is universally better - they are built for different consumers.
What happens to values JSON has and XML does not?
A JSON null is written as an empty element, for example <value/>, because XML has no null literal. Booleans and numbers are written as their plain text, exactly as JSON spells them, so true stays true and 30 stays 30. An empty string stays an empty pair of tags, which keeps it distinct from a null. Characters that XML reserves - the ampersand and the angle brackets - are escaped, and a JSON key that is not a legal XML element name has the illegal characters replaced with an underscore, with a note listing every key that was changed.