How are attributes and repeated tags handled?

Element attributes are collected under an "@attributes" object, and when a tag appears more than once it becomes an array. A leaf element with only text becomes a plain string value.

How accurate is the parsing?

Parsing uses the browser's built-in DOMParser, the same engine browsers use for real documents, so malformed XML is reported as an error rather than silently mis-parsed. Mixed content and processing instructions are simplified, since JSON has no direct equivalent.

Is my XML sent anywhere?

No. The conversion runs entirely in your browser using the native DOMParser — your data never leaves your device.

What happens when an element has both attributes and text?

The attributes go under "@attributes" and the inner text is stored under a "#text" key on the same object, so neither is lost. A leaf element with text but no attributes is flattened to a plain string instead.

Why did my conversion return an error?

DOMParser flags structural problems such as unclosed tags, mismatched names or invalid characters by injecting a parsererror node, which the tool surfaces as an error. Fix the XML so it is well-formed and convert again.

Is there a standard for converting XML to JSON?

There is no single official standard, so several conventions exist. This tool uses the widely-adopted "@attributes / arrays for repeats / string for leaves" convention, which is compact and round-trips cleanly for most data documents.

Can I convert the JSON back to XML?

Use the companion JSON to XML converter. Because attributes live under @attributes and repeated tags became arrays, that structure maps back to elements, though comments and processing instructions are not reconstructed.

XML to JSON Converter

Convert XML to JSON in your browser

Paste a well-formed XML document and get clean, indented JSON. This is the tool you reach for when an API or legacy system speaks XML but your JavaScript, config tooling or REST client wants JSON — feeds, SOAP responses, sitemaps and export files all convert in one step.

How it works

Parsing uses the browser’s native DOMParser, the same engine that reads real web documents, so behaviour matches how a browser interprets your markup. The tool then walks the resulting DOM tree recursively with a deterministic convention:

Attributes on an element are collected into an @attributes object.
A child tag name that appears more than once becomes a JSON array.
A leaf element with only text and no attributes becomes a plain string.
An element with both attributes and text keeps the text under a #text key.

If DOMParser injects a parsererror node — its signal for malformed input — the tool reports a clear error rather than emitting a half-broken object.

Example

Input:

<order id="1001" paid="true">
  <customer>Gera Tools</customer>
  <items>
    <item>Pliers</item>
    <item>Wrench</item>
  </items>
</order>

Output:

{
  "@attributes": { "id": "1001", "paid": "true" },
  "customer": "Gera Tools",
  "items": { "item": ["Pliers", "Wrench"] }
}

Note id/paid landed under @attributes, the single customer is a string, and the two <item> tags collapsed into an array.

Everything runs locally in your browser using the built-in DOMParser — your data is never uploaded or stored.