JSON

JSON (JavaScript Object Notation) is a lightweight, human-readable data-interchange format widely used in web applications and APIs.

What You Can Upload

• .json files (single objects or arrays)
• .jsonl files (JSON Lines format)
• ZIP archives with multiple JSON files

What You Get Out

DataMeans extracts your data into multiple modern formats:

How to Export / Obtain Files

1. Export data from your application as JSON
2. Or export from NoSQL database (MongoDB, CouchDB, etc.)
3. Upload directly or in a ZIP archive

Supported Features

• Objects, arrays, nested data structures
• All JSON data types (strings, numbers, booleans, null)
• UTF-8 and UTF-16 encoding
• JSON Lines format for streaming data
• Automatic flattening of nested structures

Known Limitations

• No native date/time type (dates stored as strings)
• Binary data must be base64-encoded
• Deeply nested structures may need manual review
• Inconsistent field names across records require normalization

Best Practices

• Use arrays of objects for tabular data
• Keep field names consistent across records
• Use ISO 8601 for dates (e.g., "2024-01-15T10:30:00Z")

Overview

JSON (JavaScript Object Notation) is a lightweight, text-based data interchange format derived from JavaScript object syntax. It represents structured data using key-value pairs, arrays, and nested objects, making it ideal for web APIs, configuration files, and data exchange between applications. JSON is language-independent and supports Unicode, with optional schema validation through JSON Schema.

History and Background

• 2001: JSON specified by Douglas Crockford at State Software; first JSON message sent in April 2001.
• 2002: JSON.org website launched, promoting JSON as alternative to XML.
• 2005: Yahoo begins offering web services in JSON.
• 2006: RFC 4627 published, registering the application/json media type.
• 2009: ECMAScript 5 adds native JSON support (JSON.parse and JSON.stringify).
• 2013: RFC 6901 (JSON Pointer) and RFC 6902 (JSON Patch) published in April, defining value addressing and a six-operation patch format.
• 2013: JSON standardized by Ecma International as ECMA-404.
• 2015: RFC 7464 (JSON text sequences) and RFC 7493 (I-JSON profile) published.
• 2017: RFC 8259 published as Internet Standard STD 90.
• 2018: JSON Schema draft-07 released for validation.
• 2019: JSON Schema 2019-09 draft published.
• 2020: JSON Schema 2020-12 draft published, adding dynamic references.
• 2024: RFC 9535 published in February, standardizing JSONPath query expressions.
• Present: Ubiquitous in web development and APIs.

File Format Specifications

Basic Structure:

• Plain text format using UTF-8 encoding
• File extension: .json
• MIME type: application/json
• Whitespace allowed for readability (spaces, tabs, newlines)
• Comments not officially supported (though JSON5 adds them)
• No charset parameter defined for the application/json media type
• Byte order mark: must not be added by emitters; parsers may ignore a leading U+FEFF

Syntax Rules:

• Objects: Unordered collections of key-value pairs in curly braces {}
• Arrays: Ordered lists of values in square brackets []
• Keys: Always strings, enclosed in double quotes
• Values: Can be objects, arrays, strings, numbers, booleans, or null
• Strings: Double-quoted with backslash escaping
• Numbers: Decimal notation, no leading zeros except 0
• Escapes: \", \\, \/, \b, \f, \n, \r, \t, and \uXXXX for Basic Multilingual Plane characters
• Characters above U+FFFF: written as twelve-character UTF-16 surrogate pair escapes
• Structural characters: exactly six: begin/end object, begin/end array, name separator (:), value separator (,)
• NaN and Infinity: not representable in the number grammar

Key Specifications:

• Maximum nesting depth: Implementation-dependent; the specification sets no limit
• Maximum string length: Implementation-dependent
• Number precision: Not limited by the grammar; IEEE 754 double precision assumed for interoperability
• Unicode support: Full Unicode character set; UTF-8 required for open interchange
• Integer interoperability: limited to ±9,007,199,254,740,991 (2^53 − 1); RFC 7493 advises string encoding beyond this range

Data Types and Structures

Structural Elements:

• Objects: Key-value containers, keys must be unique strings
• Arrays: Zero-indexed ordered collections
• Nested structures: Objects and arrays can contain each other
• References: No built-in support for references or cycles
• Schema validation: Optional via JSON Schema specification

Version Differences

Compatibility Notes:

• RFC 8259 made no grammar changes from RFC 7159; RFC 7159 broadened RFC 4627 by allowing any top-level value
• Most implementations support full UTF-8
• Some parsers are strict, others lenient with trailing commas
• JSON5 is not universally supported
• No formal versioning in JSON files themselves
• Object member names are only a SHOULD-be-unique requirement; behavior with duplicates varies between implementations
• JSON has no date or binary types; RFC 7493 recommends RFC 3339 timestamps and base64url-encoded binary data

Technical References

• RFC 8259: The JavaScript Object Notation (JSON) Data Interchange Format
• ECMA-404: The JSON Data Interchange Syntax
• Introducing JSON
• Wikipedia: JSON
• JSON Schema Specification

To learn how to use this format with DataMeans, see the User Guide.