The History of JSON: The Data Format That Replaced XML

In 2001, a frustrated Douglas Crockford leaned back in his chair and realized the web had a problem. XML, the darling of data interchange, had become a monster of angle brackets, schemas, and namespace declarations. Sending a simple list of product names required twenty lines of markup. Crockford had a simpler idea—one that would quietly conquer the internet over the next two decades.

The Birth of a Minimalist Standard

JSON wasn't born in an ivory tower. Crockford, then at State Software, needed a way to send structured data between a browser's JavaScript and a server. He'd been using JavaScript object literals—the same {key: value} syntax developers already knew—and realized this pattern could work universally.

In 2002, he formally specified JSON (JavaScript Object Notation). The spec fit on a single page. No DTDs. No namespaces. No attributes. Just six data types: string, number, boolean, null, object, and array. The entire standard could be memorized in five minutes.

Why XML Lost Its Throne

XML had been designed for document markup—think books, legal contracts, and scientific papers. But developers were using it as a data transport format, and the mismatch was painful.

Comparing the same data in both formats tells the story:

XML:

<product>
  <name>Widget</name>
  <price>29.99</price>
  <inStock>true</inStock>
  <categories>
    <category>Tools</category>
    <category>Hardware</category>
  </categories>
</product>

JSON:

{
  "name": "Widget",
  "price": 29.99,
  "inStock": true,
  "categories": ["Tools", "Hardware"]
}

The JSON version wastes zero bytes on closing tags, zero bytes on attribute syntax. It maps directly to data structures in nearly every programming language. You can parse it with JSON.parse() in JavaScript, json.loads() in Python, or json_decode() in PHP.

The Tipping Point: AJAX and Web 2.0

By 2005, the web was moving fast. Google Maps and Gmail had shown that JavaScript could do real work. XMLHttpRequest—the technology behind AJAX—had existed for years, but it cried out for a lighter payload than XML.

JSON slotted perfectly into this world. A JavaScript object sent from a server could be parsed into live data with a single function call. No XSLT transformations. No DOM traversal. Just pure, executable data.

JSON's Quiet Conquest

JSON's rise wasn't a corporate decision. It wasn't backed by Microsoft or Sun Microsystems. It spread because developers kept choosing it over alternatives:

• 2006: Every major language had a JSON library. Python added json module in 2.6. PHP added json_encode() and json_decode().
• 2009: JSON replaced XML as MongoDB's native document format, shaping the NoSQL revolution.
• 2010: GitHub's API shipped JSON-only. Twitter followed. REST APIs became synonymous with JSON.
• 2013: ECMA International standardized JSON as ECMA-404. The spec was still one page.
• 2017: JSON became the bedrock of serverless computing, config files, and Web APIs.

The JSON Trade-Offs

JSON isn't perfect. It's verbose compared to binary formats like Protocol Buffers. It lacks a native date type (dates become strings, and everybody guesses the format). It doesn't support comments—a deliberate choice by Crockford to prevent schema-type bloat.

But these trade-offs are features, not bugs. JSON's simplicity means any system can parse it. It works from embedded sensors to cloud databases. It's good enough, and in engineering, good enough that works everywhere beats perfect that works nowhere.

The Legacy

Today, JSON is the Esperanto of data interchange. It carries tweets, weather reports, financial transactions, and satellite telemetry. Crockford's single-page spec has been implemented tens of billions of times across every platform imaginable.

XML still exists—it's entrenched in financial systems, SOAP services, and publishing pipelines. But JSON won where it mattered most: the pragmatic, fast-moving world of web development.

Crockford later said he designed JSON not as a competitor to XML, but as a "simpler alternative." That simplicity turned out to be the killer feature. Sometimes the most powerful technology isn't the most complex—it's the one that gets out of your way and lets you get work done.