What happens with JSON keys that aren't valid XML names?

Names starting with a digit or containing characters like spaces or dots are escaped or rejected. Use simple identifier-style keys to avoid issues, or accept the substituted name in the output.

How are arrays handled?

Each element becomes a sibling tag using either the parent key name or a configurable item name, so [1,2,3] under "nums" can render as 1 2 3 .

Is the JSON sent to a server?

No. The conversion happens entirely in the browser.

Does it include an XML declaration?

Yes, with the standard prologue. You can disable it if the consumer expects a bare fragment.

json → xml · root tag · entity escape · live

Convert JSON to XML

Wrap any JSON tree in well-formed XML. Object keys become element names; arrays repeat elements. Configure the root tag and the rest is automatic.

JSON → XML

Input

93 B

7 lines

Output

168 B

9 lines

Status

ready

live

Ratio

1.81×

out/in

input · json

output · xml

<?xml version="1.0" encoding="UTF-8"?>
<root>
  <book>
    <title>Hello</title>
    <author>Jane</author>
    <tags>web</tags>
    <tags>design</tags>
  </book>
</root>

Quick Start

How JSON becomes XML

Each object key becomes an element. Arrays repeat the same element. Special XML characters (& < >) are escaped to entities. Pick a root element name for the wrapper.

01
Paste JSON
Object, array, or any nested shape.
Parsing is strict-but-tolerant — comments and trailing commas are accepted on input where the source format historically permits them; output stays canonical.
inputstricttolerantliveparse
in · sourcejson · live
```
{ "title": "Hi" }
```
loaded · parsedtarget · ready
02
Pick a root
Wrapped as <root>…</root> unless you change it.
Conversion preserves type information where the target supports it (numbers stay numeric, booleans stay boolean) so the destination parser never has to re-coerce.
roottype-preservinglosslesslivememoised
root · optionstag · live
```
<root>…</root>
```
options applied · liveround-trip
03
Walk & emit
Recurse, escape, repeat for arrays.
Re-encoding is idempotent: running output back through the same converter produces the same bytes, which keeps round-trips git-friendly.
walkidempotentround-tripdiff-cleandeterministic
walk · convertedtree · ready
```
<title>Hi</title>
```
converted · livediff-clean
04
Copy or download
Grab as .xml ready for SOAP, RSS or legacy services.
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
✓ · 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 JSON to XML

Legacy systems, feeds, schemas.

SOAP integration

Translate modern JSON payloads to legacy SOAP requests. 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

Emit feeds from a JSON-backed CMS. 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

Schema-driven docs

Render docs that expect XML examples. 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

Configuration

Generate Maven/Spring XML from JSON sources. 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

Compliance

Some regulations still require XML uploads. 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

B2B feeds

Send XML files to partners that haven't migrated. 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

Are JSON arrays preserved?

Yes — each element repeats the parent tag.

Are XML attributes generated?

No — JSON has no attribute concept here. Every value becomes an element.

What about JSON null?

Emitted as a self-closing element (<key/>).

What if a key has spaces?

Invalid in XML. The output will fail validation — sanitize keys upstream.

Is anything sent to a server?

No. Conversion is local.

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!