Paste any XML document and get a clean, structured JSON output instantly. Nested elements, attributes, and repeated tags are all handled correctly. No login, no data upload.
XML uses nested tags and attributes; JSON uses objects and arrays. The mapping is straightforward: each element becomes a key, nested elements become nested objects, repeated elements at the same level become an array, and attributes are preserved with an @_ prefix.
<user id="1">
<name>Alice</name>
<role>admin</role>
</user>
{
"user": {
"@_id": "1",
"name": "Alice",
"role": "admin"
}
}
Attributes are kept using the @_ prefix — the convention used by most XML-to-JSON libraries. It puts attributes alongside child elements in the same object without key collisions.
Repeated tags at the same level collapse into a JSON array automatically:
<items>
<item>apple</item>
<item>banana</item>
</items>
Output: { "items": { "item": ["apple", "banana"] } } — not two separate keys.
Mixed content (a tag with both text and child elements) moves the text to a #text key alongside the child keys. Self-closing tags like <br /> appear as an empty string or just their attributes.
Banking, government, ERP, and insurance systems frequently expose SOAP services that only produce XML. Web syndication formats — RSS and Atom — are XML. JIRA data exports, Maven POMs, and many legacy configuration formats (Ant, Spring XML) are also XML. JSON is the expected input for modern REST APIs, JavaScript frontends, and NoSQL databases.
Converting XML to JSON is typically a one-off task when consuming a legacy feed or migrating data out of an older system. Doing it here avoids writing a parser by hand.
| Feature | XML | JSON |
|---|---|---|
| Attributes | Yes — <tag attr="val"> | No native equivalent |
| Comments | Yes — <!-- comment --> | Not supported |
| Namespaces | Yes — xmlns:prefix | No |
| Mixed content | Yes — text + child elements | No |
| Data types | Strings only (schema needed for types) | Native numbers, booleans, null |
| Verbosity | High — opening and closing tags | Low |
| Array notation | Implicit (repeated tags) | Explicit [] |
Attributes are included in the JSON output with an @_ prefix. For example, <item id='1'> becomes { "@_id": "1" } alongside the element's child properties. This is the standard convention used by fast-xml-parser and most XML-to-JSON libraries.
If the same tag appears multiple times at the same level (e.g. multiple <item> elements), they are automatically converted to a JSON array. A single occurrence stays as an object; two or more become an array.
No — the XML declaration is stripped from the output since it has no JSON equivalent. Only the document's element content is converted.
Namespace prefixes are preserved as part of the key name (e.g. ns:item becomes the key "ns:item"). Namespace declarations (xmlns attributes) are treated like regular attributes with the @_ prefix.
XML comments (<!-- ... -->) are ignored — they have no JSON equivalent and are not included in the output.
Yes. Both are standard XML documents and are fully supported. SOAP envelopes and RSS/Atom feeds often have deeply nested elements and attributes — all of which are handled correctly.
No. All conversion happens locally in your browser using fast-xml-parser. Your data never leaves your device — safe to use with internal API responses or confidential XML exports.
More Tools