XML ↔ JSON Converter

How to Convert XML to JSON

Paste XML into the left panel and the JSON appears as you type. Parsing uses your browser's own XML parser — the same one that handles XHTML and SVG — so it validates well-formedness properly and reports the line where a document breaks, rather than accepting something malformed and producing quiet nonsense.

Everything runs locally. Your document is never uploaded, logged, or sent to a server, which matters because the XML developers most often need to convert is a SOAP response or a partner feed containing credentials, order records, or personal data.

The Mapping Convention

XML and JSON do not describe the same shape of data, so every converter has to invent a convention. This one is stated up front and applied without exception:

<book id="bk101">
  <title>XML Guide</title>
  <price>44.95</price>
</book>

{
  "book": {
    "@id": "bk101",
    "title": "XML Guide",
    "price": "44.95"
  }
}

The @ prefix exists because XML has two ways to attach a value to an element and JSON has one. Without it, an attribute named title and a child element named title would collide. The prefix keeps them distinct and makes the conversion reversible — switch to JSON → XML and any key beginning with @ becomes an attribute again.

Three Things That Make XML to JSON Genuinely Hard

Namespaces

Namespace-qualified tags keep their prefix exactly as written: <soap:Envelope> becomes the key "soap:Envelope", and the declaration itself survives as the attribute key "@xmlns:soap". Nothing is resolved or rewritten, so a round trip through JSON and back produces a document with the same prefixes it started with.

This is the pragmatic choice rather than the theoretically correct one. Namespace prefixes are arbitrary labels — two documents using soap: and s: for the same namespace URI are equivalent to a validating parser but produce different JSON keys here. If you are consuming feeds from multiple vendors, match on the local name rather than the full prefixed key.

Converting JSON to XML

Switch direction and the convention runs backwards: @ keys become attributes, #text becomes the element's text content, arrays become repeated tags, and null becomes a self-closing element. Output is indented two spaces and carries an XML declaration.

A JSON object with exactly one top-level key uses that key as the root element, since XML permits exactly one. Several top-level keys are wrapped in a <root> element instead, because there is no other legal option.

Element names are validated rather than silently repaired. XML names cannot contain spaces and must begin with a letter or underscore, so a key like "first name" is reported as an error instead of being quietly rewritten to first_name — a rename would produce a document that no longer matches the schema it was headed for, and you would find out much later.

Escaping is handled for you, and only where the specification requires it: &, <, and > are escaped in element text, and attribute values additionally escape the double quote that would otherwise close them. A quote or apostrophe sitting in ordinary text is left alone, because escaping it would be noise rather than correctness. A document converted to JSON and straight back comes out byte-for-byte identical, entities included.

Why This Conversion Still Comes Up

XML was declared legacy years ago and remains everywhere it was already installed. Three cases account for most conversions.

SOAP and enterprise APIs. Banking, insurance, logistics, government, and healthcare integrations are overwhelmingly SOAP, and they are not being rewritten. Converting the envelope to JSON at the edge lets the rest of your codebase work in one format. The credentials in those envelopes are exactly why a converter that uploads your payload is the wrong tool.

RSS, Atom, and sitemaps. Feed formats are XML by specification. Anything that ingests feeds — readers, aggregators, monitoring — converts them on the way in.

Configuration in older toolchains. Maven pom.xml, Android manifests, .NET web.config, and Ant build files are XML. Converting to JSON makes them scriptable with ordinary tooling; if you are migrating that config to a modern format, our YAML ↔ JSON converter is the second half of the trip, since most current toolchains expect YAML.

Checking the Result

XML documents nest far more deeply than most JSON, and a converted SOAP response frequently arrives six or seven levels down inside envelope and body wrappers. Paste the output into our JSON formatter and validator — its depth and key counts tell you immediately whether you are looking at the payload or at the envelope wrapped around it. If the result is a list of records headed for a spreadsheet, JSON ↔ CSV will flatten it into columns.

Frequently Asked Questions