JavaScript Object Notation (.json)
RFC StandardJavaScript Object Notation (JSON) is a lightweight, human-readable text format for data interchange, supported by many programming languages and commonly used in web APIs.
Convert JSON to HTML
Free in-browser JSON to HTML converter. Convert files instantly on your device.
Compress JSON Online
Private - files never leave your device
Inspect & Metadata
Operating systems and file analyzers identify JSON files by inspecting the leading binary byte sequence:
Byte-Level Header Signature (Magic Bytes)
Operating systems and file analyzers identify JSON files by inspecting the leading binary byte sequence:
HEX SIGNATURE (OFFSET 0):
7B or 5BASCII REPRESENTATION: { or [
Standardization: RFC 8259 / ECMA-404 / ISO/IEC 21778
Technical Specifications
| Container Architecture | Lightweight, text-based, language-independent data interchange format |
| Compression | Gzip, Brotli, and Zstandard can compress JSON text; resulting size depends on the data and settings |
| Byte Endianness | UTF-8 encoded Unicode (no Byte Order Mark / BOM recommended) |
| Color Spaces | Not applicable |
| Channels & Structure | Six basic data types: object, array, string, number, boolean, null |
| Max Dimensions | Unbounded; limited only by parser memory and maximum string length |
| Transparency | Not applicable |
| Streaming & Progressive | NDJSON (Newline Delimited JSON) / JSON Lines enables progressive stream processing |
Technical Comparison Matrix: JSON vs Competitors
| Technical Attribute | JSON (Current) | YAML | XML | Protocol Buffers |
|---|---|---|---|---|
| Syntax Complexity | Minimal (6 types, strict syntax) | High (indentation-based, complex spec) | High (verbose closing tags, namespaces) | Schema-defined binary wire format |
| Parsing Performance | Extremely fast in all modern languages | Slow (complex indentation parsing) | Moderate to slow (heavy DOM construction) | Ultra-fast (zero-copy binary deserialization) |
| Comments Supported | No (deliberately excluded to prevent metadata creep) | Yes (# comments) | Yes (<!-- comments -->) | Yes in .proto files |
| Network Payload Size | Compact text; compression results depend on the data and settings | Compact text | Verbose text (heavy tag repetition) | Ultra-compact binary |
Common Corruption Modes & Hex Recovery Guide
SyntaxError: Unexpected token , in JSON at position X.
Root Cause: Trailing comma after the last item in an array or object, which is strictly illegal in RFC 8259 JSON.
Recovery: Remove trailing commas from object keys and array entries before passing to JSON.parse().
SyntaxError: Unexpected token ' in JSON.
Root Cause: Strings or keys enclosed in single quotes ('') instead of double quotes ("").
Recovery: Replace all single-quoted strings and keys with standard double-quoted strings.
Security Analysis & Parser Attack Vectors
JSON is text-only and safe from direct code execution, but parsing untrusted JSON can lead to Prototype Pollution, ReDoS, or memory exhaustion.
Known Attack Vectors
- Prototype Pollution: Keys named '__proto__' or 'constructor' modifying Object.prototype in JavaScript applications.
- Stack overflow denial of service via deeply nested JSON structures (e.g. 10,000 opening brackets).
- Loss of numeric precision: JavaScript numbers larger than 2^53 - 1 (9,007,199,254,740,991) silently lose precision.
Defensive Best Practices: Never evaluate JSON with eval(). Use JSON.parse() and sanitize '__proto__' properties in recursive object merge functions.
Historical Origins & Milestones
Key Advantages & Pros
- Human-readable, self-describing, and concise text structure.
- Native parsing support built into JavaScript engines (JSON.parse) and every major programming language.
- Strict specification prevents arbitrary code execution.
Technical Limitations & Cons
- No support for comments, trailing commas, or circular object references.
- No native binary types (binary data must be base64-encoded, inflating size by 33%).
- Inefficient serialization compared to binary formats like Protocol Buffers or MessagePack.
Interesting Technical Trivia
- Douglas Crockford added the software license clause 'The Software shall be used for Good, not Evil' to the original JSMin JSON tools.
- JSON is a strict subset of JavaScript syntax, but until ES2019, raw unescaped U+2028 and U+2029 characters were valid in JSON but invalid in JavaScript strings.
- Douglas Crockford discovered that early web browsers could evaluate JSON directly into objects using JavaScript's native eval() before dedicated JSON.parse() APIs were standardized in ECMAScript 5.
Frequently Asked Technical Questions
Why doesn't JSON allow comments?
JSON excludes comments from its grammar. Implementations can differ in how they handle extensions and application-specific data, so the format alone does not ensure interoperability.
How do you store 64-bit integers in JSON without losing precision?
JavaScript's native Number type is an IEEE 754 double-precision float, which only supports integers up to 2^53 - 1 precisely. 64-bit integers (like database IDs or timestamps) must be serialized as strings (e.g. '1234567890123456789') in JSON.
What is the difference between JSON and NDJSON / JSON Lines?
Standard JSON wraps an entire payload in a single root object or array, requiring parsers to load the entire text before evaluating. NDJSON (Newline Delimited JSON) separates individual valid JSON records with newline characters (\n), enabling memory-efficient line-by-line streaming of massive multi-gigabyte datasets.
Related JSON Conversion Pairs
Converting JSON data into HTML source transforms raw structured key-value pairs into human-readable web documents ready for browser rendering.
Converting HTML Source into JSON Data transforms human-readable web documents into structured key-value pairs for programmatic processing and API ingestion.
Converting an SQL Dump text script into a JSON data export transforms rigid relational database tables into flexible, nested objects for modern web apps.
Transforming unstructured JSON text files into structured SQLite relational databases allows fast indexing and querying of large data records.
Converting Adobe Swatch Exchange files to Color JSON structures transforms binary design palettes into readable text objects for modern web applications.
Converting Color JSON text data into Adobe ASE binary swatches bridges web-based design tokens and professional desktop layout applications.
Converting GIMP Palette text files to Color JSON structures allows web applications to read color swatches directly without complex parsing scripts.
Converting structured Color JSON files into CSS variables transforms raw data objects into native styling properties for websites.