XML to JSON Converter: Transform XML Data to JSON

<!-- XML: one item vs many items -->
<cart>
  <item>Laptop</item>          <!-- single item -->
</cart>

<cart>
  <item>Laptop</item>          <!-- multiple items -->
  <item>Mouse</item>
</cart>

// xml2js default output — structure changes!
// Single item → object:
{ cart: { item: "Laptop" } }

// Multiple items → array:
{ cart: { item: ["Laptop", "Mouse"] } }

// Your downstream code that worked for one item:
cart.item.toUpperCase()  // works when item is a string
cart.item.toUpperCase()  // TypeError: cart.item.toUpperCase is not a function
                         // when item becomes an array

// xml2js: explicitArray: true forces all values to arrays
const xml2js = require('xml2js')
const parser = new xml2js.Parser({ explicitArray: true })

// Result is always an array — consistent regardless of child count:
{ cart: { item: ["Laptop"] } }         // one item
{ cart: { item: ["Laptop", "Mouse"] } } // two items

// fast-xml-parser: isArray callback for targeted forcing
const { XMLParser } = require('fast-xml-parser')
const parser = new XMLParser({
  isArray: (tagName) => ['item', 'product', 'order'].includes(tagName),
  ignoreAttributes: false,
  attributeNamePrefix: '@_',
})

<!-- XML: element with attributes AND text content -->
<price currency="USD" vat="false">19.99</price>

<!-- The challenge: currency and vat are attributes; 19.99 is the element value.
     JSON has no "element + attributes" concept. -->

// Approach 1: @-prefix for attributes, #text for text content
{
  "price": {
    "@currency": "USD",
    "@vat": "false",
    "#text": "19.99"
  }
}

// Approach 2: Flat merge (loses attribute/element distinction)
{
  "price": {
    "currency": "USD",
    "vat": "false",
    "_value": "19.99"
  }
}

// Approach 3: Discard attributes (most lossy but simplest)
{ "price": "19.99" }

<!-- SOAP envelope with namespaces -->
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"
               xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <soap:Body>
    <GetOrderResponse xmlns="http://example.com/orders">
      <Order>
        <xsi:type>StandardOrder</xsi:type>
        <orderId>12345</orderId>
      </Order>
    </GetOrderResponse>
  </soap:Body>
</soap:Envelope>

// If you strip namespace prefixes:
{
  "Envelope": {
    "Body": {
      "GetOrderResponse": {
        "Order": { "type": "StandardOrder", "orderId": "12345" }
      }
    }
  }
}
// Problem: if another namespace uses a "type" element, it collides with xsi:type

// If you preserve namespace prefixes as keys:
{
  "soap:Envelope": {
    "soap:Body": {
      "GetOrderResponse": {
        "Order": { "xsi:type": "StandardOrder", "orderId": "12345" }
      }
    }
  }
}
// Problem: colon in JSON key requires bracket notation: obj["soap:Envelope"]
//          Most languages handle this, but it's awkward

# pip install xmltodict
import xmltodict
import json

def xml_to_json(xml_string: str, indent: int = 2) -> str:
    """Convert XML string to JSON string using xmltodict."""
    # force_list ensures elements always become lists, not dicts
    # when there's only one child — prevents the inconsistency bug
    force_list = ('item', 'product', 'order', 'entry', 'record')

    data = xmltodict.parse(
        xml_string,
        force_list=force_list,
        attr_prefix='@',    # attributes prefixed with @
        cdata_key='#text',  # text content stored under #text key
    )
    return json.dumps(data, indent=indent, ensure_ascii=False)

# Example: Parse an RSS feed
rss_xml = """
<rss version="2.0">
  <channel>
    <title>My Blog</title>
    <item>
      <title>First Post</title>
      <link>https://example.com/post/1</link>
      <pubDate>Mon, 21 Apr 2026 10:00:00 GMT</pubDate>
    </item>
    <item>
      <title>Second Post</title>
      <link>https://example.com/post/2</link>
      <pubDate>Tue, 22 Apr 2026 10:00:00 GMT</pubDate>
    </item>
  </channel>
</rss>
"""

json_output = xml_to_json(rss_xml)
data = json.loads(json_output)

# Access feed items safely:
items = data['rss']['channel']['item']  # always a list (due to force_list)
for item in items:
    print(item['title'], item['link'])

# Convert from file:
with open('feed.xml', 'rb') as f:
    data = xmltodict.parse(f)
json_output = json.dumps(data, indent=2)

# Reverse: JSON dict back to XML
xml_output = xmltodict.unparse(data, pretty=True, indent='  ')

import xml.etree.ElementTree as ET
import json

def parse_soap_order(xml_string: str) -> dict:
    """Parse a SOAP GetOrderResponse without generic conversion."""
    ns = {
        'soap': 'http://schemas.xmlsoap.org/soap/envelope/',
        'orders': 'http://example.com/orders'
    }
    root = ET.fromstring(xml_string)

    # Navigate with explicit namespace awareness
    body = root.find('soap:Body', ns)
    response = body.find('orders:GetOrderResponse', ns)
    order = response.find('orders:Order', ns)

    return {
        'orderId': order.findtext('orders:orderId', namespaces=ns),
        'status': order.findtext('orders:status', namespaces=ns),
        'amount': float(order.findtext('orders:amount', namespaces=ns, default='0')),
    }

// npm install fast-xml-parser
import { XMLParser, XMLBuilder, XMLValidator } from 'fast-xml-parser'

// Validate before parsing
const isValid = XMLValidator.validate(xmlString)
if (isValid !== true) {
  throw new Error(`Invalid XML: ${isValid.err.msg} at line ${isValid.err.line}`)
}

const parser = new XMLParser({
  ignoreAttributes: false,        // preserve attributes
  attributeNamePrefix: '@_',      // prefix attributes with @_
  allowBooleanAttributes: true,
  parseAttributeValue: true,      // parse "123" attribute values as numbers
  parseTagValue: true,            // parse element text as numbers/booleans where appropriate

  // Force specific tags to always be arrays — critical for stability
  isArray: (tagName: string) =>
    ['item', 'product', 'entry', 'record', 'row'].includes(tagName),
})

const result = parser.parse(xmlString)
const json = JSON.stringify(result, null, 2)

// xml2js (older, slower, but widely used in legacy code):
import xml2js from 'xml2js'
const parser2 = new xml2js.Parser({
  explicitArray: true,   // always arrays — avoids the one-child bug
  mergeAttrs: false,     // keep attributes separate from element values
  attrkey: '@',          // attribute key prefix
  charkey: '#text',      // text content key
  explicitCharkey: true, // always include #text even when no attributes
})
const result2 = await parser2.parseStringPromise(xmlString)

// Streaming for large XML files (SAX-based):
import { createReadStream } from 'fs'
import { SAXParser } from 'sax'

const saxStream = createReadStream('large-data.xml')
const sax = new SAXParser(true, {})  // strict mode

sax.onopentag = (node) => { /* handle element start */ }
sax.ontext = (text) => { /* handle text content */ }
sax.onclosetag = (name) => { /* handle element end */ }

saxStream.pipe(sax)

package main

import (
    "encoding/json"
    "encoding/xml"
    "fmt"
    "strings"
)

// Define structs matching the XML structure
type RSSFeed struct {
    XMLName xml.Name   `xml:"rss" json:"-"`
    Version string     `xml:"version,attr" json:"version"`
    Channel Channel    `xml:"channel" json:"channel"`
}

type Channel struct {
    Title       string   `xml:"title" json:"title"`
    Link        string   `xml:"link" json:"link"`
    Description string   `xml:"description" json:"description"`
    Items       []Item   `xml:"item" json:"items"`
}

type Item struct {
    Title       string   `xml:"title" json:"title"`
    Link        string   `xml:"link" json:"link"`
    Description string   `xml:"description" json:"description"`
    PubDate     string   `xml:"pubDate" json:"pubDate"`
    GUID        string   `xml:"guid" json:"guid"`
}

func ConvertRSSToJSON(xmlData string) (string, error) {
    var feed RSSFeed
    if err := xml.NewDecoder(strings.NewReader(xmlData)).Decode(&feed); err != nil {
        return "", fmt.Errorf("xml decode: %w", err)
    }

    jsonData, err := json.MarshalIndent(feed, "", "  ")
    if err != nil {
        return "", fmt.Errorf("json marshal: %w", err)
    }
    return string(jsonData), nil
}

// Generic approach using xml.Token for unknown XML:
func GenericXMLToJSON(xmlData string) (map[string]interface{}, error) {
    decoder := xml.NewDecoder(strings.NewReader(xmlData))
    // Note: generic XML-to-map conversion in Go requires building
    // a recursive decoder — use the etree or xmlquery library for this:
    // go get github.com/beevik/etree
    // go get github.com/antchfx/xmlquery
    return nil, nil  // implement with etree/xmlquery for production
}

# Fetch and convert an RSS feed to JSON
import feedparser  # pip install feedparser
import json

# feedparser handles both RSS and Atom, normalizes the output
feed = feedparser.parse('https://example.com/feed.xml')

# feedparser already gives you a dict — just serialize to JSON
articles = [
    {
        'title': entry.title,
        'link': entry.link,
        'published': entry.published,
        'summary': entry.summary,
        'author': getattr(entry, 'author', None),
    }
    for entry in feed.entries
]

print(json.dumps(articles, indent=2))

// Express REST endpoint wrapping a SOAP service
import express from 'express'
import axios from 'axios'
import { XMLParser } from 'fast-xml-parser'

const router = express.Router()
const xmlParser = new XMLParser({
  ignoreAttributes: false,
  attributeNamePrefix: '@_',
  isArray: (tagName) => ['Order', 'LineItem'].includes(tagName),
})

router.get('/orders/:id', async (req, res) => {
  const soapEnvelope = `
    <?xml version="1.0" encoding="UTF-8"?>
    <soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
      <soap:Body>
        <GetOrder xmlns="http://example.com/orders">
          <OrderId>${req.params.id}</OrderId>
        </GetOrder>
      </soap:Body>
    </soap:Envelope>
  `

  const soapResponse = await axios.post(process.env.SOAP_ENDPOINT!, soapEnvelope, {
    headers: { 'Content-Type': 'text/xml; charset=utf-8', 'SOAPAction': 'GetOrder' },
  })

  const parsed = xmlParser.parse(soapResponse.data)

  // Navigate to the response body, stripping SOAP envelope
  const order = parsed?.['soap:Envelope']?.['soap:Body']?.GetOrderResponse?.Order

  if (!order) {
    return res.status(404).json({ error: 'Order not found' })
  }

  // Return clean JSON, not raw XML structure
  res.json({
    id: order.OrderId,
    status: order.Status,
    total: parseFloat(order.Total),
    createdAt: order.CreatedDate,
    items: (order.LineItem || []).map((item: any) => ({
      sku: item.SKU,
      quantity: parseInt(item.Quantity),
      unitPrice: parseFloat(item.UnitPrice),
    }))
  })
})