XML to JSON Converter
ConvertersConvert XML documents into clean, structured JSON with full support for attributes, namespaces, and nested elements.. Free, private — all processing in your browser.
The XML to JSON Converter transforms XML documents into equivalent JSON structures in a single paste-and-click interaction. XML is still everywhere — SOAP APIs, legacy enterprise systems, Microsoft Office files, RSS feeds, Android layouts, Java configuration, banking messages, and older government data feeds all rely on it. JSON dominates modern web APIs, JavaScript applications, mobile backends, and NoSQL databases. When these two worlds meet, you need a reliable converter that understands every XML quirk: attributes that live alongside elements, mixed text-and-element content, namespaces with prefixes, repeated sibling elements that must become arrays, self-closing tags, CDATA sections, and entity references.
This tool handles every XML edge case without forcing you to write custom parsing code. You paste XML, you get JSON — and more importantly, you get predictable JSON. Attributes are preserved under a clearly marked key prefix so you never lose metadata. Repeated elements are detected and grouped into arrays, even when there is only one occurrence (with a setting to force array mode for schemas you know will have collections). Namespaces can be stripped for readability or preserved for strict round-tripping. Every operation runs entirely in your browser, which means your XML never leaves your machine — a non-negotiable requirement when you are working with SOAP payloads, internal schemas, or regulated data.
XML to JSON Converter — key features
Attribute preservation
XML attributes are kept using the @ prefix convention so no metadata is silently lost during conversion.
Smart array detection
Repeated sibling elements automatically become JSON arrays, with an always-array option for schemas where collections may have zero or one item.
Namespace handling
Strip XML namespaces for cleaner JSON or preserve them for round-trip compatibility with SOAP and XSD-validated workflows.
CDATA and entity support
CDATA sections are unwrapped to plain strings and predefined entities like & and < are decoded automatically.
Pretty-printed output
The resulting JSON is indented with two spaces by default so you can read, diff, and review it before copying downstream.
Handles large documents
Streams large XML files through a browser-optimized parser without freezing the UI or loading everything into one giant string.
Error messaging with line numbers
Malformed XML shows the exact line and column of the first parse error so you can fix broken feeds quickly.
Private by design
Parsing runs entirely in your browser. Nothing is uploaded, logged, or cached on any server.
How to use the XML to JSON Converter
- 1
Paste or drop your XML
Paste XML source into the input panel, or drag an .xml, .rss, .svg, or .plist file directly onto the page.
- 2
Choose attribute and array options
Pick the @ prefix you want for attributes and decide whether to force array mode for known repeating elements.
- 3
Convert
Press Convert to parse the XML tree and emit the equivalent JSON. Parse errors are highlighted inline with line numbers.
- 4
Review the JSON output
Inspect the structure, confirm attribute keys are where you expect them, and check that arrays match your schema.
- 5
Copy or download
Copy to clipboard for quick paste into code, or download as a .json file for use in tests, fixtures, or downstream pipelines.
Common use cases for the XML to JSON Converter
API modernization
- →SOAP to REST migration: Convert SOAP XML responses to JSON so you can proxy a legacy service behind a modern REST or GraphQL gateway without rewriting the backend.
- →Third-party XML feeds: Turn partner XML feeds (flights, shipping rates, financial market data) into JSON suitable for a modern frontend or mobile app.
- →XML configuration to JSON: Migrate web.config, Spring beans, or other XML configs to JSON for modern tooling that expects JSON natively.
Data engineering
- →Loading into document stores: Transform XML exports before inserting into MongoDB, Elasticsearch, Firestore, or DynamoDB where JSON documents are the native format.
- →ETL pipelines: Normalize XML from multiple sources into consistent JSON for downstream transformation and warehouse loading.
- →Test fixture preparation: Capture real XML responses, convert to JSON, and trim them into deterministic fixtures for integration tests.
Developer workflows
- →Reading RSS and Atom feeds: Convert feed XML to JSON so you can traverse items with modern array methods instead of DOM APIs.
- →Android strings.xml audit: Convert Android resource XML to JSON so you can diff, search, and batch-update copy with JSON tooling.
- →Inspecting SVG internals: Turn SVG XML into JSON to programmatically analyze paths, groups, and attributes before automated edits.
XML to JSON Converter — examples
Simple record with attribute
An element with one attribute and one child becomes a clean nested object.
<user id="42"> <name>Ana</name> </user>
{
"user": {
"@id": "42",
"name": "Ana"
}
}Repeated elements as array
Three sibling book elements collapse into a JSON array automatically.
<library> <book>Dune</book> <book>Neuromancer</book> <book>Foundation</book> </library>
{
"library": {
"book": ["Dune", "Neuromancer", "Foundation"]
}
}SOAP envelope
A SOAP response body is flattened into JSON for frontend consumption.
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<GetPriceResponse>
<price currency="EUR">29.99</price>
</GetPriceResponse>
</soap:Body>
</soap:Envelope>{
"Envelope": {
"Body": {
"GetPriceResponse": {
"price": { "@currency": "EUR", "#text": "29.99" }
}
}
}
}CDATA section
CDATA content is unwrapped to a plain string value.
<description><![CDATA[Uses <b>HTML</b> & markup]]></description>
{
"description": "Uses <b>HTML</b> & markup"
}Mixed data types
Numbers, booleans, and dates stay as strings unless you enable type coercion.
<product> <price>29.99</price> <inStock>true</inStock> <sku>ABC-123</sku> </product>
{
"product": {
"price": "29.99",
"inStock": "true",
"sku": "ABC-123"
}
}Technical details
XML and JSON share a conceptual model (trees of named nodes containing values) but differ in three important ways that every converter must handle explicitly.
First, XML distinguishes between attributes and child elements. The fragment <user id="42"><name>Ana</name></user> has an attribute id on user and a child element name. JSON has no native concept of attributes. The common convention, popularized by libraries like xmltodict, xml-js, and fast-xml-parser, is to store attributes under a special key — typically @attributes, @_, or a configurable prefix like attr_. This tool uses the @ prefix by default and lets you switch conventions to match your target library.
Second, XML allows mixed content — text and elements at the same level. <p>Hello <b>there</b> friend</p> has three text runs interleaved with a b element. JSON represents this awkwardly through an array of alternating strings and objects, or by concatenating text nodes into a #text key. For most API-style XML (no mixed content), the clean object representation works perfectly; for document-style XML, you may need to preprocess.
Third, XML repetition is implicit. Five identical sibling elements become an array in JSON, but if there is only one element, is it a single object or an array with one item? Most parsers guess based on occurrence count, which breaks downstream code that expects consistent types. The best practice is to consult your XSD or known schema and force array mode for repeated elements — this tool offers an always-array option per path to match that practice.
Namespaces add another wrinkle. <ns:item xmlns:ns="http://example.com"/> can be rendered as ns:item (preserving the prefix), item (dropped), or with the full URI embedded in a metadata key. For interoperability with most downstream JavaScript consumers, dropping the prefix is typical; for SOAP round-trips or XSD validation later, preservation is essential.
Common problems and solutions
⚠Attributes silently dropped
Some converters discard XML attributes by default. Always check that the @ prefix (or whatever convention you chose) appears in the JSON for every attribute in the source XML.
⚠Single element not an array
If your code expects a list and the XML happens to have one item, the converter may emit a single object. Use the always-array option or post-process based on your known schema.
⚠Numbers coerced to wrong type
A value like 007 becomes 7 if auto-converted to a number, destroying leading zeros. Disable type coercion for identifier-style values.
⚠Namespaces create ugly keys
Keys like soap:Envelope can break downstream code that treats colons specially. Enable namespace stripping when you do not need round-trip fidelity.
⚠Mixed content loses order
Document XML with text interleaved with inline elements cannot round-trip cleanly. Preprocess by extracting text or use a dedicated document parser.
⚠Entity references leak into output
If the XML declares custom entities that your parser does not resolve, you may see &foo; literals in the output. Expand entities in XML before converting.
⚠Root element wrapping
Every XML document has exactly one root. JSON does not require that wrapper, but dropping it can change field paths. Decide once and document the choice in your schema.
XML to JSON Converter — comparisons and alternatives
Compared to xmltodict (Python), fast-xml-parser (Node), or xml-js, this browser-based converter covers the same core mapping rules without requiring you to install anything or write a single line of setup code. For one-off conversions, interview prep, or exploring an unfamiliar XML feed, the browser tool is the fastest path — paste XML, see JSON, copy, done.
For automation inside an application or data pipeline, you will still want a code library. fast-xml-parser is the fastest pure-JS option, xml-js is the most configurable, and xmltodict is the canonical Python choice. Any of them will match the output of this tool if you set the attribute prefix and always-array options consistently.
Purpose-built XSLT remains the gold standard for complex document transformations — turning one XML schema into another with sophisticated filtering, restructuring, and validation. Use XSLT when you need deterministic, testable, high-volume XML-to-XML transforms. Use this converter when you want JSON out at the end, and you want it in under five seconds.
Frequently asked questions about the XML to JSON Converter
▶Is my XML sent to a server?
No. Parsing runs entirely in your browser using a JavaScript XML parser. The XML content never leaves your machine, which matters when the payload contains internal schemas, customer data, or SOAP messages from regulated systems.
▶How are XML attributes represented in the output JSON?
Attributes are stored under a configurable prefix — @ by default — so the element <user id="42"> becomes { "user": { "@id": "42" } }. This follows the widely used convention from xmltodict, xml-js, and fast-xml-parser and keeps attributes visibly distinct from child elements.
▶Do I get an array when there is only one repeating element?
By default no. If the XML has one item under a known collection wrapper, it becomes a single object. Turn on the always-array option to force array mode for specific element names or paths when your code always expects a list.
▶How are namespaces handled?
You choose. Strip them for cleaner JSON (soap:Body becomes Body), preserve them as prefixed keys for strict round-tripping, or store the namespace URI in a metadata key for XSD-aware processing downstream.
▶What happens to CDATA sections and entity references?
CDATA sections are unwrapped to plain string values, so the CDATA markers disappear and the raw text becomes the JSON value. The five predefined XML entities (&, <, >, ', ") are decoded automatically.
▶Can the converter handle SOAP envelopes and WSDL responses?
Yes. SOAP is just XML with a specific envelope structure, so the converter treats it like any other document. Consider stripping namespaces for frontend use or preserving them if you will re-serialize later.
▶What size XML can it handle?
The parser is tuned for documents up to several hundred megabytes in modern browsers, limited only by available memory. For multi-gigabyte XML, stream it server-side with a SAX parser rather than loading everything into a browser tab.
▶Will numbers, booleans, and dates be typed automatically?
Not by default. Every value stays as a string to prevent data loss (leading zeros in identifiers, dates with dashes that look like subtraction, etc). Enable type coercion only when you control the schema and know which fields should be numeric or boolean.
Additional resources
- W3C XML 1.0 Specification — The official XML specification defining syntax, entities, and document structure.
- RFC 8259 (JSON) — The JSON standard covering types, grammar, and interoperability.
- fast-xml-parser on npm — Fast, configurable JavaScript library for XML parsing and serialization.
- xmltodict on PyPI — Popular Python library that maps XML to JSON-friendly dicts.
- MDN on DOMParser — Browser API used under the hood to parse XML into a DOM tree.
Related tools
All ConvertersCSV to JSON Converter
Convert CSV files to JSON arrays or objects with custom delimiters
HTML Formatter
Format, indent, and beautify HTML, XHTML, and HTML5 markup
JSON Formatter
Format, validate, and beautify JSON instantly in your browser
JSON Minifier
Compact JSON by removing whitespace — reduce file size by up to 80%
JSON to TypeScript
Generate TypeScript interfaces and types from JSON — handle nested, optional, arrays
JSON to XML Converter
Convert between JSON and XML — for SOAP APIs, legacy integration, data migration
Learn more
Explore more tools
200+ free tools that run in your browser.
Browse all tools →