XML to JSON Converter Pro

Complete Guide to Converting XML to JSON Online

XML did not go away — it retreated into the systems that are hardest to replace. SOAP web services, RSS and Atom feeds, Android manifests and layout resources, Maven POMs, Spring and log4j configuration, ISO 20022 and XBRL financial messages, and a large share of government open-data feeds all still arrive as XML. The clients consuming them — React front ends, mobile apps, serverless functions, analytics warehouses — all expect JSON. Converting XML to JSON is the seam between those two worlds, and it is usually where an integration project actually begins.

XML to JSON Converter Pro parses your document with the browser's own XML parser and emits JSON using a mapping that is written out in full on this page. Paste a SOAP envelope, an RSS channel, an `AndroidManifest.xml`, or a regulatory data feed and read the JSON immediately, with no upload and no signup.

How to Convert XML to JSON Online

1. Paste or Upload XML: Paste your document into the left editor, or drop an `.xml` file onto it. The status bar reports Valid XML, or Invalid XML with the parser's own reason for rejecting it.
2. Read the JSON: The output panel re-converts as you type and renders the result as syntax-highlighted JSON.
3. Pick Your Indentation: The toolbar's indent control (2, 3, or 4 spaces, or tabs) applies to the emitted JSON.
4. Copy or Download: Click Copy for the clipboard, or Download to save the result as `converted.json`.

How This Converter Maps XML to JSON

XML and JSON are not isomorphic, so every XML-to-JSON tool has to invent a convention — and the conventions differ between tools. These are the exact rules this converter applies:

When an XML document is converted to JSON, the converter has to settle four things the two formats disagree about. XML attributes have no JSON equivalent, so each attribute becomes a key prefixed with `@`: `<book id="bk101">` yields `"@id": "bk101"`. XML has no array type, so repeated sibling elements sharing a tag name collapse into a JSON array, while a tag appearing once stays a single object. XML text can sit alongside attributes and child elements, so an element carrying both puts its text under a `#text` key, while an element holding nothing but text becomes a plain JSON string. Finally, XML is untyped: `<year>1999</year>` is character data, not a number, so every value arrives in JSON as a string. Learn those four rules and you can predict the exact output for any well-formed document, without trial and error.

Worked Example: An Attribute, Repeated Siblings, and an Empty Tag

Input XML:

<?xml version="1.0" encoding="UTF-8"?>
<catalog updated="2026-04-18">
  <book id="bk101" available="true">
    <title>The Pragmatic Programmer</title>
    <price currency="USD">39.95</price>
  </book>
  <book id="bk102" available="false">
    <title>Refactoring</title>
    <price currency="USD">54.99</price>
  </book>
  <notes/>
</catalog>

Produced JSON:

{
  "catalog": {
    "@updated": "2026-04-18",
    "book": [
      {
        "@id": "bk101",
        "@available": "true",
        "title": "The Pragmatic Programmer",
        "price": {
          "@currency": "USD",
          "#text": "39.95"
        }
      },
      {
        "@id": "bk102",
        "@available": "false",
        "title": "Refactoring",
        "price": {
          "@currency": "USD",
          "#text": "54.99"
        }
      }
    ],
    "notes": null
  }
}

Five conventions are visible at once here. The root tag became the single top-level key. The `updated` attribute became `@updated`. The two `<book>` siblings became an array, while `<title>` — which appears once inside each book — stayed a plain string. `<price>` carried both an attribute and text, so its text moved to `#text`. The self-closing `<notes/>` became `null`, and the XML declaration was dropped as a processing instruction.

Key Technical Capabilities

The Mapping Rules Are Documented, Not Guesswork

The single most important thing to know about an XML-to-JSON converter is its convention, because there is no standard one. Does an attribute become `@id`, `_id`, or a nested `attributes` object? Does a lone `<item>` come back as an array or an object? Does `<count>7</count>` become `7` or `"7"`? Many free online converters simply show you a result and let you reverse-engineer the answers from whatever sample you happened to paste — which is how integrations end up with a bug that only appears once a feed drops from two items to one. The table and worked example above exist so you never have to guess, and the exact conversion source is public.

The privacy story is equally concrete. XML shows up in the highest-stakes corners of an enterprise — payment messages, patient records, internal SOAP contracts, signed configuration — and those are exactly the documents you should not be posting to an unknown backend just to reshape them. Here the document is parsed by your own browser inside the page — the same parse your browser performs on any XML resource — so it never crosses the network to be converted, and the wider app's JSON work (formatting, validation, statistics) is offloaded to a Web Worker rather than a backend. Rather than asking you to trust that, the whole project is open source — read the converter yourself in the GitHub repository, or self-host it.

Two honest limitations are worth repeating, because a converter that hides them is worse than one that states them. First, values are never type-inferred: everything is a string, which is safe for account numbers and identifiers but means you cast on your side. Second, single-occurrence elements are objects rather than one-element arrays — a consequence of XML's own ambiguity, not a bug you can configure away, so defensive code should normalize before iterating.

What to Do With the JSON Next

Once the feed is JSON, the rest of the toolchain opens up. Feed a converted payload into the JSON to TypeScript generator to get interfaces for the client that consumes it, or into the JSON Schema generator to write a contract test against the feed's shape before it changes under you. If you need to inspect or reformat a large converted document, the JSON formatter and tree viewer handles it. And when you have to send data back the other way — replying to a SOAP endpoint or regenerating a config file — the JSON to XML converter is the inverse direction of this page.

Legacy integrations rarely arrive in one format, either. The same input pane also accepts other sources: use the YAML to JSON converter for pipeline and Kubernetes configuration, or the CSV to JSON converter for the flat exports that so often accompany an XML feed.