How are attributes represented in the JSON?

Attributes are placed alongside child elements in the same object, typically prefixed with @ (for example, @id). Text content sits under a separate key such as #text when an element has both attributes and a value.

What happens with repeated elements?

If an element name appears more than once under the same parent, those entries are grouped into a JSON array so order is preserved. A single occurrence stays as an object.

Is my XML uploaded anywhere?

No. Parsing runs entirely in the browser tab, so the input never leaves your machine and nothing is logged on a server.

Does it preserve XML namespaces?

Namespace prefixes are kept as part of the key name. The mapping to namespace URIs is not resolved automatically, which keeps the output predictable for re-import.

xml → json · DOM-parsed · attributes preserved · live

Convert XML to JSON

Parse XML documents into clean JSON trees. Attributes are preserved on an @attributes key and repeated children become arrays. Runs locally in your browser.

XML → JSON

Input

128 B

8 lines

Output

0 B

1 lines

Status

error

see panel

Ratio

0.00×

out/in

input · xml

output · json

ErrorDOMParser is not defined

Quick Start

How to convert XML to JSON

The browser's DOMParser walks your XML tree. Attributes are flattened onto an @attributes key, repeated children collapse into arrays, and leaf text becomes plain strings.

01
Paste XML
Any well-formed XML document — RSS feeds, SOAP responses, config files.
Parsing is strict-but-tolerant — comments and trailing commas are accepted on input where the source format historically permits them; output stays canonical.
inputstricttolerantliveparse
input · sourcexml · live
```
<book id="1"><title>Hi</title></book>
```
loaded · parsedtarget · ready
02
DOM-parse the tree
Each element becomes a key; child text becomes the value.
Conversion preserves type information where the target supports it (numbers stay numeric, booleans stay boolean) so the destination parser never has to re-coerce.
parsetype-preservinglosslesslivememoised
tree · optionswalk · live
```
book
  title: "Hi"
```
options applied · liveround-trip
03
Attributes collapse
Attribute lists fold into a single @attributes object on the parent.
Re-encoding is idempotent: running output back through the same converter produces the same bytes, which keeps round-trips git-friendly.
attrsidempotentround-tripdiff-cleandeterministic
@attributes · convertedmerge · ready
```
"@attributes": { "id": "1" }
```
converted · livediff-clean
04
Copy or download
Grab pretty-printed JSON for your codebase, API tests, or jq pipelines.
Copy writes via navigator.clipboard.writeText; downloads use the target’s native MIME so editors apply the right syntax highlighting on open.
exportclipboardtarget MIMEblobclient-side
ok · copiedready · done
```
✓ Copied
```
shipped · ready to shipsuccess

Pro tips

Converting between formats, safely

Pick the strictest source format

Lossy formats hide bugs. Choose JSON or YAML as your source-of-truth, convert downstream as needed.

Round-trip in CI

If your converter is idempotent, your CI can verify A → B → A equals the original. Catches subtle data loss.

Numbers vs strings differ

YAML/TOML have a number type; CSV doesn’t. Quote IDs in CSV to keep leading-zero values intact.

Watch character encoding

Source format may be Latin-1 / Windows-1252; target should be UTF-8. Convert encoding before structure.

Preserve comments where you can

YAML and TOML support comments. Don’t silently drop them — they often encode intent.

Schema-aware beats blind

Use a schema to guide conversion. Field types, required-ness, and defaults survive better with structure.

Use Cases

When to convert XML to JSON

Modernise legacy feeds, normalise integrations.

SOAP migration

Translate XML payloads from legacy SOAP services to REST/JSON shapes. Type information survives: numbers stay numeric, booleans stay boolean, strings stay strings. The destination parser doesn't have to re-coerce, which avoids the "'true' becomes "true"" bug class.

round-trip safe

RSS / Atom

Convert feeds to JSON for static-site builds or analytics. Run output back through the inverse converter to verify idempotent round-trips in CI. A → B → A should produce byte-identical input — if it doesn't, you've found data loss.

type-preserving

Config import

Move pom.xml or other XML config snippets into JSON-based tooling. Comments and metadata survive where the target format supports them (YAML, TOML, HCL). The tool doesn't silently drop intent-encoded annotations, which keeps your config self-documenting.

schema-aware

Test fixtures

Snapshot XML responses as JSON for assertion-friendly tests. Pair with a schema (JSON Schema, OpenAPI, Zod, Pydantic) to catch shape drift on either side. Catch breaking changes at conversion time rather than at runtime in production.

lossless

Data archives

Re-shape historical XML exports into JSON before warehousing. Output respects target-format conventions: quoting in CSV, indent in YAML, brackets in JSON. Existing parsers don't need patches, and the result drops into legacy pipelines unchanged.

diff-clean

Front-end fetch

Hand back JSON to a UI that no longer needs to parse XML. Encoding-aware: handles UTF-8 vs UTF-16 vs Latin-1 / Windows-1252 transparently. The character-set surprise that breaks "works on my machine" doesn't apply here.

spec-grade

FAQ

Frequently asked questions

How are attributes represented?

Each element's attributes collapse into a sibling @attributes object so you never lose namespacing or metadata.

What happens with repeated child tags?

If a parent has multiple children with the same tag name, the converter automatically promotes them to an array.

Are XML namespaces preserved?

Yes — tag names keep their prefix (for example svg:rect) and namespace declarations survive on @attributes.

How big can my input be?

Limited only by browser memory. Multi-megabyte feeds parse comfortably.

Does it send my XML anywhere?

No. Conversion runs locally in your browser — nothing leaves your machine.

Suggest a tool

Something missing?

Tell us what you need. We ship the top requests every two weeks.

47 in queue·8 shipped this month

Request queued. Thanks!