XML Parsing and Generation in JavaScript Applications
fast-xml-parser, libxmljs, libxmljs2, sax, xml2js, xmlbuilder, and xmldom are npm packages that handle XML processing in JavaScript environments. They fall into two main categories: parsers (which convert XML strings into structured data like JavaScript objects or DOM trees) and builders/generators (which create XML from structured input). Some support both directions, while others specialize in streaming, DOM compliance, or performance. These tools are essential when integrating with legacy systems, SOAP APIs, RSS feeds, or configuration files that rely on XML.
Npm Package Weekly Downloads Trend
Github Stars Ranking
Stat Detail
XML Processing in JavaScript: Parsing, Building, and Streaming Compared
Working with XML in modern JavaScript apps often feels like maintaining legacy integrations—SOAP APIs, enterprise data feeds, or config files—but choosing the right tool makes a big difference. The seven packages here cover parsing, building, and DOM manipulation, each with distinct trade-offs in performance, compatibility, and ease of use. Let’s break them down by real-world engineering concerns.
🧩 Core Capabilities: What Each Package Actually Does
Not all XML libraries do the same thing. First, clarify your need:
- Parsing: Convert XML string → JS object / DOM
- Building: Convert JS object / code → XML string
- DOM: Full document object model with traversal/mutation
- Streaming: Process XML incrementally (low memory)
| Package | Parse | Build | DOM | Stream |
|---|---|---|---|---|
fast-xml-parser | ✅ | ✅ | ❌ | ❌ |
libxmljs | ✅ | ✅ | ✅ | ❌ |
libxmljs2 | ✅ | ✅ | ✅ | ❌ |
sax | ✅ | ❌ | ❌ | ✅ |
xml2js | ✅ | ❌ | ❌ | ❌ |
xmlbuilder | ❌ | ✅ | ❌ | ❌ |
xmldom | ✅ | ❌ | ✅ | ❌ |
⚠️ Deprecation Note:
libxmljsis deprecated. Its npm page states: “This package is no longer maintained. Please use libxmljs2 instead.” Do not use it in new projects.
📥 Parsing XML: Object vs DOM vs Streaming
Object-Based Parsers (fast-xml-parser, xml2js)
These convert XML directly into plain JavaScript objects—ideal for quick data extraction.
fast-xml-parser prioritizes speed and simplicity:
// fast-xml-parser
import { XMLParser } from 'fast-xml-parser';
const parser = new XMLParser();
const result = parser.parse('<book><title>JS Guide</title></book>');
// { book: { title: "JS Guide" } }
xml2js uses a callback/event-based approach but hides SAX complexity:
// xml2js
import { parseString } from 'xml2js';
parseString('<book><title>JS Guide</title></book>', (err, result) => {
// result = { book: { title: ["JS Guide"] } }
});
Note: xml2js wraps values in arrays by default (to handle repeated tags), while fast-xml-parser avoids this unless configured.
DOM Parsers (libxmljs2, xmldom)
These create a tree of node objects, letting you use standard DOM methods.
libxmljs2 (Node.js-only, native binding):
// libxmljs2
import libxmljs from 'libxmljs2';
const doc = libxmljs.parseXml('<book><title>JS Guide</title></book>');
const title = doc.get('//title').text(); // "JS Guide"
xmldom (pure JS, browser-like):
// xmldom
import { DOMParser } from '@xmldom/xmldom';
const parser = new DOMParser();
const doc = parser.parseFromString('<book><title>JS Guide</title></book>', 'text/xml');
const title = doc.getElementsByTagName('title')[0].textContent; // "JS Guide"
Streaming Parser (sax)
For huge files, stream tokens as they arrive:
// sax
import sax from 'sax';
const parser = sax.createStream(true, {});
let currentTag = '';
parser.on('opentag', (node) => { currentTag = node.name; });
parser.on('text', (text) => {
if (currentTag === 'title') console.log(text); // "JS Guide"
});
parser.write('<book><title>JS Guide</title></book>').end();
You manage state manually—great for memory efficiency, poor for developer velocity on small docs.
🏗️ Building XML: Code-Driven vs Template-Driven
Only fast-xml-parser and xmlbuilder generate XML, but differently.
xmlbuilder uses a fluent, method-chaining API:
// xmlbuilder
import { create } from 'xmlbuilder';
const xml = create({ book: { title: 'JS Guide' } }).end({ pretty: true });
// <book>
// <title>JS Guide</title>
// </book>
Or programmatically:
const root = create('book');
root.ele('title').txt('JS Guide');
console.log(root.end());
fast-xml-parser includes a builder that works from JS objects:
// fast-xml-parser builder
import { XMLBuilder } from 'fast-xml-parser';
const builder = new XMLBuilder({ format: true });
const xml = builder.build({ book: { title: 'JS Guide' } });
xmlbuilder offers more control (namespaces, attributes, CDATA), while fast-xml-parser’s builder is simpler but less feature-rich.
🖥️ Environment Compatibility: Browser, Node, Edge
- Browser-safe (pure JS):
fast-xml-parser,sax,xml2js,xmlbuilder,xmldom - Node.js-only (native deps):
libxmljs2(and deprecatedlibxmljs)
If you’re targeting Vercel Edge Functions, Cloudflare Workers, or any non-Node runtime, avoid libxmljs2. All others work anywhere JavaScript runs.
🔍 Advanced Features: XPath, Validation, Namespaces
Need XPath queries? Only libxmljs2 and xmldom support them natively:
// libxmljs2 XPath
const nodes = doc.find('//book[price > 30]');
// xmldom + xpath package (separate install)
import xpath from 'xpath';
const nodes = xpath.select('//book/title', doc);
XSD validation? Only libxmljs2 provides it out of the box.
Namespace handling is best in libxmljs2 and xmlbuilder; others have limited or inconsistent support.
🧪 Error Handling and Robustness
saxandxmldomthrow detailed parse errors for malformed XML.fast-xml-parsercan be configured to ignore or report errors via options.xml2jspasses errors to its callback.libxmljs2throws C-level errors that can crash Node if unhandled—wrap in try/catch.
🔄 Round-Trip Example: Parse → Modify → Serialize
Suppose you need to read an XML config, change a value, and write it back.
With fast-xml-parser (simplest round-trip):
import { XMLParser, XMLBuilder } from 'fast-xml-parser';
const xml = '<config><timeout>30</timeout></config>';
const parser = new XMLParser();
const builder = new XMLBuilder();
let obj = parser.parse(xml);
obj.config.timeout = 60;
const newXml = builder.build(obj);
With xmldom (DOM-style mutation):
import { DOMParser } from '@xmldom/xmldom';
import { XMLSerializer } from '@xmldom/xmldom';
const parser = new DOMParser();
const serializer = new XMLSerializer();
const doc = parser.parseFromString('<config><timeout>30</timeout></config>', 'text/xml');
doc.getElementsByTagName('timeout')[0].textContent = '60';
const newXml = serializer.serializeToString(doc);
The DOM approach is more verbose but mirrors browser XML handling—useful if your team already knows DOM APIs.
📊 When to Use Which: Decision Matrix
| Scenario | Best Choice(s) |
|---|---|
| Quick XML ↔ JSON in browser or Node | fast-xml-parser |
| Generate XML from code with full control | xmlbuilder |
| Parse massive XML files with low memory | sax |
| Need XPath, XSD, or full DOM in Node.js | libxmljs2 |
| Simulate browser XML handling in tests | xmldom |
| Simple one-off parsing (legacy codebases) | xml2js |
| New project requiring native XML features | Never libxmljs (deprecated) |
💡 Final Guidance
Start with fast-xml-parser if you just need to get data in and out of XML quickly—it’s fast, dependency-free, and works everywhere. If you’re generating complex XML documents, pair it with xmlbuilder.
Reach for sax only when file size forces streaming. Use xmldom if you’re writing XML unit tests or need DOM parity. Reserve libxmljs2 for heavy-duty enterprise scenarios where you absolutely need XPath or validation—and accept the native dependency cost.
And remember: never start a new project with libxmljs. Its successor exists for good reason.
How to Choose: xmlbuilder vs fast-xml-parser vs libxmljs vs libxmljs2 vs sax vs xml2js vs xmldom
- xmlbuilder:
Choose
xmlbuilderif your primary need is generating well-formed XML from JavaScript objects or programmatic calls. It provides a fluent API for building XML trees and supports namespaces, CDATA, and pretty printing. It does not parse XML, so pair it with a parser likefast-xml-parserif you need round-trip functionality. - fast-xml-parser:
Choose
fast-xml-parserif you need a fast, pure JavaScript parser that converts XML to JSON without native dependencies. It’s ideal for browser-compatible applications or lightweight Node.js services where bundle size and startup time matter. It supports basic validation and can preserve order via array output, but doesn’t offer full DOM APIs or streaming. - libxmljs:
Avoid
libxmljsin new projects — it is officially deprecated per its npm page and GitHub repository. The maintainers recommend migrating tolibxmljs2. It wraps the native libxml2 library, requiring compilation and limiting browser use, but historically offered strong standards compliance and XPath support. - libxmljs2:
Choose
libxmljs2if you require full DOM Level 2 compliance, XPath queries, XSD validation, or high-performance parsing of large documents in Node.js. It depends on native bindings (via node-gyp), so it won’t work in browsers or serverless edge runtimes. Use it only when you need features beyond basic parsing and can manage native dependency overhead. - sax:
Choose
saxif you’re processing very large XML files or need low-memory, streaming parsing. It’s a pure JavaScript SAX-style parser that emits events as it reads tokens, giving you fine control over memory usage. However, you must manually reconstruct object structure, making it more complex for simple use cases. - xml2js:
Choose
xml2jsif you want a straightforward, widely used parser that converts XML to JavaScript objects with minimal setup. It’s built onsaxunder the hood but abstracts away event handling. It’s suitable for moderate-sized documents and offers decent customization, though it’s slower thanfast-xml-parserand lacks streaming output. - xmldom:
Choose
xmldomif you need a browser-like DOM implementation for XML in Node.js or other non-browser environments. It parses XML into a standards-compliant DOM tree (withdocument,element, etc.), enabling traversal and manipulation similar to browser XML handling. However, it’s heavier than object-based parsers and doesn’t support streaming.
Popular Comparisons
README for xmlbuilder
xmlbuilder-js
An XML builder for node.js similar to java-xmlbuilder.
Announcing xmlbuilder2:
The new release of xmlbuilder is available at xmlbuilder2! xmlbuilder2 has been redesigned from the ground up to be fully conforming to the modern DOM specification. It supports XML namespaces, provides built-in converters for multiple formats, collection functions, and more. Please see upgrading from xmlbuilder in the wiki.
New development will be focused towards xmlbuilder2; xmlbuilder will only receive critical bug fixes.
Installation:
npm install xmlbuilder
Usage:
var builder = require('xmlbuilder');
var xml = builder.create('root')
.ele('xmlbuilder')
.ele('repo', {'type': 'git'}, 'git://github.com/oozcitak/xmlbuilder-js.git')
.end({ pretty: true});
console.log(xml);
will result in:
<?xml version="1.0"?>
<root>
<xmlbuilder>
<repo type="git">git://github.com/oozcitak/xmlbuilder-js.git</repo>
</xmlbuilder>
</root>
It is also possible to convert objects into nodes:
var builder = require('xmlbuilder');
var obj = {
root: {
xmlbuilder: {
repo: {
'@type': 'git', // attributes start with @
'#text': 'git://github.com/oozcitak/xmlbuilder-js.git' // text node
}
}
}
};
var xml = builder.create(obj).end({ pretty: true});
console.log(xml);
If you need to do some processing:
var builder = require('xmlbuilder');
var root = builder.create('squares');
root.com('f(x) = x^2');
for(var i = 1; i <= 5; i++)
{
var item = root.ele('data');
item.att('x', i);
item.att('y', i * i);
}
var xml = root.end({ pretty: true});
console.log(xml);
This will result in:
<?xml version="1.0"?>
<squares>
<!-- f(x) = x^2 -->
<data x="1" y="1"/>
<data x="2" y="4"/>
<data x="3" y="9"/>
<data x="4" y="16"/>
<data x="5" y="25"/>
</squares>
See the wiki for details and examples for more complex examples.