XML to JSON

Convert XML into JSON, with optional attribute handling. Free, in your browser.

Parses XML into JSON in your browser, with optional attribute handling.

Free to use — premium coming soon

FREE
  • Attribute handling
  • Formatted JSON
  • 100% private
PREMIUM
  • Remove ads
  • Namespaces & advanced options

About the XML to JSON

The XML to JSON converter turns angle-bracket markup into the lighter, key-value structure that powers modern JavaScript apps and REST APIs. You paste an XML document and get back JSON where elements become object properties, repeated tags collapse into arrays, and text content lands inside each node. It exists because the two formats think differently: XML is document-oriented, built for validation, namespaces, and mixed prose-and-markup; JSON is data-oriented, with native objects, arrays, numbers, and booleans. Conversion bridges that gap so data trapped in an XML feed or legacy response can flow into code that expects JSON.

Reach for this tool whenever something upstream still speaks XML but your code speaks JSON. SOAP web services (common in banking, healthcare, and ERP systems) return XML envelopes by definition, and RSS and Atom feeds are XML standards you must parse to read. Build files like Maven's pom.xml, Spring's applicationContext.xml, Android layouts, and SVG graphics are all XML too. Rather than write a brittle parser, drop the payload here, convert it to JSON, and pipe the result straight into JavaScript, a database, or a dashboard. It is also handy for eyeballing a tangled XML response in a flatter, more readable shape.

Under the hood the converter walks the XML tree and applies a consistent mapping. Because JSON has no concept of attributes, each attribute is moved into a property, conventionally prefixed so it does not collide with child elements (the widely used convention prefixes attributes with @, while the BadgerFish style adds @ for attributes and $ for text). Elements that repeat under the same parent are gathered into a JSON array, since JSON distinguishes objects from arrays even though XML does not. Text inside an element with attributes is stored under a dedicated key, and CDATA sections are unwrapped into plain strings.

A few things are worth knowing for accuracy. XML to JSON is not always perfectly reversible: comments, processing instructions, and the XML declaration have no JSON equivalent and are usually dropped, and a tag that appears once may be read as a single value or a one-item array depending on the rules, so downstream code should not assume one or the other. Namespaces are typically simplified by keeping only the local name (so soap:Body becomes Body). On privacy: this converter runs entirely in your browser. Your XML is parsed locally and never uploaded, which matters when the document carries credentials, customer records, or internal config.

Frequently asked questions

How are XML attributes represented in the JSON output?

Because JSON has no attributes, each attribute becomes a normal property, conventionally prefixed (commonly with @) to keep it separate from child elements. For example, <book id="123"> becomes something like {"book": {"@id": "123"}}.

Why does a single XML element sometimes become an array and sometimes not?

XML has no array type, so converters infer arrays from repeated tags. An element that appears multiple times collapses into a JSON array, but one that appears only once is often kept as a single value. To be safe, write code that handles both, or normalise the structure after conversion.

Can I convert the JSON back to the original XML exactly?

Not always. XML to JSON loses information that JSON cannot store, such as comments, processing instructions, the XML declaration, and strict element ordering. The data round-trips, but the exact original markup usually cannot be perfectly reconstructed.

What happens to XML namespaces during conversion?

JSON has no native namespace concept. Most converters strip the namespace URI and keep only the local name for readability, so an element like <soap:Body> typically becomes a plain "Body" key in the JSON.

Is my XML uploaded to a server?

No. The conversion happens entirely in your browser using the local XML parser, so your document is never sent anywhere. That makes it safe for sensitive payloads like SOAP responses or configuration files containing secrets.

From our blog

How to Build CSS Gradients That Look Clean on Every Screen

By the Super Simple Digital Tools Team · Updated June 2026

Gradients are one of the few design effects in CSS that cost nothing to ship. Because the browser paints them as a generated image rather than downloading a file, a gradient background adds no extra HTTP request and stays razor-sharp at any resolution. That makes them perfect for hero sections, buttons, and overlays where a JPG or PNG would add weight and blur on high-density screens. The trade-off is syntax: the gradient functions pack direction, shape, and color stops into a single line, and that is exactly what a generator helps you assemble correctly.

Start with the workhorse, linear-gradient(). Its first value is the direction, either an angle such as 45deg or a keyword such as 'to right'. Remember that 0deg points straight up and the angle increases clockwise, so 90deg flows to the right. After the direction comes the color-stop list. At minimum you need two colors; the first sits at 0% and the last at 100% unless you say otherwise. Add a third or fourth color for richer blends, but three to four is usually the sweet spot before a gradient starts to look noisy.

Radial gradients swap the angle for a shape and size. radial-gradient(circle, ...) draws a perfect circle, while the default 'ellipse' stretches to match the box. Size keywords like closest-side and farthest-corner tell the browser where the final color lands relative to the element's edges, and the 'at' keyword repositions the center, for example 'at 30% 20%'. This is how you build a soft spotlight: a bright center color fading to a darker or transparent edge. Conic-gradient() rounds out the set by sweeping colors around a center point, which is what powers pie charts and color wheels.

Hard stops are the trick most people miss. If you give two adjacent colors the same position, for example 'red 50%, blue 50%', the blend collapses into a crisp line. Repeat that idea with repeating-linear-gradient() using fixed units like pixels and you get stripes; do it with repeating-conic-gradient() and you get pie slices or a starburst. Percentage stops will not repeat usefully because the gradient already spans the full element, so reach for px or em when you want a tiling pattern.

Finally, polish for real displays. Wide, low-contrast fades can show stair-step 'banding' on 8-bit monitors, so add an intermediate color stop or nudge the contrast to smooth it out. When a gradient fades to nothing, fade to the same color at zero alpha rather than the keyword 'transparent', which some engines interpret as transparent black and render as a gray haze. Test your final snippet against the actual background it sits on, because layered gradients stack with the first one on top.

  • Stick to three or four color stops; more than that tends to look noisy and muddy rather than smooth.
  • When fading to nothing, use rgba(r,g,b,0) instead of 'transparent' to avoid a gray banding seam.
  • Use fixed units (px or em), not percentages, with repeating-linear-gradient() so the pattern actually tiles.
  • Set two color stops to the same position to create a hard edge for stripes, checkerboards, or split backgrounds.

Read the full guide →

Tool by the Super Simple Digital Tools Team. Reviewed by our editorial team. Free to use, no signup required.

Related tools