JSON and XML are both widely-used data formats. Understanding their strengths and weaknesses helps you choose the right format for each situation.

Quick Comparison

Syntax Comparison

JSON

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

XML

<?xml version="1.0" encoding="UTF-8"?>
<user id="123">
  <name>John Doe</name>
  <email>john@example.com</email>
  <roles>
    <role>admin</role>
    <role>editor</role>
  </roles>
  <active>true</active>
</user>

When to Use JSON

APIs and Web Services

JSON is the standard for modern web APIs:

// REST API response
{
  "status": "success",
  "data": {
    "users": [...],
    "pagination": {...}
  }
}

// GraphQL responses
{
  "data": {
    "user": {
      "name": "John",
      "posts": [...]
    }
  }
}

Configuration Files

JSON works well for configs:

{
  "app": {
    "name": "MyApp",
    "version": "1.0.0",
    "database": {
      "host": "localhost",
      "port": 5432
    },
    "features": {
      "darkMode": true,
      "beta": false
    }
  }
}

Data Exchange

For structured data transfer:

{
  "event": "user.created",
  "timestamp": "2026-01-30T10:00:00Z",
  "data": {
    "userId": 123,
    "email": "user@example.com"
  }
}

When to Use XML

Document Publishing

XML excels for documents:

<book>
  <title>Introduction to XML</title>
  <author>
    <firstName>Jane</firstName>
    <lastName>Smith</lastName>
  </author>
  <chapters>
    <chapter number="1">Getting Started</chapter>
    <chapter number="2">Advanced Topics</chapter>
  </chapters>
</book>

Enterprise Integration

XML is common in enterprise systems:

<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
  <soap:Body>
    <GetCustomerRequest xmlns="http://example.com/customers">
      <CustomerId>12345</CustomerId>
    </GetCustomerRequest>
  </soap:Body>
</soap:Envelope>

Complex Metadata

For rich metadata:

<metadata>
  <dc:title xmlns:dc="http://purl.org/dc/elements/1.1/">
    The Art of JSON
  </dc:title>
  <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">
    John Doe
  </dc:creator>
  <dc:format xmlns:dc="http://purl.org/dc/elements/1.1/">
    application/json
  </dc:format>
</metadata>

Schema Comparison

JSON Schema

{
  "type": "object",
  "properties": {
    "name": { "type": "string" },
    "age": { "type": "integer", "minimum": 0 }
  },
  "required": ["name"]
}

XSD (XML Schema)

<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:element name="user">
    <xs:complexType>
      <xs:sequence>
        <xs:element name="name" type="xs:string"/>
        <xs:element name="age" type="xs:positiveInteger" minOccurs="0"/>
      </xs:sequence>
      <xs:attribute name="id" type="xs:positiveInteger" use="required"/>
    </xs:complexType>
  </xs:element>
</xs:schema>

Performance Comparison

Parsing Speed

JSON parsing is typically 2-5x faster than XML parsing.

Payload Size

JSON is typically 20-50% smaller than equivalent XML.

Conversion Between Formats

JSON to XML

function jsonToXml(obj, root = 'root') {
  const toXml = (value, name) => {
    if (typeof value === 'object') {
      return Object.entries(value)
        .map(([k, v]) => toXml(v, k))
        .join('');
    }
    return `<${name}>${value}</${name}>`;
  };
  
  return `<${root}>${toXml(obj, root)}</${root}>`;
}

XML to JSON

function xmlToJson(xml) {
  const parser = new DOMParser();
  const doc = parser.parseFromString(xml, 'text/xml');
  
  function parse(node) {
    const obj = {};
    
    if (node.attributes) {
      for (const attr of node.attributes) {
        obj[`@${attr.name}`] = attr.value;
      }
    }
    
    for (const child of node.children) {
      const childObj = parse(child);
      const tagName = child.tagName;
      
      if (obj[tagName]) {
        if (!Array.isArray(obj[tagName])) {
          obj[tagName] = [obj[tagName]];
        }
        obj[tagName].push(childObj);
      } else {
        obj[tagName] = childObj;
      }
    }
    
    if (Object.keys(obj).length === 0) {
      return node.textContent;
    }
    
    return obj;
  }
  
  return parse(doc.documentElement);
}

Summary

Choose JSON for most modern web applications. Use XML when you need document features, strong namespaces, or are working with XML-native enterprise systems.