XML Formatter

The XML Formatter beautifies messy or minified XML documents into properly indented, readable output. Works with any XML variant: SOAP envelopes, RSS and Atom feeds, SVG graphics, XHTML, XML config files (Spring, Maven pom.xml, Android manifests), WSDL service descriptions, XSLT stylesheets, and any custom XML schema. Unlike HTML, XML is strict — all elements must close, attributes must be quoted, and there is one root element. This formatter validates strict XML rules while formatting, catching errors that would break parsers.

XML remains essential in enterprise contexts (banking, healthcare, government APIs), legacy systems, SOAP web services, configuration (Maven, MSBuild, Android), data interchange (RSS, Atom), and vector graphics (SVG). Despite JSON displacing XML for new web APIs, XML is far from dead. Being able to quickly beautify and validate XML is a daily need for developers working with enterprise systems, legacy APIs, or SVG editing. This formatter handles everything XML throws at it — namespaces, CDATA sections, processing instructions, DTD declarations, and comments.

XML (eXtensible Markup Language, W3C standard since 1998) is a strict markup language designed for data representation.

XML rules (stricter than HTML):

- All elements must close: <p>text</p> or self-closing <br/>. Unlike HTML, no optional closing tags.
- Attributes must be quoted: <a href="url"> — no unquoted attributes.
- One root element: document must have exactly one top-level element.
- Case-sensitive: <Foo> and <foo> are different elements.
- Special characters escaped: <, >, &, ", ' or numeric (<).
- XML declaration optional but conventional: <?xml version="1.0" encoding="UTF-8"?> at document start.

Formatting rules:

- One element per line.
- Nested elements indented (2 or 4 spaces).
- Long attribute lists can be wrapped onto multiple lines.
- Comments (<!-- -->) preserved.
- CDATA sections (<![CDATA[...]]>) preserved verbatim (content not reformatted).
- Processing instructions (<?xml-stylesheet ... ?>) preserved.

Common XML documents:

SOAP envelope:
``xml
<?xml version="1.0"?>
<soap:Envelope xmlns:soap="http://www.w3.org/2003/05/soap-envelope">
<soap:Header/>
<soap:Body>
<m:GetPrice xmlns:m="http://example.com/stocks">
<m:StockName>IBM</m:StockName>
</m:GetPrice>
</soap:Body>
</soap:Envelope>
``

RSS feed:
``xml
<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0">
<channel>
<title>Tooleras Blog</title>
<link>https://tooleras.com/blog</link>
<description>Developer tools and tutorials</description>
<item>
<title>Blog Post Title</title>
<link>https://tooleras.com/blog/post</link>
</item>
</channel>
</rss>
``

SVG:
``xml
<?xml version="1.0"?>
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100">
<circle cx="50" cy="50" r="40" fill="red"/>
</svg>
``

Android manifest:
``xml
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.example.app">
<application android:icon="@drawable/icon">
<activity android:name=".MainActivity"/>
</application>
</manifest>
``

Namespaces:

XML uses namespaces to disambiguate elements from different vocabularies:

``xml
<root xmlns:book="http://example.com/book" xmlns:music="http://example.com/music">
<book:title>XML Guide</book:title>
<music:title>Song Name</music:title>
</root>
``

Formatter preserves namespace prefixes and declarations.

CDATA sections:

Text inside CDATA is not parsed as XML — used for code snippets, special characters:

``xml
<script><![CDATA[
if (x < 5 && y > 3) {
doSomething();
}
]]></script>
``

Formatter preserves CDATA contents verbatim (does not reformat internal text).

Validation levels:

- Well-formed: follows XML syntax rules (one root, closed tags, quoted attributes, escaped chars).
- Valid: conforms to a schema (DTD, XSD, RelaxNG). Requires schema validation.

This formatter checks well-formedness. For validity, use schema validator.

Encoding:

XML declares its encoding (encoding="UTF-8" typical). UTF-8 is the web standard. Legacy systems may use Windows-1252, ISO-8859-1. Check declared encoding matches actual bytes.

XML vs HTML formatting: XML is strict (all tags must close, attributes quoted, case-sensitive). HTML is permissive. XML formatters reject invalid XML; HTML formatters tolerate errors. See HTML Formatter.

XML vs JSON: XML is verbose with start/end tags; JSON is compact with braces. XML supports namespaces, CDATA, DTD schemas. JSON simpler. Most new APIs use JSON.

XML Formatter vs XML Minifier: Formatter expands. Minifier compresses (remove whitespace, collapse attributes). Both lossless roundtrip.

This tool vs xmllint (CLI): xmllint is the classic Unix XML tool. Handles huge files, schema validation. This tool for browser-based ad-hoc formatting.

XML vs SVG: SVG is XML-based. Same formatting rules. SVG has specific tags (path, circle, rect) but formatting is identical to generic XML.

Well-formed vs Valid: Well-formed = follows XML syntax rules. Valid = conforms to a specific schema. This formatter checks well-formedness. For schema validation (DTD/XSD), use dedicated validators.