JSON to XML Converter

Q: How does this tool convert JSON to XML?

It parses your JSON and wraps it in a single root element, then turns each object key into a child element, each array into repeated elements sharing the parent's tag name, and each scalar into that element's text. For example {"ports":[80,443]} becomes 80 443 . Because XML requires exactly one root, the whole document is placed inside a root element whose name you can change.

Q: How do I produce XML attributes instead of child elements?

Prefix the key with @. A key like "@id" becomes an attribute on the surrounding element, and the special key "#text" becomes the element's text content. So {"book":{"@id":"bk101","#text":"Dune"}} produces Dune . This @/#text convention is the same one our XML to JSON tool reads back, so the two round-trip.

Q: What happens to keys that aren't valid XML names?

XML element names can't contain spaces and can't start with a digit, so a JSON key like "first name" or "123" would produce invalid XML. The tool renames those to a safe form (first_name, _123) and tells you in the insights panel which keys it had to change, so the output is always well-formed.

Q: Can I control the root element and the XML declaration?

Yes. You can set the root element name (it defaults to root) and toggle the declaration on or off. If your JSON is a top-level array, it is wrapped in the root element with one per entry, since an array has no single tag name of its own.

Q: Is my data sent to a server?

No. The conversion runs entirely in your browser with JavaScript. Your JSON never leaves your device, so it's safe to convert payloads that contain internal identifiers, tokens, or other sensitive values. You can copy the XML or download it as a .xml file.

Convert JSON to XML online. Maps arrays to repeated elements and @keys to attributes, with a configurable root element. Runs entirely in your browser.

JSON input (0 chars)

Root element

Indentation

Declaration Include <?xml?>

XML output

All conversion happens locally in your browser. No data is sent to any server. Your JSON stays completely private.

What It Does

This tool rewrites JSON as XML — the format still used by SOAP services, RSS and Atom feeds, sitemaps, office documents, and many enterprise APIs. Objects become nested elements, arrays become repeated elements that share the parent's tag name, and scalar values become the text inside each element. Because XML must have exactly one root, everything is wrapped in a root element whose name you choose. The tool also supports the two things people most often need when generating real XML: attributes and text. Any key you prefix with @ becomes an attribute, and a #text key becomes the element's text, so you can produce markup like <book id="bk101">Dune</book> rather than being limited to elements only. It then explains exactly how it mapped your data — how many arrays it expanded, how many attributes it created, and any keys it had to rename to stay valid XML — so there are no surprises.

When to Use It

You have a JSON API response and need to feed it into a legacy system, SOAP endpoint, or tool that only accepts XML.
You're generating an RSS/Atom feed, sitemap, or config file from JSON data and want clean, indented XML.
You need attributes in the output (id, type, lang) and want a converter that supports them via the @ convention rather than elements only.
You want to see exactly how nested arrays and objects map to repeated elements before wiring up the conversion in code.

Worked Examples

{"note":{"to":"Ada","from":"Alan","body":"Hello"}}

A simple object becomes nested elements: <note> containing <to>, <from> and <body>. This is the plain element-only mapping.

{"library":{"book":[{"title":"Dune"},{"title":"Foundation"}]}}

The book array is expanded into two repeated <book> elements inside <library> — the standard way arrays map to XML.

{"book":{"@id":"bk101","@lang":"en","#text":"Dune"}}

The attribute case: @id and @lang become attributes and #text becomes the element text, producing <book id="bk101" lang="en">Dune</book>.

Features

JSON to clean

indented XML in real time

Arrays expanded to repeated elements

@-prefixed keys mapped to attributes

#text key mapped to element text

Configurable root element name

Optional <?xml?> declaration

2 or 4-space indentation

Automatic renaming of invalid element names

Mapping summary (elements

attributes

arrays

depth)

Strict JSON parsing with line and column errors

File upload and drag-and-drop

Copy and download the XML

Browser-only processing with no server uploads

How to Use

1. Paste or upload JSON in the input area. 2. Optionally set the root element name, indentation, and whether to include the XML declaration. 3. The XML appears instantly, with a panel explaining how arrays and attributes were mapped. 4. Click Copy or Download to save the result.

Common Mistakes

Expecting a JSON array to become a single XML element. Arrays become repeated sibling elements sharing the parent tag name — there is no wrapper element per array unless you add one in the JSON.
Using keys with spaces or leading digits and expecting valid XML. Those aren't legal element names; the tool renames them, but it's better to fix the source key if the exact name matters.
Forgetting XML needs one root. A top-level array or multiple top-level keys are all placed inside the single root element — set the root name to something meaningful.
Assuming attributes appear automatically. Only keys you prefix with @ become attributes; everything else becomes an element.

Frequently Asked Questions

How does this tool convert JSON to XML?

How do I produce XML attributes instead of child elements?

What happens to keys that aren't valid XML names?

Can I control the root element and the XML declaration?

Is my data sent to a server?