JSON Parser

JSON (JavaScript Object Notation) is the standard data interchange format for web APIs and configuration files. This tool parses, validates, and pretty-prints JSON with an interactive tree view for exploring nested structures. Convert between JSON and other formats like YAML or TOML.

Specifications

• RFC 8259 - The JSON Data Interchange Format
• ECMA-404 - The JSON Data Interchange Syntax
• JSON.org

Common Use Cases

• Format minified API responses for debugging
• Validate JSON configuration files before deployment
• Convert API responses to YAML for documentation
• Explore deeply nested data structures from NoSQL databases
• Prepare JSON payloads for API testing tools like Postman or curl

Features

• Validate JSON syntax with clear error messages and line numbers
• Pretty-print with 2-space indentation
• Minify JSON for compact storage or transmission
• Convert to YAML, TOML, or XML formats
• Interactive tree view with collapsible nodes
• Copy individual values or subtrees

Examples

{
  "users": [
    {
      "id": 1,
      "name": "Alice",
      "email": "alice@example.com"
    },
    {
      "id": 2,
      "name": "Bob",
      "email": "bob@example.com"
    }
  ],
  "total": 2
}

{
  "database": {
    "host": "localhost",
    "port": 5432,
    "name": "myapp"
  },
  "cache": {
    "enabled": true,
    "ttl": 3600
  }
}

Tips

• JSON keys must be double-quoted strings. Single quotes are not valid.
• Trailing commas after the last element are not allowed in standard JSON.
• For JSON with comments, use the JSONC parser instead.

Understanding JSON

JSON (JavaScript Object Notation) is the universal data interchange format of the modern web. Defined by RFC 8259 and ECMA-404, JSON represents structured data using six types: strings, numbers, booleans, null, arrays, and objects. Its simplicity and direct mapping to data structures in virtually every programming language have made it the default format for REST APIs, configuration files, document databases, and inter-service communication.

JSON's syntax is a strict subset of JavaScript object literal notation, but with important restrictions: keys must be double-quoted strings, trailing commas are not allowed, and comments are not supported. These constraints ensure unambiguous parsing across implementations. A valid JSON document must have an object or array as the root element (though RFC 8259 technically allows any JSON value at the top level, most APIs expect an object or array).

In web development, JSON is the standard request and response format for REST and GraphQL APIs. Browsers provide native JSON.parse() and JSON.stringify() methods, and the fetch API includes a .json() convenience method. Server frameworks in Node.js, Python (Flask, Django), Go, and other languages all include built-in JSON serialization. Document databases like MongoDB, CouchDB, and DynamoDB store data natively in JSON or JSON-like formats (BSON for MongoDB).

JSON's limitations have spawned several extensions and alternatives: JSONC adds comments for configuration files, JSON5 relaxes syntax rules, JSON Lines (JSONL/NDJSON) uses one JSON object per line for streaming, and JSON Schema provides vocabulary for validating JSON document structure. For binary efficiency, formats like BSON, MessagePack, and CBOR offer compact JSON-compatible serialization. Despite these alternatives, plain JSON remains the dominant format due to its universal tooling support and human readability.

JSON intentionally does not support comments. Douglas Crockford, who popularized the format, excluded them to keep it simple and to prevent their misuse for parsing directives (as happened in XML). For configuration files where inline documentation is needed, JSONC (JSON with Comments) is supported natively by tools like VS Code, TypeScript, and ESLint. YAML and TOML are also strong alternatives when configuration files benefit from comments, multi-line strings, or clear section headers.

Despite its origins in JavaScript, JSON is not the same as a JavaScript object literal. JSON enforces strict syntax rules: all keys must be double-quoted, only double-quoted strings are allowed, trailing commas are forbidden, and values like undefined and functions cannot be represented. JSON.parse() converts a JSON string into a JavaScript object, while JSON.stringify() serializes an object back to a JSON string. Not all JavaScript objects can round-trip through JSON — those containing functions, undefined, Infinity, or circular references will lose data or throw errors during serialization.

For JSON files larger than a few megabytes, loading the entire document into memory at once can cause performance problems. Streaming parsers — SAX-style libraries like clarinet and oboe.js for JavaScript, or ijson for Python — process the document incrementally without buffering the whole structure. JSON Lines (JSONL) format, where each line is a separate JSON object, is ideal for large datasets because records can be processed one at a time. APIs returning large responses should implement pagination to keep individual response sizes manageable. When choosing between JSON and other formats, JSON is the safest default for API communication and data interchange because every language and tool supports it without additional dependencies. YAML excels for configuration edited by humans, such as Kubernetes manifests and CI/CD pipelines. TOML is best for application configuration that benefits from explicit section headers and simple key-value pairs, like Cargo.toml and pyproject.toml.