How to Convert XML to JSON Without Losing Attributes or Structure

XML to JSON conversion parses an XML document into a tree, then rebuilds that same tree as nested JSON objects and arrays. Element names become object keys, nested elements become nested objects, and the text between opening and closing tags becomes a string value. Nothing about the underlying data changes - only the notation does.

The hard part is that XML carries two kinds of information JSON does not have a built-in place for: attributes (sku="A100") and mixed content (an element that has both attributes and text, or text alongside child elements). A good converter needs a fixed convention for both, so the output is predictable no matter what document you feed it. The XML to JSON Converter uses an @ prefix for attributes and a #text key for element text when it coexists with attributes or children.

XML has not disappeared - SOAP APIs, RSS/Atom feeds, many enterprise config formats, and older data exports still use it. But most modern tooling, from JavaScript frontends to REST-based backends, is built around JSON. Converting at the boundary lets you keep working with a legacy source while writing the rest of your code the way you already do.

• Simpler client code - JSON.parse and dot-notation access replace XML DOM traversal or XPath.
• Easier interoperability - JSON slots straight into REST APIs, JavaScript objects, and NoSQL document stores.
• Better tooling fit - JSON works natively with things like JSON Path queries, schema validators, and most logging pipelines.
• Lighter payloads - dropping closing tags and redundant markup typically shrinks the document.

The parser walks the XML tree depth-first. For each element it creates a JSON object, adds one @-prefixed key per attribute, and recurses into each child element. If a child tag name appears more than once under the same parent, those occurrences are collapsed into a JSON array instead of overwriting one another - so a single <item> stays an object, but three <item> siblings become an array of three objects.

Text content is where the two formats disagree most. If an element contains only text and no attributes or children, it converts to a plain string. If it also has attributes (or child elements alongside the text), the text is moved to a #text key so it does not collide with the attribute keys or the nested objects. Entities such as &, <, and > are unescaped back into their literal characters along the way, since JSON has no equivalent escaping requirement.

<catalog>
  <product sku="A100">
    <name>Wireless Mouse</name>
    <price currency="USD">24.99</price>
  </product>
</catalog>

{
  "catalog": {
    "product": {
      "@sku": "A100",
      "name": "Wireless Mouse",
      "price": {
        "@currency": "USD",
        "#text": "24.99"
      }
    }
  }
}

1. Open the XML to JSON Converter and paste your XML - a SOAP response, a feed, or a config file with its declaration and namespaces intact.
2. Let the parser walk the document; it converts elements, attributes, and text using the @ and #text convention automatically.
3. Check the array shape for any elements that repeat, since a document with one occurrence today might have several tomorrow.
4. Copy or download the resulting JSON, then consume it directly in your JavaScript app, pipeline, or data store.

There is nothing to install and no account required, and the conversion keeps working offline once the page has loaded - useful when you are converting XML that should not touch a network at all.

• Consuming a legacy SOAP or XML API response as JSON inside a modern JavaScript or TypeScript app.
• Turning an RSS or Atom feed into JSON for a custom reader or aggregator.
• Migrating XML configuration files into a JSON-based configuration system.
• Inspecting a dense XML document by converting it to JSON and browsing it with a tree viewer.
• Normalizing third-party XML exports into JSON before loading them into a data pipeline or database.

Repeated elements changing shape

Because a single occurrence of a tag converts to an object while two or more convert to an array, code that reads catalog.product.name can break the moment a feed adds a second product and the value becomes catalog.product[1].name. Always write consumer code that treats a field as either-object-or-array, or normalize it to an array right after conversion.

Mixed content and text nodes

An element like <price currency="USD">24.99</price> has both an attribute and text, so its value cannot simply be the string "24.99" - that would silently discard the currency. Look for the #text key rather than assuming every element resolves to a plain string, especially when the source XML mixes plain elements with attributed ones.

No native types in XML

XML has no type system, so numbers, booleans, and dates are all just text in the source document. The converter preserves them as strings ("24.99", "true") rather than guessing at a type, because guessing wrong is worse than leaving the cast to code that knows the intended type. Convert values explicitly where your application needs a number or boolean.

• Confirm the XML is well-formed before converting - unclosed tags or unescaped & characters will fail to parse.
• Treat any element that could legally repeat as an array in your consuming code, even if today's sample only has one.
• Cast strings to numbers, booleans, or dates explicitly in your own code rather than assuming the JSON already has the right type.
• Once converted, format or validate the JSON output so it is easy to review before it goes into a pipeline.
• If you need to go the other direction later, the matching JSON to XML converter reverses the same @ and #text convention.