Reading and Writing XML in Node.js

While JSON dominates modern web development, XML remains critical for enterprise integrations. From SOAP web services to configuration files and legacy system connectivity, Node.js provides powerful tools for handling XML data efficiently. This guide covers reading, writing, validating, and optimizing XML processing in Node.js applications.

Whether you're building API integrations with enterprise systems or processing configuration files, understanding XML handling is essential for full-stack developers working in business environments.

Why XML Still Matters in Modern Web Development

Despite JSON's popularity, XML remains essential in numerous enterprise scenarios:

• Legacy System Integration: Enterprise ERP systems, banking platforms, and healthcare systems often communicate exclusively via XML
• SOAP Web Services: Many organizations still maintain SOAP-based APIs for critical business operations
• Configuration Files: Tools like Maven, Android, and enterprise frameworks use XML for configuration
• Document Standards: Office Open XML, SVG, and various industry-specific formats rely on XML structure

The modern developer frequently encounters XML when integrating with established enterprise infrastructure, even when their preferred data format is JSON. As noted by Geshan in their comprehensive Node.js XML guide, "XML parsing and creation is still a required skill for many Node.js developers working in enterprise environments."

Popular XML Parsing Libraries for Node.js

Node.js offers several libraries for XML processing, each with distinct advantages:

fast-xml-parser (6M+ weekly downloads)

The most popular choice, offering excellent performance and extensive configuration options:

• Supports XML validation, parsing, and building
• Configurable attribute handling and namespace support
• Significantly faster than traditional libraries
• Actively maintained with regular updates

xml2js

A traditional choice with simpler API:

• Easy to get started with basic use cases
• Less configurable than fast-xml-parser
• Slower performance on larger documents
• Last major update several years ago

tXml (~1.5KB)

For extreme performance scenarios:

• 5-10x faster than sax/xml2js
• 2-3x faster than fast-xml-parser
• Zero dependencies, minimal footprint
• Best for large-scale processing

According to NPM Trends, fast-xml-parser maintains its position as the most downloaded XML parsing library for Node.js, reflecting its balance of features and performance.

When working with TypeScript, these libraries integrate well with TypeScript type definitions for type-safe XML processing.

Generating XML from JavaScript Objects

The XMLBuilder class reverses the process, converting JavaScript objects into XML:

import { XMLBuilder } from 'fast-xml-parser';

const xmlBuilder = new XMLBuilder({
 format: true,
 ignoreAttributes: false,
 attributeNamePrefix: "@_"
});

const bookData = {
 catalog: {
 book: [
 {
 "@_id": "bk101",
 author: "Gambardella, Matthew",
 title: "XML Developer's Guide",
 genre: "Computer",
 price: "44.95"
 },
 {
 "@_id": "bk102",
 author: "Ralls, Kim",
 title: "Midnight Rain",
 genre: "Fantasy",
 price: "5.95"
 }
 ]
 }
};

const xmlOutput = xmlBuilder.build(bookData);
console.log(xmlOutput);

Formatting Options:

• format: true: Adds proper indentation
• attributeNamePrefix: Controls attribute naming
• suppressEmptyNode: Omits empty elements

XML Validation Techniques

Validating XML before processing prevents downstream errors and security issues:

import { XMLValidator } from 'fast-xml-parser';

const xmlData = `<?xml version="1.0"?>
<catalog>
 <book>
 <author>Gambardella, Matthew</author>
 </book>
</catalog>`;

const result = XMLValidator.validate(xmlData);
if (result === true) {
 console.log('✓ XML is valid');
} else {
 console.log('✗ Validation error:', result.err.msg);
 console.log(' Line:', result.err.line, 'Column:', result.err.col);
}

Validation catches:

• Malformed tag structure
• Missing closing elements
• Invalid XML declarations
• Character encoding issues

Always validate XML input from external sources before processing to catch structural problems early and prevent cascading errors in your application.

Performance Optimization Strategies

Handling Large XML Files

For files exceeding available memory, use streaming approaches or consider the tXml library, which is 5-10x faster than sax/xml2js with a minimal ~1.5KB footprint.

Performance Comparison

Optimization Tips:

• Reuse parser instances for batch processing
• Disable unnecessary features (attributes, entities)
• Set memory limits for untrusted input
• Use streaming for files over 10MB
• Consider tXml for extreme performance requirements with large datasets

Security Best Practices

XML External Entity (XXE) Attacks

XXE attacks exploit XML parsers to access sensitive files or perform denial-of-service attacks. This is a critical consideration when building secure web applications:

// Secure parsing configuration
const secureParser = new XMLParser({
 processEntities: false, // Disable entity processing
 stopNodes: ["!doctype"], // Ignore DOCTYPE declarations
 trimValues: true, // Clean input
 ignoreAttributes: true // If not needed
});

Security Checklist:

• Never parse untrusted XML without safeguards
• Disable external entity resolution
• Set input size limits
• Validate against expected schema
• Log parsing errors for monitoring

Input Sanitization

// Limit file size to prevent DoS
const MAX_SIZE = 10 * 1024 * 1024; // 10MB
const stats = fs.statSync(filePath);
if (stats.size > MAX_SIZE) {
 throw new Error('File too large');
}

Implementing these security measures is essential when processing XML from untrusted sources, particularly in API integrations that accept external data.

Real-World Use Cases

SOAP Web Service Integration

// Sending XML payloads to SOAP endpoints
const soapPayload = xmlBuilder.build({
 'soap:Envelope': {
 'soap:Body': {
 GetProduct: {
 ProductId: '12345'
 }
 }
 }
});

// Response parsing
const response = await fetch(soapEndpoint, {
 method: 'POST',
 body: soapPayload,
 headers: { 'Content-Type': 'text/xml' }
});
const result = xmlParser.parse(await response.text());

Configuration File Processing

// Reading Maven pom.xml for build configuration
const pomData = xmlParser.parse(
 readFileSync('./pom.xml', 'utf8')
);
const dependencies = pomData.project.dependencies.dependency;

Data Transformation Pipeline

// XML to JSON conversion for modern APIs
app.post('/api/convert/xml-to-json', async (req, res) => {
 const xml = await req.text();
 const json = xmlParser.parse(xml);
 res.json(json);
});

These patterns are common in enterprise application development, where XML remains the standard for system-to-system communication despite the rise of JSON for modern APIs.

Conclusion

XML processing remains a critical skill for Node.js developers working in enterprise environments. The fast-xml-parser library has emerged as the standard choice, offering the best balance of performance, features, and maintainability.

Key Takeaways:

• XML is essential for enterprise integrations, SOAP services, and legacy systems
• fast-xml-parser (6M+ weekly downloads) is the recommended library for most use cases
• Always validate XML before processing to catch structural issues
• Configure secure parsing to prevent XXE attacks
• Choose tXml for extreme performance needs with large files
• Consider streaming approaches for files exceeding available memory

Whether you're integrating with legacy ERP systems, processing configuration files, or building SOAP API clients, Node.js provides robust tools for efficient XML handling.

Need help with XML integration or enterprise development? Our team specializes in building modern web applications with robust enterprise integration capabilities.

Sources

1. DEV Community: NodeJS Fundamentals: XML - Comprehensive coverage of XML parsing in JavaScript, security considerations, and performance optimization
2. LogRocket: Reading and writing XML in Node.js - Detailed comparison of npm packages with code examples
3. Geshan: A beginner's guide to parse and create XML with Node.js - Step-by-step tutorial with fast-xml-parser
4. NPM Trends: fast-xml-parser vs xml2js - Performance benchmarks and download statistics
5. MDN: DOMParser - Browser API documentation for native XML parsing
6. npm: fast-xml-parser - Official package documentation
7. GitHub: tXml - Ultra-fast lightweight XML parser