XML to JSON Converter

XML and JSON describe data with different building blocks, so every converter has to make choices, and two tools will often disagree on the same input. The main mismatches are:

• Attributes versus elements. <price currency="USD"> carries data in two places. JSON has only keys, so attributes need a marker that keeps them apart from child elements with the same name.
• Order. XML element order is significant; JSON object keys are officially unordered. Interleaved siblings such as <a/><b/><a/> end up as one a array and one b key, so the original sequence is lost.
• Mixed content. In <p>Hello <b>world</b>!</p> the text and the element are interleaved. JSON has no natural way to say where the <b> sat inside the sentence.
• Arrays of one. This is the classic bug. A converter only sees an array when an element repeats, so an order with two <item> children produces "item": [ ... ], but an order with one item produces "item": { ... }. Code that does order.item.forEach(...) works in testing and then fails in production on the first single-item order.

The fix for the last one is to tell the converter which elements are lists. Type the tag names into Force arrays, separated by commas, and they are always emitted as arrays, even with one child. If you consume the JSON in code, do this for every element your schema allows to repeat.

Put together, a small document converts like this:

<order id="A-1">
  <item sku="KB-01">Keyboard</item>
  <item sku="MS-07">Mouse</item>
  <note>Leave at door</note>
</order>

{
  "order": {
    "@id": "A-1",
    "item": [
      { "@sku": "KB-01", "#text": "Keyboard" },
      { "@sku": "MS-07", "#text": "Mouse" }
    ],
    "note": "Leave at door"
  }
}

Text inside an element that also has attributes or children goes under #text. With mixed content, the text pieces are joined with a space and their position relative to the child elements is not preserved. If you change the attribute prefix to _ or $, pick the same prefix in the JSON to XML converter and the output converts back to equivalent XML.

XML has no types without a schema: <zip>02134</zip> and <count>42</count> are both just text. Guessing types breaks real data. ZIP codes, account numbers and ISBNs lose their leading zeros, version strings like 1.10 become 1.1, and a 19-digit order ID silently changes because JavaScript numbers only hold integers exactly up to 2⁵³.

When you switch on Numbers & booleans, the converter only changes a value if nothing is lost: 42, -3.25, true and false are converted, while 007, 1.50, 1e3 and 9007199254740993 stay strings. It is a convenience for reading data, not a substitute for a schema.

• SOAP and legacy APIs. Paste a SOAP envelope to see the response as a tree you can query. Untick Keep namespace prefixes to turn soap:Envelope and ns2:getQuoteResponse into plain Envelope and getQuoteResponse; the xmlns declarations are dropped at the same time. Only do this when local names are unique, because two namespaces can use the same local name.
• RSS and Atom feeds. Add item (RSS) or entry (Atom) to Force arrays so a feed with one post has the same shape as a feed with fifty.
• Maven and Android files. pom.xml dependencies and Android strings.xml resources become easy to scan or diff once they are JSON. Use the diff checker to compare two converted versions.
• Entities. XML only predefines &, <, >, " and '. HTML entities such as   fail with "Entity 'nbsp' not defined" unless the document declares them; replace them with numeric references like  .
• Whitespace. With Trim text on, leading and trailing whitespace is removed from every text value. Turn it off when spaces are meaningful, for example in fixed-width fields or preformatted text.
• Common parse errors. "Opening and ending tag mismatch" means a closing tag does not match the open one; "Extra content at the end of the document" means there is more than one root element. To fix indentation or find the broken tag, try the XML formatter.

The parsing rules follow the W3C XML 1.0 specification. Once you have JSON, the JSON viewer is handy for exploring large results.