Input XML

Formatted XML

Free Online XML Formatter & Beautifier

XML Formatter Online — Beautify, Indent & Validate XML

Paste a minified SOAP envelope, an RSS feed, or a 3,000-line Maven pom.xml and get clean, indented XML back. The formatter parses your input first, so a mismatched tag or a stray & comes back with the reason it broke instead of a blank screen. Beautify, pretty-print, or minify XML in the browser; nothing is uploaded.

2 / 4 / tab indent Keeps CDATA & namespaces Well-formedness check Runs in your browser

🔐

100% Browser-Based

XML is parsed with DOMParser locally. Nothing leaves your device.

🧩

Structure-Aware

CDATA, comments, and namespace prefixes are preserved.

⚠

Catches Errors

Reports the exact not-well-formed spot as you format.

⚡

Fast & Free

No signup, no size limits, no waiting on a server.

How It Works

Format XML in 4 Steps

Paste, pick an indent, format. Results in milliseconds.

Paste XML

A SOAP response, RSS feed, or config file.

Pick indent

2 spaces, 4 spaces, or tab.

Format

Get indented, well-formedness-checked XML.

Copy or download

Grab the clean .xml.

The Basics

A beautifier that understands XML, not just whitespace

Naive "format XML online" tools just re-space the text they are handed. This one parses the document first, so it beautifies the actual tree: elements indent under their parents, attributes stay on their tags, and if the XML is not well-formed you get the error instead of garbage. Beautifying never rewrites your data. Text nodes, attribute values, and element order come out identical; only the indentation between tags changes.

XML is stricter than the HTML most of us cut our teeth on. It is case-sensitive (<Book> and <book> are two different tags), it allows exactly one root element, and it wants reserved characters escaped as entities. Break any of those and the parser stops dead at that byte.

Well-formed vs valid: know which one you need

"Well-formed XML" means the syntax holds up: tags matched and nested, attributes quoted, entities escaped. "Valid XML" is stricter again, matching a schema (DTD, XSD, or RelaxNG) that dictates which elements may appear where. This formatter enforces well-formedness as it beautifies, which catches most real bugs. If you also work in JSON, the same idea powers the JSON parser and JSON formatter.

What the formatter leaves alone

Text content, attribute values, and element order: byte-for-byte.
CDATA sections, which legitimately hold raw < and &.
Namespace prefixes such as xmlns:soap and soap:Body.
The <?xml … ?> prolog and its encoding declaration.

Compact in, readable out

Example

<note><to>Ada</to><from>Grace
</from><body>Hi &amp; bye</body></note>

<note>
  <to>Ada</to>
  <from>Grace</from>
  <body>Hi &amp; bye</body>
</note>

XML syntax rules a formatter enforces

Rule	Valid	Invalid
Case-sensitive tags must match	`<Book></Book>`	`<Book></book>`
Exactly one root element	`<root><a/><b/></root>`	`<a/><b/>`
Proper nesting (close in reverse)	`<a><b/></a>`	`<a><b></a></b>`
Attribute values quoted	`<p id="1">`	`<p id=1>`
Reserved chars escaped in text	`< & >`	`raw < and &`

What a correct formatter preserves

Construct	Handling
Prolog `<?xml version="1.0"?>`	Kept on line 1 with its encoding declaration
CDATA `<![CDATA[…]]>`	Left byte-for-byte; may contain `<` and `&`
Namespaces `xmlns:soap`	Prefixes preserved verbatim on their elements
Comments `<!-- -->`	Kept and re-indented
Self-closing `<br/>`	Preserved, not expanded

The XML errors that actually bite, and their fixes

XML parsers are unforgiving: the first slip stops the parse, so you fix errors one at a time from the top. These five cover almost every "not well-formed" message.

Parser says	What actually happened	Fix
`mismatched tag`	Start and end tag differ, usually in case, because XML is case-sensitive	Make `<Book>` and `</Book>` match exactly
`junk after document element`	Two elements at the top level with no wrapper	Wrap the siblings in one root element
`EntityRef: expecting ';'`	A raw ampersand in text, e.g. the & in "AT&T"	Escape it as `&`
`AttValue: " or ' expected`	An unquoted attribute like `id=1`	Quote every value: `id="1"`
`Premature end of data`	A tag opened and never closed before end of file	Close it, or self-close as `<tag/>`

Beautify to read, minify to ship

Beautifying and minifying are the same operation in reverse, and both are lossless. Beautify (pretty-print) while you read a SOAP trace or eyeball an Android strings.xml; minify before you send XML over the wire, where every space is bandwidth. Hit Minify above to collapse an indented document back to one line. It is the XML counterpart to the JSON minifier and JSON pretty-printer, so the workflow is identical whichever format your API speaks.

Use Cases

What developers use an XML beautifier for

Reading and debugging XML is where this earns its keep.

Reading SOAP traffic

Turn a one-line SOAP or WSDL response into an indented tree you can trace through.

Debugging RSS & Atom feeds

Find the item with the unescaped ampersand or the unclosed <description>.

Config files

Maven pom.xml, web.config, Spring beans, Android layouts: reindent and sanity-check.

Clean Git diffs

Consistent XML indentation keeps version-control diffs small and reviewable.

Pre-commit validation

Catch a mismatched tag or bad entity before CI does, right in the browser.

Also work in JSON?

Same job, JSON syntax: the JSON formatter and JSON viewer.

FAQ

Frequently Asked Questions

What developers ask about formatting XML.

Does formatting change my XML data?▼

No. The XML formatter only touches whitespace between tags. Every text node, attribute value, CDATA block, and the order of elements comes out byte-identical, so you can beautify a signed or hashed document and it still matches.

Well-formed vs valid XML: which does this check?▼

This tool checks well-formedness (matched tags, quoted attributes, escaped entities) as it beautifies. Validity is the stricter check against a DTD or XSD schema and is a separate step. Most day-to-day broken XML is a well-formedness slip, which is exactly what the formatter surfaces.

Why does my XML say "mismatched tag"?▼

The start and end tag do not match. Nine times out of ten it is case, because XML is case-sensitive, so <Book> and </book> are different tags; the rest of the time tags were closed in the wrong nesting order.

Can it pretty-print a SOAP or RSS response?▼

Yes. Namespace declarations like xmlns:soap and prefixed names like soap:Envelope are kept verbatim, CDATA is left intact, and the <?xml?> prolog stays on line one. Paste RSS 2.0, Atom, or a WSDL and it indents cleanly.

How is XML indentation different from JSON?▼

XML nests elements and attributes, needs one root, and escapes reserved characters as entities; JSON nests objects and arrays with a simpler value set. The indentation habit is the same, which is why the JSON pretty-print and JSON formatter tools feel familiar if you know one.

Is my XML uploaded anywhere?▼

No. The formatter runs on DOMParser in your own browser. Your XML never touches a server, which matters for config files and API payloads that carry keys or tokens.

Related Guides