XML to JSON Conversion: A Developer's Guide

XML and JSON are the two most popular data interchange formats in modern development. Whether you're working with legacy systems, SOAP APIs, or modern REST services, understanding how to convert between these formats is essential.

XML vs JSON: Key Differences

Example Comparison

XML:

<users>
    <user id="1" active="true">
        <name>John Doe</name>
        <email>john@example.com</email>
        <roles>
            <role>admin</role>
            <role>user</role>
        </roles>
    </user>
</users>

JSON:

{
    "users": [{
        "id": 1,
        "active": true,
        "name": "John Doe",
        "email": "john@example.com",
        "roles": ["admin", "user"]
    }]
}

When to Use Each Format

Use XML When:

• Working with SOAP web services
• Document markup is needed (like XHTML)
• Complex schema validation is required
• You need attributes and namespaces
• Integrating with legacy enterprise systems
• Using XSLT transformations

Use JSON When:

• Building REST APIs
• JavaScript/web applications
• Mobile app development
• Configuration files
• Data storage (NoSQL databases)
• Performance and bandwidth matter

Conversion Challenges

Attributes

XML attributes don't have a direct JSON equivalent. Common solutions:

// XML: <user id="1">John</user>

// Option 1: Prefix with @
{"user": {"@id": 1, "#text": "John"}}

// Option 2: Separate attributes object
{"user": {"_attributes": {"id": 1}, "_text": "John"}}

// Option 3: Flatten (simpler but loses structure)
{"user_id": 1, "user": "John"}

Mixed Content

XML can mix text with elements, JSON cannot:

// XML
<p>Hello <b>World</b>!</p>

// Possible JSON representation
{"p": ["Hello ", {"b": "World"}, "!"]}

Arrays vs Single Elements

In XML, a single element looks the same as one item in a collection:

// These look identical in XML:
<items><item>A</item></items>

// But in JSON, you must decide:
{"items": {"item": "A"}}     // object
{"items": {"item": ["A"]}}   // array with one element

Conversion Strategies

XML to JSON

1. Badgerfish: Preserves all XML information including attributes
2. Parker: Simplest mapping, ignores attributes
3. GData: Google's convention for attributes
4. Custom: Define your own rules for your use case

JSON to XML

Converting back requires decisions about:

• Root element name
• Array element naming
• Handling special characters
• Namespace prefixes

Using Our XML Converter

Our XML Converter makes transformations easy:

1. Paste your XML or JSON content
2. Select the conversion direction
3. Choose conversion options (attribute handling, arrays)
4. Click Convert to transform your data
5. Copy or download the result

Code Examples

JavaScript

// Using xml2js library
const xml2js = require('xml2js');

// XML to JSON
const parser = new xml2js.Parser();
parser.parseString(xmlString, (err, result) => {
    console.log(JSON.stringify(result, null, 2));
});

// JSON to XML
const builder = new xml2js.Builder();
const xml = builder.buildObject(jsonObject);

Python

import xmltodict
import json

# XML to JSON
with open('data.xml') as f:
    data = xmltodict.parse(f.read())
    json_data = json.dumps(data, indent=2)

# JSON to XML
xml_data = xmltodict.unparse(json.loads(json_string))

PHP

// XML to JSON
$xml = simplexml_load_string($xmlString);
$json = json_encode($xml);

// JSON to XML (using custom function or library)
function array_to_xml($data, &$xml) {
    foreach($data as $key => $value) {
        if(is_array($value)) {
            $subnode = $xml->addChild($key);
            array_to_xml($value, $subnode);
        } else {
            $xml->addChild($key, htmlspecialchars($value));
        }
    }
}

Best Practices

For Conversions

1. Validate first: Ensure your source format is valid before converting
2. Document your convention: Especially for attribute handling
3. Test round-trips: Convert back and forth to verify data integrity
4. Handle edge cases: Empty elements, CDATA sections, special characters

API Design

• Offer both formats if you need to support legacy systems
• Use content negotiation (Accept header) for format selection
• Document differences between XML and JSON representations

Conclusion

Understanding the differences between XML and JSON, and knowing how to convert between them, is a valuable skill for any developer. Use our XML Converter for quick transformations, and choose the right format based on your specific requirements.