XML to JSON Converter

XML to JSON & JSON to XML Converter - Free Online Bidirectional Tool

This free XML to JSON converter instantly transforms data between XML and JSON formats in both directions - paste XML and get clean JSON, or paste JSON and get well-formed XML. Both formats represent structured data, but they come from different eras and serve different needs: XML (eXtensible Markup Language) is the older, verbose, tag-based format still heavily used in enterprise systems, SOAP web services, RSS feeds, and configuration files, while JSON (JavaScript Object Notation) is the lightweight, compact format that dominates modern REST APIs and web applications. Converting between them is a constant task when integrating legacy XML systems with modern JSON-based applications.

Use this online converter to switch between the two formats without installing software or writing parsing code. The tool handles nested elements, attributes, arrays, text content, and mixed structures, mapping XML's tag hierarchy to JSON's object structure and back again. Simply toggle the direction - XML to JSON or JSON to XML - paste your input, and copy the converted output instantly. Whether you are modernizing a SOAP API response into JSON for a JavaScript front-end, converting a JSON payload into XML for a legacy enterprise system, or parsing an RSS feed, this converter handles it in your browser with no sign-up and no data sent to a server.

How to Use the XML ⇄ JSON Converter

1. Step 1 - Choose Your Conversion Direction

   Select whether you want to convert XML to JSON or JSON to XML using the direction toggle. XML to JSON is the most common direction - developers convert verbose XML responses from older APIs and enterprise systems into the compact JSON format that modern applications and JavaScript expect. JSON to XML is needed when you must send data to a legacy system, SOAP web service, or enterprise application that only accepts XML. The tool defaults to XML to JSON, but you can switch directions at any time and the conversion updates instantly.

2. Step 2 - Paste Your Input Data

   Paste your source data into the input panel on the left. For XML to JSON, paste well-formed XML with its opening and closing tags, attributes, and nested elements. For JSON to XML, paste valid JSON with its braces and brackets. The tool accepts data of any practical size, from a single element to large multi-hundred-line documents like SOAP envelopes or RSS feeds. You can also type or edit directly in the input panel. If your XML is malformed (unclosed tags, mismatched elements) or your JSON has syntax errors, the converter flags the issue so you can correct it.

3. Step 3 - Review the Converted Output

   The converted result appears instantly in the output panel on the right. When converting XML to JSON, the output is properly formatted JSON where XML elements become object keys, nested elements become nested objects, repeated elements become arrays, and XML attributes are typically represented with a special prefix (commonly "@" or "_attributes"). When converting JSON to XML, the output is well-formed XML with proper opening and closing tags and correct nesting. Review the output carefully - XML to JSON conversion involves some structural decisions (especially around attributes and text content) that you should verify match your needs.

4. Step 4 - Copy or Download the Result

   Click the copy button to copy the converted output to your clipboard, ready to paste into your code editor, API client, or application. For larger conversions, use the download option to save the output as a .json or .xml file. The converted data is valid and ready to use - properly formatted JSON for modern applications, or well-formed XML for legacy systems and SOAP services. Because the conversion happens entirely in your browser, your data never leaves your device, making it safe for XML documents containing sensitive business data, internal endpoints, or proprietary schema details.

XML to JSON Conversion Examples

Example 1 - Simple Nested Elements

A basic XML structure showing how nested elements map to a JSON object hierarchy.

<book>
  <title>The Pragmatic Programmer</title>
  <author>Andrew Hunt</author>
  <year>1999</year>
</book>

{
  "book": {
    "title": "The Pragmatic Programmer",
    "author": "Andrew Hunt",
    "year": "1999"
  }
}

Each XML element becomes a key in the JSON object, and the text content becomes the value. Note that XML has no concept of data types - everything is text - so the year "1999" becomes a string in JSON, not a number. This is a key difference from YAML or native JSON, where 1999 would be a number.

Example 2 - XML Attributes

XML attributes have no direct JSON equivalent, so converters use a convention to represent them. This example shows the common "@" prefix approach.

<product id="1042" currency="USD">
  <name>Wireless Mouse</name>
  <price>29.99</price>
</product>

{
  "product": {
    "@id": "1042",
    "@currency": "USD",
    "name": "Wireless Mouse",
    "price": "29.99"
  }
}

The attributes id and currency are converted to keys prefixed with "@" to distinguish them from child elements. Different converters use different conventions (some use "$", "_", or a nested "@attributes" object), so always check how your specific tool or target system expects attributes to be represented.

Example 3 - Repeated Elements Become Arrays

When XML has multiple elements with the same tag name, they convert to a JSON array - a critical and sometimes tricky conversion behavior.

<cart>
  <item>Keyboard</item>
  <item>Monitor</item>
  <item>Webcam</item>
</cart>

{
  "cart": {
    "item": [
      "Keyboard",
      "Monitor",
      "Webcam"
    ]
  }
}

The three repeated <item> elements become a JSON array. Be aware of the "single element ambiguity" problem: if the cart had only one item, most converters produce a single string value rather than an array - which can break code that expects an array. This is the most common XML to JSON conversion pitfall, covered in the tips section below.

Example 4 - JSON to XML (Reverse Direction)

Converting a JSON object into XML - useful for sending data to a SOAP service or legacy enterprise system that requires XML.

{
  "order": {
    "id": 5567,
    "customer": "Acme Corp",
    "items": ["Laptop", "Charger"]
  }
}

<order>
  <id>5567</id>
  <customer>Acme Corp</customer>
  <items>Laptop</items>
  <items>Charger</items>
</order>

The JSON object becomes XML elements, and the JSON array of items becomes repeated <items> elements - the standard XML way of representing a list. Note that JSON's typed values (the number 5567) become plain text in XML, since XML does not distinguish types.

How XML to JSON Conversion Works

XML and JSON both represent hierarchical data, but they use fundamentally different models. XML is a markup language built around elements (tags), attributes, and text content, with no built-in concept of data types or arrays. JSON is a data format built around objects, arrays, and typed values (strings, numbers, booleans, null). Because the models differ, conversion requires mapping decisions - it is not as direct as the YAML-JSON relationship.

The Core Mapping Rules

The Attribute Problem

The biggest structural challenge in XML to JSON conversion is attributes. XML elements can have both attributes and child content, but JSON objects have no equivalent concept. Converters solve this with conventions: attributes are typically prefixed (with "@", "$", or "_") to distinguish them from child elements, and when an element has both attributes and text content, the text is placed under a special key like "#text". There is no single official standard for this mapping, which is why the same XML can produce slightly different JSON depending on the converter. If you are feeding the JSON to a system that expects a specific convention, verify the format matches.

The Type Problem

XML has no data types - every value is text. So when converting XML to JSON, numbers and booleans become strings by default: <count>42</count> becomes "count": "42", not "count": 42. Some converters offer a "type coercion" option that attempts to detect numbers and booleans and convert them to proper JSON types, but this can cause problems (a ZIP code like "01234" might lose its leading zero, or a version "1.0" might become 1). The safest default is to keep everything as strings and let your application cast types where needed.

The Array Ambiguity Problem

XML cannot natively express "this is a list with one item." A single <item> and a list of three <item> elements look structurally similar, differing only in count. So a converter sees one <item> and produces a single value, but sees multiple and produces an array. This inconsistency breaks code that always expects an array. Robust conversion requires either a schema (XSD) that declares which elements are arrays, or a converter setting that forces specified elements to always be arrays regardless of count.

Who Uses an XML ⇄ JSON Converter?

• Developers integrating legacy and modern systems - Engineers connecting older enterprise systems that output XML (SOAP services, ERP systems, banking APIs) with modern JavaScript applications and REST APIs that expect JSON, using the converter to bridge the format gap during integration and testing.
• API developers working with SOAP and REST - Developers who consume SOAP web services (which return XML) but build JSON-based applications, converting SOAP responses to JSON to inspect the data structure and plan their parsing logic before writing code.
• Developers processing RSS and Atom feeds - Engineers building feed readers, content aggregators, or news applications who receive RSS/Atom feeds in XML and convert them to JSON for easier processing in JavaScript and modern frameworks.
• QA engineers and API testers - Testers validating data exchange between systems who convert XML payloads to JSON (and vice versa) to compare structures, verify data integrity across format boundaries, and create test fixtures in whichever format their test framework prefers.
• Data migration and integration specialists - Professionals migrating data from XML-based legacy databases or document stores into modern JSON-based systems (like document databases or web APIs), using the converter to understand and transform the data structure during migration planning.

Common Mistakes When Converting Between XML and JSON

XML vs JSON - Feature Comparison

Understanding how XML and JSON differ clarifies why conversion between them requires mapping decisions and when each format is the right choice. The table below compares the two across the features that matter most in real-world development and integration work.

The bottom line: JSON wins for modern, lightweight data exchange and is the default for new APIs, while XML persists where its richer feature set (attributes, namespaces, schema validation, document markup) and entrenched enterprise tooling are required. Because both formats remain widespread, converting between them is a routine integration task - which is exactly what this bidirectional converter handles.