メインコンテンツへ移動

JSON vs XML

Pick JSON for API payloads and anything a browser or mobile app consumes: smaller, typed, universally parsed. Pick XML for document-shaped data, enterprise integration and interfaces that need namespaces or strict XSD validation. Neither is obsolete: JSON owns the wire, XML owns documents, and this page's converters bridge both directions.

端末内で処理

以下の解説は英語のみでご覧いただけます。

JSON vs XML explained

For fifteen years XML was the default answer to almost every data question — SOAP services, RSS feeds, Office documents, build configuration. JSON then took the API layer almost completely, and the two formats have lived in a comfortable division of labour ever since. The rivalry framing hides the real story: they were built for different jobs. XML descends from SGML and is a markup language for documents; JSON is a data interchange format whose grammar fits on an index card. Most disappointment with either comes from asking one to do the other's job.

The daily differences are concrete. XML marks up every value with an opening and closing tag, which roughly doubles the markup per field; JSON wraps values in quotes and commas. XML is stringly typed — everything is text until a schema says otherwise — while JSON declares numbers, booleans and null in the syntax itself. XML has attributes, namespaces and mixed content; JSON has keys, arrays and none of those things. Each of those decisions ripples outward into schemas, tooling and payload size.

This page keeps the comparison where it bites: syntax and the tag tax, typing, schemas and namespaces, size and streaming. When you need to cross between them, both directions have converters on this site — and like everything here, they parse and emit entirely in your browser.

Need to hand a JSON payload to an XML-only system? The JSON to XML converter maps keys and arrays to elements in your browser, nothing uploaded.

Inheriting a legacy feed or a SOAP response? The XML to JSON converter reshapes it as JSON locally, before your code ever touches a tag.

Origins: a markup language versus a data format

XML's ancestor is SGML, and its design goal was marking up documents: prose that mixes paragraphs, emphasis and structure. That is why XML alone of the two supports mixed content — text with inline markup like <title>Learning <em>XML</em></title> — and why it grew attributes, entity references and a heavyweight processing model. JSON was extracted from JavaScript object literals around 2001 for exactly one purpose: moving structured data between programs with the least possible grammar. There is no mixed content in JSON, no entity machinery, and no document tree — objects, arrays and four scalar types are the entire universe.

Syntax: the tag tax, attributes and the missing array

Every XML element opens and closes, so a simple value costs two tags: <price>19.99</price>. XML offers an alternative spelling — <price currency="EUR">19.99</price> — and the attribute-versus-element choice has generated debate for two decades without a universal answer. JSON has exactly one spelling for a key/value pair and one for a list. Crucially, JSON has native arrays; XML has no array type at all. A list is expressed by repeating an element, which means every JSON-to-XML tool must agree on a convention for naming and wrapping repeated items.

AspectJSONXML
GrammarOne page (RFC 8259)XML 1.0 plus namespaces, infoset and DTD machinery
ContainersObjects and arraysElements; arrays are repeated elements
TypingNumbers, booleans, null are nativeAll values are text until a schema types them
AttributesNone — one spelling per pairAttribute or element, a standing choice
NamespacesNone; prefix conventions onlyBuilt-in xmlns mechanism for merged vocabularies
CommentsNone, removed by designYes, <!-- --> anywhere in the tree
Schema languageJSON SchemaXSD, DTD, Relax NG
Mixed contentNot expressibleNative — text interleaved with markup

Schemas and namespaces: where XML still earns its keep

XSD is XML's quiet advantage in enterprises: a mature schema language with derived types, cardinality constraints, pattern facets and two decades of tooling that can validate a document and report precisely which element broke which rule. JSON Schema pursues the same goal with a different shape — it is expressive, supports conditional logic, and has become the de facto contract language for modern APIs — but its long draft history means tooling varies more in what it accepts. Both ecosystems can be strict; XML's is simply older.

Namespaces are XML's other enduring feature. An XHTML page can embed SVG and MathML without key collisions because each vocabulary carries its own URI. JSON has no equivalent mechanism — name collisions are avoided by convention, or by layered designs such as JSON-LD that attach context explicitly.

Size, streaming and when to pick which

For the same data, XML payloads are usually larger: closing tags alone roughly double the element markup, and attribute-heavy styles add more. Both formats compress well with gzip — XML's redundancy is highly compressible — but the base overhead rarely closes completely. On streaming, XML's parser ecosystem runs deeper: SAX and StAX push parsers were designed for documents too big for memory, and every platform ships one. JSON streaming parsers exist and are excellent, but whole-document parsing remains the common default.

Pick JSON for anything a pair of programs exchanges: web and mobile APIs, structured logs, service-to-service payloads. Pick XML when a specification mandates it — SOAP stacks, publishing pipelines, Office formats, many healthcare and finance standards — or when you need XSD validation and namespaces on the wire. The guidance reverses cleanly: JSON leaking into a document pipeline usually wants to be XML, and a SOAP-era API exposing clean JSON is a migration win, not a betrayal.

Frequently asked questions

Is JSON replacing XML?

It displaced XML from one territory, not all of them. JSON now owns the API layer — REST, mobile, browser — while XML remains entrenched where documents or standards dominate: Office and EPUB files, SVG graphics, SOAP enterprises, and publishing, healthcare and finance specifications that mandate it. Learning both stays worthwhile; converting between them is routine.

Why is XML larger than JSON for the same data?

Two structural reasons. Every element needs a closing tag, so each value pays the markup twice, and XML has no native array — lists become repeated elements with their own tags. Compression narrows the gap because repeated tags gzip extremely well, but the raw sizes differ enough that mobile-era APIs standardised on JSON.

Does converting XML or JSON here upload my data?

No. Both converters parse and emit inside your browser tab with no server involved — there is no upload endpoint, and the site's Content-Security-Policy restricts network access to itself. Open the DevTools Network panel while converting and you will see no outbound request carrying your payload.

Should XML values live in attributes or child elements?

A workable rule: attributes for metadata about the element — identifiers, types, units, language — and child elements for content, especially anything long, ordered, repeating or itself marked up. Attributes cannot repeat, cannot hold structure and are invisible to mixed content, which is why any list of things must be elements.

Is XSD validation stronger than JSON Schema?

Stronger in maturity, not in principle. XSD has twenty years of stable tooling, derived types and strict sequencing rules that enterprises rely on. JSON Schema is expressive — conditions, pattern properties, reusable definitions — and dominant for modern API contracts. Pick the one your toolchain already validates with; changing formats does not remove the need for a schema.

How do JSON arrays become XML elements?

Because XML lacks an array type, converters map an array to repeated child elements under a wrapper, or to siblings sharing one name — the convention varies by tool and matters enormously on round-trips. This site's converters document the exact mapping they use, so a document pushed through both directions stays predictable.