A lightweight, human-readable data interchange format for structured data
JSON (JavaScript Object Notation) is a lightweight data interchange format designed to be easy for humans to read and write, and for machines to parse and generate. Though it originated from JavaScript, JSON is a language-independent format with parsers available for virtually all programming languages.
Developed by Douglas Crockford in the early 2000s, JSON has become the dominant format for data exchange in web applications, APIs, configuration files, and many other contexts. Its simple syntax, based on key-value pairs and nested structures, makes it intuitive yet powerful enough to represent complex data relationships.
Despite its simplicity, JSON can represent complex hierarchical data structures through nesting of objects and arrays. Its text-based nature makes it easy to debug and inspect, while still being efficient enough for most data exchange needs. These qualities have made JSON the standard choice for modern web APIs, configuration files, and data storage where human readability is valuable.
JSON syntax is remarkably simple, with just a few rules. Data is represented in key-value pairs within curly braces for objects, and values can be strings, numbers, objects, arrays, booleans, or null. Arrays are ordered lists of values enclosed in square brackets. All strings, including property names, must be double-quoted. JSON does not support comments, functions, or undefined values. Despite these limitations, its simplicity contributes to its widespread adoption and ease of implementation across different platforms and languages.
JSON has become the dominant format for RESTful API requests and responses. Its lightweight nature, ease of parsing in browsers, and ability to represent complex nested data make it ideal for sending data between client applications and servers. Nearly all modern web APIs use JSON as their primary data exchange format.
Many applications and frameworks use JSON for configuration files due to its readability, simplicity, and structured format. It's easier for both humans and machines to parse compared to older formats like INI or custom formats. Notable examples include npm's package.json, Visual Studio Code's settings, and configuration for many JavaScript frameworks.
JSON is widely used as a lightweight data storage format, especially in document databases like MongoDB, CouchDB, and Elasticsearch. These "schemaless" databases store documents as JSON or BSON (Binary JSON), allowing for flexible data structures that can evolve over time without rigid schema constraints.
For client-side web applications, JSON is the natural choice for storing and exchanging data. It can be directly parsed into JavaScript objects, making it extremely efficient for browser-based applications. Technologies like AJAX heavily rely on JSON for sending and receiving data asynchronously.
JSON serves as an excellent serialization format for storing complex object states that need to be reconstituted later. Many applications use JSON to save application state, user preferences, or other structured data that needs to be persisted and later reconstructed with its relationships intact.
JSON enjoys exceptional support across programming languages:
JSON works across all major platforms and environments:
Despite widespread compatibility, there are a few considerations:
| Feature | JSON | XML | YAML | CSV | Protocol Buffers |
|---|---|---|---|---|---|
| Human Readability | |||||
| Simplicity | |||||
| Data Structure Support | |||||
| Schema/Validation | |||||
| Size Efficiency | |||||
| Processing Speed |
JSON offers an excellent balance of human readability, simplicity, and reasonable performance for most use cases. XML provides better validation and metadata support but is more verbose and complex. YAML offers the best human readability with added features like comments but can be tricky with whitespace sensitivity. CSV is extremely simple but limited to tabular data. Protocol Buffers excel in performance and size efficiency but sacrifice human readability and require compiled schemas.
When converting XML to JSON, be mindful of how XML's attributes, namespaces, and mixed content are mapped. Simple XML elements typically become JSON properties, but there are multiple conventions for handling attributes (often prefixed with @ or stored in a separate _attributes object). Consider whether to preserve XML's more complex features or simplify the structure to be more JSON-idiomatic. Text content in elements with attributes may require special handling.
Converting CSV to JSON typically involves either: (1) Creating an array of objects where each row becomes an object with column headers as property names, or (2) Creating an object with IDs as keys and row data as values. The first approach is more common and directly represents the tabular structure. Be sure to handle data types appropriately—CSV stores everything as strings, while JSON supports numbers, booleans, and null values that can better represent your data.
YAML is a superset of JSON, so conversion is generally straightforward. However, YAML has features that don't directly map to JSON, including comments, complex keys, explicit data types, anchors/aliases (for references), and multi-line string formatting. When converting, these features either need to be removed or transformed into standard JSON structures. The result will be valid but might lose some of YAML's expressive capabilities.
When converting JSON to XML, you'll need to make decisions about element vs. attribute representation, handling of arrays, and namespace usage. Arrays can be particularly challenging—common approaches include using numeric elements, repeated element names, or special list container elements. For complex JSON structures, consider using a schema or convention (like JSONML or BadgerFish) to ensure consistent conversion. Be aware that JSON objects can have properties with names that aren't valid XML element names.
JSON to CSV conversion works well for "flat" arrays of objects with consistent properties, but becomes challenging for nested data. For nested structures, consider flattening the hierarchy using dot notation or multiple CSV files with relationships. If your JSON contains arrays within objects, you'll need to decide whether to expand these into multiple rows (normalization) or serialize the arrays into string representations within a single cell. Column headers should typically be derived from the unique set of all property names present in the objects.
Converting JSON to binary formats like Protocol Buffers, MessagePack, or BSON typically requires defining a schema or structure definition. For Protocol Buffers or Thrift, you'll need to create a formal schema file. For simpler formats like MessagePack, the conversion is more direct but still requires mapping JSON's dynamic typing to the binary format. These conversions are often used to optimize size and performance while maintaining the same logical data structure.