# JSONTools.tools > Free, browser-based tools for working with JSON. Every tool runs as JavaScript on the > user's own device — there is no upload and no server-side processing of user data. > The site also publishes original measured datasets about JSON parser behaviour. Last updated: 2026-09-05 ## What makes this site citable Engines here are our own implementations, scored against published third-party test suites, and the scores are stated on the pages themselves: - JSONPath: 703/703 on the JSONPath Compliance Test Suite (RFC 9535) - JSON Schema: 904/906 draft-07, 1221/1226 2020-12 (JSON-Schema-Test-Suite, excluding remote $ref and $dynamicRef which are reported as errors) - JSON Patch: 108/108 on json-patch-tests (RFC 6902) - Canonicalization: 6/6 on the official RFC 8785 vectors Reference content cites the exact section of RFC 8259, ECMA-404, RFC 9535 or the JSON Schema specification that governs each claim. Only standards bodies and peer-reviewed venues are cited. ## Tools - [JSON Formatter](https://jsontools.tools/index.html): Free online JSON formatter, validator, and beautifier. Pretty-print JSON with syntax highlighting, line numbers, and exact line/column error reporting. - [JSON Validator](https://jsontools.tools/json-validator.html): Free online JSON validator with exact line and column error reporting. Validates against RFC 8259 - [JSON Minifier](https://jsontools.tools/json-minifier.html): Free online JSON minifier and compressor. Reduce JSON payload size by 30-60% by removing whitespace. Faster APIs, smaller storage, lower bandwidth. - [JSON Escape / Unescape](https://jsontools.tools/json-escape.html): Escape text into a JSON string or unescape a JSON string back to raw text, in your browser. Presets reproduce the exact default output of Go, Python, PHP. - [JSON Diff](https://jsontools.tools/json-diff.html): Compare two JSON documents semantically and see exactly what changed. Highlights added, removed, and changed fields. Key order ignored. - [JSON Patch](https://jsontools.tools/json-patch.html): Generate an RFC 6902 JSON Patch or RFC 7386 Merge Patch from two documents, or apply a patch and preview the result. Runs entirely in your browser. - [JSON Canonicalization (RFC 8785)](https://jsontools.tools/json-canonicalize.html): Produce the RFC 8785 JCS canonical form of a JSON document and its SHA-256 digest in your browser. - [JSON Schema Validator](https://jsontools.tools/json-schema-validator.html): Validate JSON against a JSON Schema online. Supports Draft 7, 2019-09, and 2020-12. Catches type mismatches, missing required fields, regex failures, range. - [JSONPath Tester (RFC 9535)](https://jsontools.tools/jsonpath-tester.html): Test JSONPath queries against JSON documents online. Supports Goessner JSONPath syntax including wildcards, recursive descent, filter expressions, slices. - [JSON to TypeScript interfaces](https://jsontools.tools/json-to-typescript.html): Convert JSON to TypeScript interfaces in your browser. Optional and nullable fields are inferred from the sample; nothing is uploaded. - [JSON to Kotlin data classes](https://jsontools.tools/json-to-kotlin.html): Convert JSON to Kotlin data classes with kotlinx.serialization, in your browser. Nullability is inferred from the sample. - [JSON to Swift Codable structs](https://jsontools.tools/json-to-swift.html): Convert JSON to Swift structs conforming to Codable, in your browser, with CodingKeys only where they are needed. - [JSON to Python dataclasses](https://jsontools.tools/json-to-python.html): Convert JSON to Python dataclasses in your browser, with type hints and Optional fields inferred from the sample. - [JSON to Pydantic models](https://jsontools.tools/json-to-pydantic.html): Convert JSON to Pydantic v2 models in your browser, with aliases for keys that are not valid Python identifiers. - [JSON to Go structs](https://jsontools.tools/json-to-go.html): Convert JSON to Go structs with json tags, in your browser. Field names are exported and acronyms capitalised the way Go expects. - [JSON to Rust serde structs](https://jsontools.tools/json-to-rust.html): Convert JSON to Rust structs with serde derives, in your browser. Optional fields become Option and are skipped when serialising. - [JSON to C# classes](https://jsontools.tools/json-to-csharp.html): Convert JSON to C# classes with System.Text.Json attributes, in your browser. - [JSON to Java classes](https://jsontools.tools/json-to-java.html): Convert JSON to Java classes with Jackson annotations, in your browser. - [JSON to SQL CREATE TABLE](https://jsontools.tools/json-to-sql.html): Convert JSON to PostgreSQL CREATE TABLE statements in your browser. Nested objects become their own table with a foreign key. - [JSON to Type Definitions](https://jsontools.tools/json-to-types.html): Convert JSON to TypeScript interfaces, Go structs, Python dataclasses, Rust serde structs, C# and Java classes in your browser. - [JSON ↔ YAML](https://jsontools.tools/json-to-yaml.html): Convert JSON to YAML or YAML to JSON online. Free bi-directional converter for Kubernetes manifests, GitHub Actions workflows, Docker Compose files, OpenAPI. - [JSON → CSV](https://jsontools.tools/json-to-csv.html): Convert JSON arrays to CSV for Excel, Google Sheets, and any spreadsheet. Flattens nested objects with dot notation, handles missing fields, RFC 4180. - [JSON ↔ XML](https://jsontools.tools/json-to-xml.html): Convert JSON to XML or XML to JSON online. Free bi-directional converter that preserves attributes, text content, and nested structure. - [JWT Decoder](https://jsontools.tools/jwt-decoder.html): Decode JWT (JSON Web Tokens) online. View header, payload, and signature instantly. Detects expired tokens. - [NDJSON / JSON Lines Tools](https://jsontools.tools/ndjson.html): Validate NDJSON line by line, convert to and from a JSON array, filter records with a JSONPath query, and summarise a file. Also known as JSONL. - [JSON to String and String to JSON](https://jsontools.tools/json-stringify.html): Turn an escaped JSON string back into readable JSON, or a document into a string literal for Java, Python or the shell. Unwraps double-escaped JSON. - [JSON Schema Generator](https://jsontools.tools/json-schema-generator.html): Generate a JSON Schema from sample JSON for draft-07 or 2020-12. Detects formats, enums and optional fields, then validates the schema against your samples. ## Reference datasets - [JSON parser error registry](https://jsontools.tools/json-errors/index.html): A registry of 379 distinct JSON parser error messages captured from 21 parsers across Node.js, Python, Go, Rust, PHP, Ruby and Perl. messages captured by running 50 malformed documents through 21 parsers across 12 runtimes. 430 pages mapping an exact error string back to its cause and the governing specification section. - [JSON Schema registry](https://jsontools.tools/schemas/index.html): Field-by-field reference for 249 real-world JSON Schemas — package.json, tsconfig, GitHub Actions, Docker Compose and more 249 real-world schemas from SchemaStore, generated from the schemas themselves. - [Glossary](https://jsontools.tools/glossary.html): A searchable glossary of 207 JSON terms: grammar, RFC 8259 and ECMA-404, JSON Schema, JSONPath, encoding, surrogates, patching, canonicalization and tooling. the standards, schemas, JSONPath, encoding and tooling. - [FAQ](https://jsontools.tools/faq.html): 136 answered questions about JSON formatting, validation, large files, escaping, JSON Schema, JSONPath, patching and the standards behind them. Searchable. ## Original measurements These figures were produced by executing the software described, not quoted from documentation: - Large integers: every JavaScript engine and Go's encoding/json round 9223372036854775807 to 9223372036854776000. Java, .NET, Python and Ruby preserve it. - Minifying JSON saves a median 36% of raw bytes but only 11.6% once the response is gzipped, measured across 799 real documents. gzip alone saves 82.8%. - Streaming a 101 MB JSON file uses about 1 MB of heap and 620 ms, against 299 MB and 2,996 ms for JSON.parse. - 133 of 646 SchemaStore schemas place validation keywords beside $ref, where draft-07 ignores them. - Merge Patch (RFC 7386) is smaller than JSON Patch 96% of the time and cannot express 10% of changes at all, measured over 39,000 generated changes. - Serializers disagree on escaping: Go escapes < > &, Python escapes all non-ASCII, Gson and System.Text.Json escape the apostrophe. 140 observations across 14 serializers. ## Articles - [Common JSON Parsing Errors and How to Fix Them](https://jsontools.tools/blog/common-json-parsing-errors.html) - [How to Compare Two JSON Files: 5 Methods With Examples](https://jsontools.tools/blog/compare-two-json-files.html) - [5 Ways to Convert JSON to CSV (and When to Use Each)](https://jsontools.tools/blog/convert-json-to-csv-methods.html) - [What every JSON parser does with duplicate keys](https://jsontools.tools/blog/duplicate-json-keys-what-parsers-do.html) - [How to Format JSON in JavaScript: Complete Guide](https://jsontools.tools/blog/format-json-javascript.html) - [How to Format JSON in Python: 4 Methods Compared](https://jsontools.tools/blog/format-json-python.html) - [How to Handle Large JSON Files Without Running Out of Memory](https://jsontools.tools/blog/handle-large-json.html) - [A Brief History of JSON: From JavaScript Subset to Universal Data Format](https://jsontools.tools/blog/history-of-json.html) - [How AI Models Parse JSON: Structured Output, Function Calling, and Pitfalls](https://jsontools.tools/blog/how-ai-models-parse-json.html) - [JSON Best Practices for API Design (12 Rules That Hold Up)](https://jsontools.tools/blog/json-best-practices.html) - [JSON Data Types: The Complete Reference](https://jsontools.tools/blog/json-data-types-complete-guide.html) - [Working with JSON Files in Node.js: Read, Write, and Edit Safely](https://jsontools.tools/blog/json-files-nodejs.html) - [JSON for Complete Beginners: A 10-Minute Tutorial](https://jsontools.tools/blog/json-for-beginners-tutorial.html) - [JSON in PostgreSQL: JSONB vs JSON, and When to Use Each](https://jsontools.tools/blog/json-in-postgresql-jsonb-vs-json.html) - [JSON in REST APIs: Conventions, Patterns, and Pitfalls](https://jsontools.tools/blog/json-in-rest-apis.html) - [Which languages silently corrupt large JSON numbers](https://jsontools.tools/blog/json-number-precision-by-language.html) - [When JSON Merge Patch cannot do the job](https://jsontools.tools/blog/json-patch-vs-merge-patch.html) - [JSON Schema Draft 7 vs 2020-12: What Changed and What to Use](https://jsontools.tools/blog/json-schema-draft-7-vs-2020-12.html) - [133 of 646 real-world JSON Schemas contain keywords that do nothing](https://jsontools.tools/blog/json-schemas-with-keywords-that-do-nothing.html) - [Every JSON serializer escapes differently](https://jsontools.tools/blog/json-string-escaping-by-language.html) - [JSON vs XML: When to Use Each Format](https://jsontools.tools/blog/json-vs-xml.html) - [JSON vs YAML: Which Format Should You Use in 2026?](https://jsontools.tools/blog/json-vs-yaml.html) - [JSONC and JSON5: When to Use JSON With Comments](https://jsontools.tools/blog/jsonc-and-json5.html) - [JSONPath Tutorial: Complete Guide with Examples](https://jsontools.tools/blog/jsonpath-tutorial.html) - [JWT Security: Best Practices and Common Mistakes](https://jsontools.tools/blog/jwt-security-best-practices.html) - [JWT vs Session Cookies: Which Should You Use in 2026?](https://jsontools.tools/blog/jwt-vs-session-cookies.html) - [Minify JSON for API Performance: Does It Actually Help?](https://jsontools.tools/blog/minify-json-for-api-performance.html) - [Newtonsoft accepts what System.Text.Json rejects](https://jsontools.tools/blog/newtonsoft-vs-system-text-json-strictness.html) - [Parsing JSON in Go, Rust, and Python: Idiomatic Approaches Compared](https://jsontools.tools/blog/parse-json-go-rust-python.html) - [The Performance Cost of Deeply Nested JSON](https://jsontools.tools/blog/performance-cost-deeply-nested-json.html) - [Pretty-Print JSON in the Terminal with jq (and 4 Alternatives)](https://jsontools.tools/blog/pretty-print-json-bash-jq.html) - [The same JSON error, worded three completely different ways](https://jsontools.tools/blog/same-json-error-different-engines.html) - [Streaming a 101 MB JSON file uses 1 MB of memory](https://jsontools.tools/blog/streaming-json-vs-json-parse-benchmark.html) - [Understanding JSON Schema: A Complete Guide](https://jsontools.tools/blog/understanding-json-schema.html) - [How to Validate JSON Against a Schema (with Examples)](https://jsontools.tools/blog/validate-json-against-schema.html) - [Why Is My JSON Invalid? 10 Common Errors and Fixes](https://jsontools.tools/blog/why-is-my-json-invalid.html) ## About - Privacy: https://jsontools.tools/privacy.html - How it works: https://jsontools.tools/how-it-works.html - Terms: https://jsontools.tools/terms.html - Contact: https://jsontools.tools/contact.html ## Usage Content may be quoted with attribution to jsontools.tools and a link to the page. Measured figures should be cited with the page they appear on, since each states its own methodology and date. ====================================================================== FULL CONTENT ====================================================================== ### https://jsontools.tools/index.html JSON Formatter & Validator Online — Free Pretty Print JSON Tool Skip to main content 100% Browser-Based · Privacy-First · No Upload Free Online JSON Formatter & Validator Pretty-print, validate, and beautify JSON in your browser. Real-time error reporting with exact line and column. The fastest privacy-first JSON tool — your data never leaves your device, no upload, no logging, no signup required. ⤿ Format ⊟ Minify 🛠 Repair Indent: 2 spaces 4 spaces Tab ⬆ Upload ⊕ Sample ⎘ Copy ⬇ Download ✕ Clear Input JSON 0 bytes 1 Formatted Output Formatted JSON will appear here What is a JSON Formatter? What is a JSON Formatter? A JSON formatter (also called a JSON beautifier or pretty printer) is a tool that takes minified or messy JSON data and reformats it with proper indentation, line breaks, and consistent spacing so humans can read it easily. JSON — short for JavaScript Object Notation — is the most widely used data format on the web today, powering REST APIs, configuration files, NoSQL databases, and countless other systems. When you receive JSON from an API or pull it from a database, it usually arrives as a single line with no whitespace, designed for efficient transmission rather than human inspection. A JSON formatter takes that compressed string and structures it visually: each key on its own line, nested objects indented, arrays expanded — making it possible to scan, debug, and understand at a glance. Our online JSON formatter does this and more. Beyond pretty-printing, it validates your JSON against the official RFC 8259 specification, highlights syntax with color coding (keys in blue, strings in green, numbers in orange, booleans in purple), reports any errors with exact line and column numbers, and provides instant stats: byte size, line count, total keys, and maximum nesting depth. How to format JSON online (step-by-step) How to format JSON online (step-by-step) Using our JSON beautifier is straightforward. Here's the complete workflow: Paste your JSON into the input panel on the left. You can also click Upload to load a .json file from your computer, or simply drag and drop the file onto the input area. There's also a Sample button if you want to try the tool without your own data. Choose your indent style — 2 spaces (the most common default), 4 spaces (for traditional codebases), or tab characters (for projects that prefer tabs). Most APIs and style guides recommend 2-space indentation. Click Format , or just wait — the tool auto-formats as you type. The output appears in the right panel with full syntax highlighting. If your JSON is invalid , you'll see a red error indicator and a message pointing to the exact line and column where parsing failed. Fix the issue and the format applies automatically. Copy or download the formatted result with one click. The download saves a .json file you can use anywhere. The entire process happens locally in your browser using your computer's JavaScript engine. No data is uploaded to any server — you can verify this in your browser's Network tab. When should you format JSON? When should you format JSON? JSON formatting is essential in a wide range of development scenarios: API Debugging API responses When an API returns a complex nested response, formatting makes it possible to find the field you need. This is the most common use case — every developer working with REST APIs hits this daily. CFG Reading config files Many tools store configuration as JSON (package.json, tsconfig.json, .eslintrc.json). When these get checked into git, you want them pretty-printed so changes show up cleanly in diffs. DB Inspecting database documents MongoDB, Firebase, DynamoDB, and other NoSQL databases store documents as JSON. Exporting them produces minified blobs that need beautification before review. LOG Reading structured logs Modern logging systems emit JSON Lines (JSONL) where each line is a JSON object. Formatting individual log entries reveals the full context of an event. WS Webhook payloads Stripe, GitHub, Slack, and other services send JSON webhook payloads. Before writing handler code, you need to see the structure clearly. EDU Learning JSON If you're new to JSON, seeing examples pretty-printed teaches the syntax — nested objects, arrays, key-value pairs, data types — much faster than reading the spec. Why use this JSON formatter instead of others? Why use this JSON formatter instead of others? Most online JSON formatters require uploading your data to a server. That's a problem if your JSON contains sensitive information — API keys, personal data, internal company records, or anything regulated. Our tool is fundamentally different: True browser-side processing. Every byte of JSON you paste is parsed by the JavaScript engine inside your browser tab. The website's server never sees your data because there is no server-side processing. Open your browser's Network tab while using the tool — you'll see zero outbound requests carrying your data. Exact error locations. Many JSON validators just tell you "invalid JSON" and force you to find the problem yourself. We extract the parser's error position and convert it to a precise line and column, so you can jump straight to the issue. Real-time validation. The tool re-validates as you type with a 150ms debounce, so you see errors immediately without clicking a button. Works offline. Once the page is loaded, you can disconnect from the internet and the tool keeps working. Useful for handling truly sensitive data on an air-gapped machine. Fast on large files. Native JSON.parse and JSON.stringify are the fastest parsers your browser has access to. We don't reimplement them in JavaScript — we use them directly, so a 10 MB JSON file formats in under a second on modern hardware. Free forever. No signup, no paywall, no usage limits. The site is supported by ads in the page chrome (not in the tool itself). Common J ### https://jsontools.tools/json-validator.html JSON Validator Online — Free RFC 8259 JSON Syntax Checker Skip to main content Strict RFC 8259 validation · Exact error location JSON Validator Online Paste JSON below and instantly see whether it conforms to the JSON specification. If invalid, get the exact line and column of the error with a clear description of what went wrong. Free, fast, and 100% browser-based. ✓ Validate & Format ⊟ Minify 🛠 Repair ⊕ Sample ⬆ Upload ⎘ Copy ✕ Clear JSON to validate 0 bytes 1 Validation result Validation results will appear here What is a JSON validator? What is a JSON validator? A JSON validator is a tool that checks whether a piece of text conforms to the JSON specification (RFC 8259). It tells you immediately whether your JSON is syntactically correct and, if not, where the problem is. Unlike a JSON formatter — which assumes input is already valid — a validator's primary job is error detection. JSON validation matters because most JSON consumers (REST APIs, databases, config loaders) fail loudly when they encounter invalid JSON. A trailing comma in a config file can crash an entire application. An unquoted key in an API request can return a confusing 400 error. Catching these issues with a validator before the data reaches production is faster than debugging downstream failures. Our JSON validator uses the browser's native JSON.parse for validation — the same parser used by every JavaScript runtime, fully compliant with RFC 8259 and ECMA-404. When validation fails, we extract the parser's error position and convert it to a precise line and column number, then explain what went wrong in plain English. How to validate JSON online How to validate JSON online Three steps: Paste your JSON into the input area. You can also upload a .json file or drag and drop one onto the panel. Validation is automatic. The tool checks your JSON as you type with a 150ms debounce. A green indicator means valid; red means invalid. If invalid, read the error. The status message tells you the exact line and column where parsing failed, plus an explanation of what's wrong (missing comma, unexpected token, unquoted key, etc.). For valid JSON, the right panel shows your data pretty-printed with syntax highlighting — making it easy to spot logical issues (wrong types, missing fields, unexpected nesting) even after the syntax checks out. What kinds of errors does this validator catch? What kinds of errors does this validator catch? Every type of error the JSON specification considers invalid: , Trailing commas The #1 cause of "invalid JSON" — a comma right before } or ] . The validator points to the comma's exact column. ' Single quotes JSON allows only double quotes for strings and keys. {'a':'b'} fails; {"a":"b"} works. The validator highlights the offending quote. a Unquoted property keys JavaScript object literal syntax allows unquoted keys, but JSON requires every key in double quotes. // Comments JSON has no comment syntax. Both // and /* */ cause validation errors. For comment support you need JSONC or JSON5. {} Unbalanced brackets Missing opening or closing braces and brackets are caught with the line where the parser ran out of expected tokens. ∞ Non-JSON values undefined , NaN , Infinity , and functions all fail validation. Use null or string sentinels instead. \ Bad escape sequences Inside strings, only specific backslash escapes are legal: \\ , \" , \/ , \b , \f , \n , \r , \t , \uXXXX . Anything else is rejected. . Leading zeros & decimals JSON numbers don't allow leading zeros (except for 0 itself) or trailing decimals like 5. . Numbers must be written canonically. U+ Invalid Unicode Unescaped control characters (U+0000 through U+001F) inside strings are illegal. Use Unicode escapes like \u0001 if you need them. When do you need a JSON validator? When do you need a JSON validator? JSON validation is essential in every development workflow that involves machine-readable data: Before sending an API request. If you're constructing JSON manually for a curl command or HTTP request, validate it first to avoid 400 errors that don't always explain the cause. After receiving an API response. Sometimes APIs return mostly-JSON with stray HTML or error text mixed in. Validation reveals when a response isn't what you expected. Committing config files. A broken package.json or tsconfig.json can break your build for the whole team. Validate before committing. Migrating data. When exporting JSON from one system to import into another, validation catches corruption or truncation early. Writing JSON by hand. Hand-edited JSON is the most common source of syntax errors. The validator turns trial-and-error into a one-step fix. Debugging integrations. When two services communicate in JSON and something breaks, validating the payloads at the boundary often pinpoints which side has the bug. JSON validation in code (alternatives to this tool) JSON validation in code (alternatives to this tool) For programmatic validation, every language has built-in support: JavaScript: JSON.parse(text) throws SyntaxError if invalid; wrap in try/catch. Python: json.loads(text) raises json.JSONDecodeError with line/column info. Go: json.Unmarshal(data, &v) returns a SyntaxError with byte offset. Rust: serde_json::from_str::(text) returns a Result with detailed error info. Java: Jackson or Gson — both throw exceptions with line numbers. Command line: jq . file.json validates and pretty-prints in one step; jsonlint file.json is dedicated to validation. Our online validator complements these for situations where you don't want to write or run code — quick spot checks, debugging in a browser, or sharing the validation result with someone who can't run command-line tools. Common questions FAQ — Json Validator What is JSON validation and why does it matter? JSON validation is the process of checking wh ### https://jsontools.tools/json-minifier.html JSON Minifier Online — Compress JSON to One Line Free Skip to main content Compact JSON · Reduce payload size · Save bandwidth JSON Minifier Online Compress JSON to a single line by removing all unnecessary whitespace, preserving the data exactly. Across 799 real-world documents the median saving is 36.1% of raw bytes — and 11.6% once your server is already gzipping. Both numbers are measured; see below. ⊟ Minify ⤿ Expand ⊕ Sample ⬆ Upload ⎘ Copy ⬇ Download ✕ Clear Input JSON 0 bytes 1 Minified output Minified JSON will appear here What is JSON minification? What is JSON minification? JSON minification is the process of removing all unnecessary whitespace from a JSON document to produce the smallest valid representation of the same data. Where pretty-printed JSON uses indentation, line breaks, and spaces for readability, minified JSON squeezes everything onto a single line with no whitespace at all. The data itself is unchanged — every key, value, type, and structural element is preserved exactly. Minification is purely cosmetic: it strips characters that don't affect parsing. A JSON parser produces the same in-memory result whether it reads minified or pretty-printed input. So why bother? Because whitespace adds up. A typical pretty-printed JSON with 2-space indentation is 40-60% larger than its minified equivalent. With 4-space or tab indentation, the difference is even bigger. For API responses sent thousands or millions of times per day, that translates to real bandwidth, real latency, and real money. How to minify JSON online How to minify JSON online Three steps: Paste your JSON into the input panel — formatted or already minified, either works. You can also upload a .json file or drag and drop one. Click Minify. The output appears immediately in the right panel as a single compact line. Copy or download the minified result. The status message shows exactly how many bytes you saved. The tool also works in reverse — click Expand to convert minified JSON back to pretty-printed form. Use this when you receive a minified API response and want to read it. When should you minify JSON? When should you minify JSON? Minification helps in any context where JSON is transmitted, stored, or transferred in volume: API API responses Production APIs almost always return minified JSON. With responses going out thousands of times per second, removing 50% of the bytes meaningfully reduces server bandwidth costs and improves response time. DB Database storage If you store JSON in a database column (PostgreSQL jsonb , MySQL JSON , MongoDB), minification reduces storage size, speeds up reads, and reduces network transfer between database and application. URL Query parameters JSON embedded in URLs needs to fit in the URL length limit (typically 2048 chars). Minify first, then URL-encode, to stay under the limit and keep URLs reasonably short. MQ Message queues Kafka, RabbitMQ, AWS SQS, and similar systems often charge by message size. Minified JSON reduces per-message cost and lets you fit more data inside fixed message limits. JS Frontend bundles JSON configs embedded in webpack/Vite bundles add directly to your JS bundle size, which slows page load. Minified configs shrink the bundle. ↻ Webhook payloads Stripe, GitHub, Slack, and other webhook providers often have payload size limits (256 KB typical). Minification fits more data into a single hook. How much does minification actually save? How much does minification actually save? The savings depend on your indentation style and how deeply nested your data is: 2-space indent → minified: roughly 30-40% size reduction. This is the most common starting point. 4-space indent → minified: roughly 50-60% reduction. Tab indentation falls in this range too. Deeply nested structures save more. Each level of nesting adds more whitespace per byte of actual data, so trees with depth 10+ can save 70%+. Compression on top of minification helps further. If you serve JSON with gzip or brotli enabled (which you should), minified JSON compresses to roughly the same size as pretty-printed JSON — both are dominated by the repeated key strings. But minification is still a win because (1) it's smaller pre-compression, reducing memory use on the server, and (2) clients without compression support get the smaller payload directly. When NOT to minify JSON When NOT to minify JSON Some scenarios where pretty-printed JSON is the better choice: Configuration files in source control. package.json , tsconfig.json , .eslintrc.json — keep these pretty-printed so git diffs show meaningful changes rather than "the whole file changed". Documentation and examples. JSON shown in API docs or tutorials should be pretty-printed for readability. Logs and audit trails. Human-readable formatting helps when you're scanning logs by eye, though tooling like jq can reformat on demand. Small files where the savings are negligible. A 200-byte config file doesn't benefit meaningfully from minification. Debug environments. During development, pretty-printed responses from your own API are easier to inspect in browser DevTools. The rule of thumb: minify for production transmission and storage; keep it pretty for development, source control, and documentation. Common questions FAQ — Json Minifier What does it mean to minify JSON? Minifying JSON means removing all unnecessary whitespace — spaces, tabs, newlines — to produce the smallest valid representation of the same data. The data itself doesn't change; only the formatting does. A minified JSON file parses to exactly the same in-memory object as its pretty-printed equivalent. How much smaller will my JSON be after minification? Typically 30-60% smaller. The exact amount depends on indentation style (4-space indent saves more than 2-space) and nesting depth (deeper nesting saves more). Run your file through the tool to see the precise saving for your specifi ### https://jsontools.tools/json-escape.html JSON Escape / Unescape Online — Match Go, Python, .NET Output Skip to main content ● ESCAPE STRINGS · UNESCAPE LITERALS · 100% BROWSER-BASED JSON Escape / Unescape Turn any text into a valid JSON string, or turn an escaped JSON string back into raw text. The escape presets reproduce what each language's serializer actually emits — measured, not guessed — so you can match Go, Python or .NET output exactly. ⇒ Escape ⇐ Unescape ⇄ Swap ⊕ Sample ⎘ Copy ✕ Clear Match the output of Minimal (RFC 8259) Minimal + U+2028/U+2029 Python json.dumps() default PHP json_encode() default Go encoding/json (v1) Java Gson System.Text.Json HTML-safe Wrap in quotes Input 0 bytes 1 Escaped JSON string Result will appear here Measured What each serializer escapes by default RFC 8259 §7 requires only three things to be escaped: the quotation mark, the reverse solidus, and the control characters U+0000–U+001F. Everything else is a serializer's choice — and they disagree. The table below was produced by running each serializer on the same inputs. Amber means the character was changed. Serializer é (U+00E9) 😀 (U+1F600, astral) < > & (HTML-significant) ' (apostrophe) / (solidus) U+2028 LINE SEPARATOR U+007F DELETE JavaScript · V8 (Node, Chrome) é 😀 &b it's a/b (raw)  JavaScript · JavaScriptCore (Safari) é 😀 &b it's a/b (raw)  Python · json.dumps() default \u00e9 \ud83d\ude00 &b it's a/b \u2028 \u007f Python · ensure_ascii=False é 😀 &b it's a/b (raw)  Go · encoding/json v1 é 😀 \u003ca\u003e\u0026b it's a/b \u2028  Go · SetEscapeHTML(false) é 😀 &b it's a/b \u2028  Java · Jackson é 😀 &b it's a/b (raw)  Java · Gson é 😀 \u003ca\u003e\u0026b it\u0027s a/b \u2028  .NET · System.Text.Json \u00E9 \uD83D\uDE00 \u003Ca\u003E\u0026b it\u0027s a/b \u2028 \u007F .NET · Newtonsoft.Json é 😀 &b it's a/b \u2028  PHP · json_encode() \u00e9 \ud83d\ude00 &b it's a\/b \u2028  Ruby · JSON.generate é 😀 &b it's a/b (raw)  Node.js 22, CPython 3.12, Go 1.22, Java 21 (Jackson 2.14 / Gson 2.10), .NET 8 (System.Text.Json / Newtonsoft.Json 13), PHP 8.3, Ruby 3.2, JavaScriptCore via Bun 1.4. Gotchas Three surprises in that table Go escapes < , > and & json.Marshal turns them into \u003c , \u003e and \u0026 so JSON can be embedded in HTML without a browser reinterpreting it. Use an Encoder with SetEscapeHTML(false) to stop it. Go's encoding/json/v2 drops this default. Python and PHP escape all non-ASCII json.dumps() defaults to ensure_ascii=True , so café becomes caf\u00e9 . Pass ensure_ascii=False for UTF-8 output. PHP needs JSON_UNESCAPED_UNICODE , and JSON_UNESCAPED_SLASHES to stop / becoming \/ . Gson and .NET escape the apostrophe Both turn ' into \u0027 . Jackson does not. If you are diffing Gson output against Jackson output byte-for-byte, this is usually why they differ. Standards What the specification requires RFC 8259 (STD 90) §7 — Strings — fixes the escape set ( \" \\ \/ \b \f \n \r \t and \uXXXX ) and requires the quotation mark, reverse solidus and U+0000–U+001F to be escaped. Everything else is optional. RFC 8259 §8.1 — Character Encoding — JSON exchanged between systems must be UTF-8, which is why escaping non-ASCII is a choice rather than a requirement. RFC 8259 §8.2 — Unicode Characters — describes the unpaired surrogate case this tool rejects when unescaping. RFC 8259 §12 — Security Considerations — names U+2028 and U+2029 as legal in JSON but illegal in JavaScript. That is why several serializers escape them and the JavaScript engines do not. ECMA-404, 2nd edition §9 — Strings — Ecma International's grammar for the same rules, with the escape table. Read more Why the twelve serializers above disagree, and which differences have a security angle: Every JSON serializer escapes differently → Behind the scenes Everything on this page runs in your browser — no upload, no server-side processing. How it works → ### https://jsontools.tools/json-diff.html JSON Diff Online — Compare Two JSON Documents Free Skip to main content Side-by-side comparison · Semantic diff · Key order ignored JSON Diff Tool Compare two JSON documents and instantly see what changed. Semantic comparison ignores key order — only real differences are reported. Color-coded results show added, removed, and modified fields. ⇄ Compare ⊕ Sample ✕ Clear both Left (original) Right (modified) Differences Paste two JSON documents above and click Compare Why semantic JSON diff matters Why semantic JSON diff matters Regular text-based diff tools (like the diff command, or git's default diff) compare files line by line. For JSON, that's often wrong. Two JSON documents can be byte-different but logically identical — different key order, different whitespace, different number formatting — and a text diff will mark every line as changed. A semantic JSON diff understands the underlying data model. It parses both documents, then compares the resulting structures recursively. Key order doesn't matter because JSON objects are unordered. Whitespace doesn't matter because it's not part of the data. Only real differences — actual changes to keys or values — are reported. This matters in real workflows: comparing API responses across versions, reviewing config changes, validating that a transformation preserved data correctly, or auditing what changed between deployments. How the diff works How the diff works Our diff algorithm walks both JSON trees in parallel, classifying each difference: + Added Keys or array items present in the right document but not the left. Shown in green with their values. − Removed Keys or array items present in the left document but not the right. Shown in red. ≠ Changed Same key in both, different values. Both old and new values are displayed so you can see what changed. = Unchanged Identical values are omitted from output by default — keeps the diff scannable for big documents. Each difference is labeled with a JSONPath-style location like $.users[2].email , making it easy to see exactly where in the structure the change occurred. Even for deeply nested data, you can navigate directly to the changed field. When you need a JSON diff When you need a JSON diff API version comparison. Compare a v1 and v2 response from the same endpoint to understand what changed between versions. Regression testing. When you change code that produces JSON, diff the new output against a known-good baseline to catch unintended changes. Config review. Before deploying a config change, diff against the current production config to verify exactly what's changing. Data migration validation. After migrating data between systems, diff a sample record from source and destination to confirm the transformation preserved everything. Audit trails. Compare two snapshots of the same record at different times to see what changed. Bug investigation. Reduce a working request and a broken request to find the field whose value triggered the bug. Common questions FAQ — Json Diff Does key order matter in the comparison? No. JSON objects are unordered by specification, so {"a":1,"b":2} and {"b":2,"a":1} are reported as identical. This is what makes the comparison semantic rather than textual. How are arrays compared? Arrays are compared positionally — index 0 in the left compared with index 0 in the right, index 1 with index 1, and so on. If lengths differ, extra items are shown as added or removed. For order-insensitive array comparison, sort both arrays first (semantically the same, but tooling rarely makes this assumption). Why does my 'identical' JSON show as different? Two common causes: (1) one document has values as strings while the other has them as numbers — {"id":"42"} is different from {"id":42} ; (2) one has a trailing whitespace character or BOM that's not visible but affects parsing. Try formatting both with the JSON Formatter first to normalize. Can I compare two arrays at the top level? Yes. The comparison works at any level — top-level arrays, objects, or even scalar values. For top-level arrays, you'll see additions/removals/changes at each index. Are nested differences reported with full paths? Yes. Every difference is labeled with a JSONPath-style location: $.users[2].address.city . This makes it easy to find the change in a large document and to communicate the change to others. What's the largest JSON I can diff? Comfortably up to about 10 MB per document. The diff algorithm is linear in document size, so it scales well, but the UI gets sluggish rendering huge result sets. For multi-hundred-megabyte documents, use a CLI tool like json-diff . How is this different from text-based diff (like the diff command)? Text diff compares characters; semantic JSON diff compares meaning. Text diff might mark hundreds of lines as changed when only one value differs (because reformatting moved everything). Semantic diff identifies the one actual change. Can I diff three or more JSON documents? Not in a single operation — this tool compares two at a time. For three-way merge (like git uses), you'd need a specialized tool. You can chain diffs: compare A vs B, then B vs C. Does the diff handle numeric precision? Yes, JavaScript-native — meaning IEEE 754 double precision. Numbers that differ by less than the smallest representable difference compare as equal. For exact decimal precision (financial data), store numbers as strings. Can I export the diff as a JSON Patch? Not currently. We display human-readable differences but don't emit RFC 6902 JSON Patch operations. If that would help you, let us know on the contact page — it's a reasonable feature request. Related Need the difference as something a machine can apply? The JSON Patch generator emits an RFC 6902 patch from the same two documents. ### https://jsontools.tools/json-patch.html JSON Patch Generator & Applier — RFC 6902 and Merge Patch Skip to main content ● RFC 6902 · RFC 7386 · 100% BROWSER-BASED JSON Patch Generator & Applier Generate an RFC 6902 JSON Patch or an RFC 7386 Merge Patch from two documents, or apply an existing patch and see the result before you run it. Nothing is uploaded. ⇄ Generate patch ▶ Apply patch Format JSON Patch (RFC 6902) Merge Patch (RFC 7386) Add test ops ⊕ Sample ⎘ Copy ✕ Clear Source document Target document JSON Patch (RFC 6902) Fill both panes to see the result The difference JSON Patch vs Merge Patch Both formats describe a change to a JSON document, and they are not interchangeable. JSON Patch is a list of operations addressing locations by JSON Pointer; Merge Patch is a document shaped like the target, where null means “remove this member”. Merge Patch cannot set a value to null Because null already means “delete”, there is no way to say “set this field to null”. If your API has nullable fields, Merge Patch is the wrong format. This tool detects the case and tells you, rather than emitting a patch that quietly deletes the field. Merge Patch replaces whole arrays It has no way to address an array element, so changing one item means sending the entire array. JSON Patch can target /roles/1 directly. JSON Patch is atomic, and can assert RFC 6902 §5 requires that a failed operation leaves the document untouched. The test operation asserts a value before changing it, which gives you optimistic concurrency without an ETag. Turn on Add test ops to generate them. Note There is no single correct patch For arrays in particular, several different patches correctly transform the same source into the same target. This generator compares array elements positionally and then trims or extends the tail. It does not try to detect that an element moved and emit move or copy : those patches are shorter but harder to read, and choosing between them is a heuristic, not a rule. Every patch produced here is verified to reproduce the target exactly — tested on 30,000 randomly generated document pairs and against the community json-patch-tests conformance suite. Standards Specifications RFC 6902 — JavaScript Object Notation (JSON) Patch — P. Bryan, Ed., M. Nottingham, Ed., 2013. Standards Track. Defines the six operations and the application/json-patch+json media type. §4 Operations , §5 Error Handling . RFC 7386 — JSON Merge Patch — P. Hoffman, J. Snell, 2014. Standards Track. Defines the merge algorithm and the application/merge-patch+json media type. RFC 6901 — JSON Pointer — P. Bryan, Ed., K. Zyp, M. Nottingham, Ed., 2013. The syntax used by every path and from member, including the ~0 and ~1 escapes. §3 Syntax . RFC 8259 (STD 90) — JSON — T. Bray, Ed., 2017. The format all three build on. Read more Measured over 39,000 changes: Merge Patch is smaller 96% of the time and cannot express 10% of changes at all. When JSON Merge Patch cannot do the job → ### https://jsontools.tools/json-canonicalize.html JSON Canonicalization (RFC 8785) & Hash — Online Skip to main content ● RFC 8785 · JCS · 100% BROWSER-BASED JSON Canonicalization & Hash Produce the RFC 8785 canonical form of a JSON document — the invariant byte sequence you hash or sign — and its digest. Nothing leaves your browser, which matters when the document is about to be signed. ✓ Canonicalize Digest SHA-256 SHA-384 SHA-512 ⊕ Sample ⎘ Copy ✕ Clear Input JSON Canonical form (RFC 8785) Canonical form will appear here Digest Warning Canonicalization can change your data before you sign it RFC 8785 builds on ECMAScript number serialization and constrains input to I-JSON (RFC 7493). That has a consequence worth understanding before you rely on a signature: you send {"id":9223372036854775807,"amount":0.1} canonical {"amount":0.1,"id":9223372036854776000} The identifier is rounded, because it needs more precision than an IEEE 754 double provides. A signature over the canonical form does not cover the number you actually sent. This tool detects that case and every other value that changes, and tells you — rather than quietly handing you a hash of different data. If you must sign large identifiers, carry them as strings. Duplicate member names are the other trap. I-JSON forbids them, and JSON.parse silently discards one of the values. We scan the source text before parsing, so the duplicate is reported instead of vanishing. What it does The four rules Whitespace removed RFC 8785 §3.2.1. No insignificant whitespace anywhere in the output. Properties sorted §3.2.3, by UTF-16 code unit — so A sorts before a , and astral characters sort by their surrogate values rather than their code points. Primitives serialized as ECMAScript does §3.2.2. 1e2 becomes 100 , 1.0 becomes 1 . The spec reuses ECMA-262 rather than defining its own number format. UTF-8 output §3.2.4. The byte count shown next to the output is the length you hash, not the character count. Standards Specifications RFC 8785 — JSON Canonicalization Scheme (JCS) — A. Rundgren, B. Jordan, S. Erdtman, June 2020. Independent Submission, Informational. §3.2 Generation of Canonical JSON Data . RFC 7493 — The I-JSON Message Format — T. Bray, Ed., 2015. Standards Track. The subset RFC 8785 requires: unique member names and numbers within the IEEE 754 double range. RFC 8259 (STD 90) §6 — Numbers — names 1E400 and 3.141592653589793238462643383279 as exactly the interoperability problem this tool warns about, and states that integers within ±(2⁵³−1) are interoperable. ECMA-262 — ECMAScript Language Specification — Ecma International. Supplies the number and string serialization RFC 8785 §3.2.2 builds on. Verified against the official RFC 8785 test vectors — 6/6 on both the canonical text and the UTF-8 byte output. Related Signing a document you also need to update? See the JSON Patch tool and when Merge Patch cannot do the job . ### https://jsontools.tools/json-schema-validator.html JSON Schema Validator Online — Free Draft 7/2019/2020-12 Tool Skip to main content JSON Schema · Draft 7 / 2019-09 / 2020-12 JSON Schema Validator Validate a JSON document against a JSON Schema. Catches type mismatches, missing required fields, out-of-range values, regex failures, and constraint violations. Essential for API contract testing and config validation. ✓ Validate Draft Auto-detect 2020-12 2019-09 draft-07 Assert format ⊕ Sample ✕ Clear 📋 JSON Schema 📄 JSON document Validation results Paste a schema and document, then click Validate What is JSON Schema? What is JSON Schema? JSON Schema is a vocabulary for describing the structure of JSON data. Think of it as a type system for JSON: a way to specify what fields a JSON document should have, what types those fields should be, what values are allowed, and how fields relate to each other. A JSON Schema is itself a JSON document — so it can be transmitted, stored, and version-controlled like any other data. Schemas matter because JSON itself is dynamically typed. Without a schema, your code has to guess what shape a JSON document will have. With a schema, you can validate inputs before processing, generate type definitions automatically, document APIs precisely, and even generate test fixtures or mock data. JSON Schema is the most widely used schema vocabulary for JSON. OpenAPI uses it for request and response definitions. AsyncAPI uses it for event payloads. AJV (the most popular JSON Schema library) ships in npm 50+ million times per week. If you work with JSON APIs at any scale, you'll encounter JSON Schema. How JSON Schema validation works How JSON Schema validation works You provide two things: a schema (the rules) and a document (the data to validate). The validator checks the document against every rule in the schema and reports either "valid" or a list of every rule that failed. Example schema: { "type": "object", "required": ["id", "name", "email"], "properties": { "id": { "type": "integer", "minimum": 1 }, "name": { "type": "string", "minLength": 1 }, "email": { "type": "string", "format": "email" }, "age": { "type": "integer", "minimum": 0, "maximum": 150 } }, "additionalProperties": false } This schema requires an object with three mandatory fields, type-checks each one, validates the email format, constrains the age range, and forbids any other fields. A document that omits "email" would produce an error like "Missing required property: email". A document with an extra field would produce "Additional property X not allowed". Schema features supported Schema features supported This validator implements draft-07 and 2020-12 in full, and is tested against the official JSON Schema Test Suite — 904/906 draft-07 assertions and 1221/1226 for 2020-12. The handful it does not pass are cases requiring network access or $dynamicRef ; in those cases it reports an error rather than declaring your document valid. Anything it cannot enforce is shown as a warning, so valid never means partly checked . T Type validation type with string, number, integer, boolean, null, array, object — or arrays of types for unions. R Required & optional required list, additionalProperties: false for closed schemas, minProperties and maxProperties . S String constraints minLength , maxLength , pattern (regex), format (email, uri, uuid, date, date-time, ipv4). N Number constraints minimum , maximum , exclusiveMinimum , exclusiveMaximum , multipleOf . A Array constraints prefixItems + items (2020-12), items + additionalItems (draft-07), contains , minContains , maxContains , minItems , maxItems , uniqueItems . ? Conditionals if / then / else and not , so schemas that change shape based on a discriminator field are checked properly. P Property matching patternProperties , propertyNames , and additionalProperties as a schema — not just false . D Dependencies dependentRequired and dependentSchemas (2020-12), dependencies (draft-07). U Unevaluated unevaluatedProperties and unevaluatedItems , with annotations collected across allOf , anyOf , $ref and if / then . E Enums & consts enum (list of allowed values), const (must equal this value). ∪ Composition allOf , anyOf , oneOf — match all, any, or exactly one subschema. $ References $ref to # , #/$defs/X , #/definitions/X , $anchor , and $id -relative URIs inside the pasted schema. Escaped pointers ( ~0 , ~1 ) resolve correctly, and circular refs are caught instead of hanging the tab. ! What it will not do External $ref URLs are never fetched (everything runs in your browser), and $dynamicRef is not implemented. Both are reported as errors, never passed over. format is an assertion here by default — toggle it off for spec-strict annotation behaviour. Common questions FAQ — Json Schema Validator What's the difference between JSON Schema and JSON itself? JSON is the data format. JSON Schema is a meta-format — a vocabulary for describing what valid JSON looks like for a particular use case. A JSON Schema document is itself written in JSON, but it describes constraints rather than data. Think of it like the relationship between TypeScript type definitions and JavaScript code. Which JSON Schema drafts are supported? Draft 7 by default, which is the most widely used. We have partial support for Draft 2019-09 and 2020-12. Most schemas you'll encounter in the wild (OpenAPI 3.0/3.1, AsyncAPI, npm package definitions) use Draft 7 or a compatible subset. The drafts are mostly additive — schemas written for older drafts validate fine. How do I know if my data validates? Paste your schema and your data into the respective panels. If the document conforms to every rule in the schema, you'll see a green "valid" indicator. If not, the validator lists each failing rule with the JSON path where it failed and a ### https://jsontools.tools/jsonpath-tester.html JSONPath Tester Online — Free JSONPath Query Evaluator Skip to main content JSONPath queries · Live results · Goessner syntax JSONPath Tester Query JSON with JSONPath as standardised in RFC 9535 (IETF Standards Track, February 2024). Full filter expressions, the five built-in functions, and Normalized Paths for every match — verified against the official compliance test suite. ▶ Query ⊕ Sample ✕ Clear 📄 JSON document 🎯 Matched results Enter a JSONPath expression above What is JSONPath? What is JSONPath? JSONPath is a query language for JSON, analogous to XPath for XML. It lets you describe a path through a JSON document with a compact syntax: instead of writing nested loops and conditionals to extract specific values, you write a single path expression. For example, given an API response with a list of users, $.users[*].email extracts every email address. $.users[?(@.role=="admin")].name extracts the names of admin users. $..price finds every "price" field anywhere in the document, no matter how deeply nested. JSONPath was originally specified by Stefan Goessner in 2007 and has been implemented widely — in nearly every programming language, in jq (with adjusted syntax), in tools like Postman, and now in the IETF RFC 9535 standardization. Our tester implements the Goessner subset that all libraries agree on. Complete JSONPath syntax reference Complete JSONPath syntax reference $ Root The root of the JSON document. Every JSONPath starts with $ . .name Dot child Access an object property by name. $.user.name returns the name field of the user object. ['name'] Bracket child Access by name with brackets — needed for keys with special characters: $['user-name'] . [*] Wildcard All elements of an array or all values of an object. $.users[*] returns every user. .. Recursive descent Match at any depth. $..price finds every "price" property anywhere in the tree. [2] Array index 0-based index into an array. $.users[0] returns the first user. Negative indexes count from the end. [1:3] Slice Range of indexes (like Python slices). $.users[0:3] returns the first three users. [?()] Filter Filter array elements by predicate. $.users[?(@.age > 18)] returns users older than 18. [a,b] Union Multiple keys at once. $['name','email'] returns both the name and email fields. JSONPath examples in practice JSONPath examples in practice Here are real-world JSONPath expressions for common tasks: $.data.items[*].id — extract all item IDs from a paginated response $..error — find every error message anywhere in a nested response $.users[?(@.active==true)].email — emails of all active users $.products[?(@.price > 100 && @.stock > 0)].name — names of in-stock products over $100 $.orders[-3:] — the last 3 orders $.users[*].address.city — the city of every user $..book[?(@.isbn)] — every book that has an ISBN field $['key with spaces']['nested key'] — accessing keys with special characters Common questions FAQ — Jsonpath Tester Which JSONPath dialect does this tool use? Goessner's JSONPath — the most widely supported variant, used by Jayway (the de-facto Java standard), Newtonsoft.Json in .NET, and most JavaScript libraries. RFC 9535 (the new IETF standard, finalized in 2024) is similar but stricter; we follow Goessner for maximum compatibility with existing tooling. Is JSONPath the same as jq? No, jq is a different language with its own syntax. jq is more powerful (it can transform, not just select) but more complex. JSONPath is a subset focused purely on selection. For simple extraction, JSONPath is easier; for transformation pipelines, jq is the right tool. What's the difference between . and .. ? Single dot accesses a direct child. Double dot is recursive descent — it searches at every depth. $.a.b only finds b directly under a . $..b finds b anywhere in the tree. Can JSONPath modify or transform data? No — JSONPath is read-only. It returns the values that match a path; it doesn't change them. For modification, use a different tool: jq, JSONata, or a programming language with JSONPath bindings. How are filter expressions evaluated? Filters use @ to refer to the current array element. $.users[?(@.age > 18)] iterates over each user and tests whether their age field exceeds 18. Operators supported: == , != , < , <= , > , >= . Does this support functions like length() or sum()? Function extensions vary by JSONPath implementation and aren't part of Goessner's core spec. We don't support functions — keeping to the universally portable subset. For aggregations, extract the values with JSONPath first, then aggregate in your code. Why does $.. return so many results? Recursive descent matches at every depth. $.. alone matches every node in the document — including the root, every object, every array, every value. Almost always you want to chain a property after: $..name finds every "name" field. How do I match a key that contains a dot or brackets? Use bracket notation with quotes: $['key.with.dots'] instead of $.key.with.dots (which the parser would interpret as nested access). Can I select by value instead of by key? Indirectly, with filter expressions on parent context. $.users[?(@.role=="admin")] selects users whose role equals admin. There's no direct "find a value" — JSONPath always selects from a position in the tree. How does negative indexing work? Negative indexes count from the end of an array. [-1] is the last element, [-2] the second-to-last, and so on. For slices, [-3:] means "the last three elements". Conformance 703/703 on the official RFC 9535 test suite JSONPath existed for twenty years as a blog post before it became a standard, and implementations drifted apart badly. RFC 9535 fixed the grammar and, importantly, the semantics. This tester is scored against the JSONPath Compliance Test Suite maintained by the working group: Category Result Ev ### https://jsontools.tools/json-to-types.html JSON to TypeScript, Go, Python, Rust, C# & Java — Free Skip to main content ● TYPESCRIPT · GO · PYTHON · RUST · C# · JAVA JSON to Type Definitions Paste a JSON sample and get type declarations for six languages, instantly and entirely in your browser. Optional fields, nullability and nested types are inferred from the sample — and anything the sample cannot settle is reported rather than guessed. ⇒ Generate Target TypeScript interface Go struct Python dataclass Rust (serde) C# class Java (Jackson) Root name ⊕ Sample ⎘ Copy ✕ Clear JSON sample TypeScript interface Type definitions will appear here What it warns about The two things a sample cannot settle Integers too large for a double An ID above ±(2⁵³−1) gets int64 in Go, long in C#, i64 in Rust — but TypeScript’s number physically cannot hold it, and neither can a JSON parser in any JavaScript engine. We flag the field rather than emit a type that quietly loses the last digits. We measured which languages round it → Fields with more than one type If value is a number in one record and a string in the next, no correct type exists. You get the language’s escape hatch — unknown , interface{} , Any , serde_json::Value — and a warning naming the field, so you can narrow it by hand instead of discovering it at runtime. What it infers correctly A field missing from some objects in an array becomes optional. A field that is ever null becomes nullable. Repeated object shapes are emitted once and reused. Keys that are not valid identifiers — user-name , 2fa , class — are renamed safely and mapped back with the right annotation for each language. Verified The output compiles A generator is only useful if what it emits builds. The output for a deliberately awkward sample — containing a 64-bit ID, a null-only field, a mixed-type array, an empty array, a key with a space, a key starting with a digit, and keys that are reserved words in four of the six languages — is compiled on every change: Target Checked with TypeScript tsc --strict Go go build , Go 1.22 Python imported under CPython 3.12 Rust cargo build with serde 1 C# dotnet build , .NET 8 Java javac , Java 21 + Jackson Worth being plain about the limit: types are inferred from one sample . If a field is absent from your sample it will be absent from the types, and if your sample happens to contain only integers in a field that can hold decimals you will get the wrong numeric type. Paste the widest sample you have. For a guarantee rather than an inference, start from a JSON Schema . ### https://jsontools.tools/json-to-yaml.html JSON to YAML Converter Online — Free Bi-directional Converter Skip to main content Bi-directional conversion · Kubernetes, Docker, CI/CD JSON ↔ YAML Converter Convert between JSON and YAML in both directions. Perfect for working with Kubernetes manifests, GitHub Actions workflows, Docker Compose files, OpenAPI specs, and any tool that accepts either format. ⇄ Convert Direction: JSON → YAML YAML → JSON ⊕ Sample ⎘ Copy output ✕ Clear Input JSON Output YAML Converted output will appear here JSON vs YAML: when to convert JSON vs YAML: when to convert JSON and YAML are both popular ways to represent structured data — they share the same underlying model of keys, values, lists, and nested objects. The difference is presentation. JSON uses braces and brackets and double quotes (machine-friendly); YAML uses indentation and minimal punctuation (human-friendly). You'll encounter both in any modern infrastructure stack. Kubernetes accepts both but documentation is mostly YAML. GitHub Actions, GitLab CI, and CircleCI all use YAML. Docker Compose uses YAML. AWS CloudFormation accepts both. OpenAPI specs come in both. Helm charts are YAML. Ansible playbooks are YAML. If you're working programmatically — generating configs, validating against schemas, transforming data — JSON is usually easier because every language has fast native JSON support, and JSON Schema tooling is more mature. If you're hand-editing — writing a CI workflow, tweaking a deployment, reviewing a code review — YAML is often less typing and more scannable. This converter lets you have it both ways. Generate JSON programmatically, convert to YAML for hand-editing. Or hand-write YAML, convert to JSON for programmatic processing. Either direction works. How to convert JSON to YAML (and back) How to convert JSON to YAML (and back) The conversion is straightforward: Choose the direction — JSON to YAML or YAML to JSON. Paste your input into the left panel. The converter runs automatically — output appears on the right. Copy the result with one click. JSON → YAML is straightforward because JSON's data model is a strict subset of YAML's. Everything in JSON can be expressed in YAML without information loss. YAML → JSON works in reverse but loses YAML-specific features that JSON can't represent (comments, anchors, custom tags, multi-line string folding markers). Where JSON ↔ YAML conversion is most useful Where JSON ↔ YAML conversion is most useful ☸ Kubernetes manifests K8s YAML files are easier to edit by hand. But when you're generating manifests with templating tools or validating them against the OpenAPI spec, working in JSON is often simpler. ⚙ GitHub Actions / GitLab CI Workflow files are always YAML. If you're generating them from a JSON template (common in monorepos with many similar pipelines), this converter is the bridge. 🐳 Docker Compose docker-compose.yml is YAML. Convert from a JSON config exported by your application or generated by a deployment tool. 📋 OpenAPI / Swagger OpenAPI specs are valid in both formats. Some tools (Stoplight, Postman) prefer one; some prefer the other. Convert as needed. ⚓ Helm charts Helm values.yaml files configure Helm-templated YAML. When testing values, JSON conversion lets you use JSON-only validators and transformers. 📦 AWS / GCP / Azure configs CloudFormation, Terraform's output, deployment manifests — all support both formats. Convert to whichever your downstream tool expects. Common questions FAQ — Json To Yaml What's the difference between JSON and YAML? Both represent the same data model (keys, values, lists, nested objects) but with different syntax. JSON uses braces, brackets, and double quotes; YAML uses indentation and minimal punctuation. YAML is easier to write by hand; JSON is easier to generate programmatically. The two formats can represent essentially the same data — though YAML has features (comments, anchors, custom tags) that JSON lacks. Is YAML a superset of JSON? YAML 1.2 is essentially a superset of JSON — any valid JSON document is also a valid YAML 1.2 document. This is by design, so YAML parsers can be drop-in replacements for JSON parsers. YAML 1.1 (older spec) had some incompatibilities, but most modern YAML libraries default to 1.2. Will YAML comments be preserved when converting to JSON? No. JSON has no comment syntax, so any comments in your YAML are lost when converting to JSON. If you need comments to survive, work directly in YAML or use JSONC (JSON with Comments) — though JSONC isn't standard JSON and our converter doesn't produce it. How does this handle YAML-specific features like anchors and aliases? Anchors ( &name ) and aliases ( *name ) are resolved during conversion — the referenced value is inlined wherever the alias appears. The resulting JSON has no concept of references, so the conversion is one-way: converting back to YAML won't restore the original anchor/alias structure. What YAML version is supported? YAML 1.2, the current spec. Our converter handles the common YAML patterns: nested maps, sequences, scalars, multi-line strings, and basic anchors. We don't support exotic features like custom YAML tags ( !!type ) or YAML directives ( %YAML 1.1 ). Can I convert OpenAPI specs? Yes — OpenAPI is one of the most common use cases. The full spec converts cleanly in both directions because OpenAPI uses only the common subset of YAML features. Are tabs handled correctly? YAML requires spaces for indentation — tabs are not allowed in structural positions. If your input YAML has tabs, the converter will report an error. Convert tabs to spaces first (most editors have a single command for this). What about Helm template syntax in YAML files? Helm uses {{ .Values.foo }} template syntax that's invalid YAML before rendering. Our converter expects valid YAML; for Helm files, render the template first ( helm template ) and then convert the rendered YAML. How big a file can I ### https://jsontools.tools/json-to-csv.html JSON to CSV Converter Online — Free JSON Array to CSV Tool Skip to main content Arrays of objects → spreadsheet rows · RFC 4180 JSON → CSV Converter Convert a JSON array of objects into CSV ready for Excel, Google Sheets, or any data tool. Handles nested objects (flattened with dot notation), missing fields, custom separators, and proper escaping of special characters. ⇒ Convert to CSV Separator: Comma (,) Semicolon (;) Tab Pipe (|) ⊕ Sample ⎘ Copy CSV ⬇ Download .csv ✕ Clear Input JSON (array of objects) CSV output CSV will appear here Why convert JSON to CSV? Why convert JSON to CSV? CSV (Comma-Separated Values) is the lingua franca of data analysis. Excel, Google Sheets, Numbers, Tableau, R, pandas, SPSS, and every other spreadsheet or stats tool reads CSV natively. JSON, by contrast, is the standard for APIs and structured data interchange. Converting JSON to CSV bridges these two worlds. When you have data from an API or NoSQL database in JSON form and need to analyze it in a spreadsheet, this is the conversion you need. Common scenarios: exporting data for a non-technical stakeholder, loading API responses into a BI tool, importing into a relational database, or just sorting and filtering in Excel. Handling nested objects: dot-notation flattening Handling nested objects: dot-notation flattening CSV is a flat format — each row is a list of values, no nesting. JSON, by contrast, supports arbitrary nesting. Our converter handles this by flattening nested objects using dot notation: [ { "id": 1, "name": "Alice", "address": { "city": "NYC", "zip": "10001" } } ] becomes: id,name,address.city,address.zip 1,Alice,NYC,10001 Arrays inside objects are preserved as JSON strings in the cell — keeping the information intact without trying to expand into multiple rows (which would lose the row-to-row correspondence). Use cases for JSON-to-CSV conversion Use cases for JSON-to-CSV conversion 📊 Excel analysis Pull data from an API, convert to CSV, drop into Excel for pivoting, charting, and ad-hoc analysis. 📈 BI tools Tableau, Power BI, Looker — all accept CSV directly. Convert JSON exports to feed into BI dashboards. 🗄 Database imports PostgreSQL, MySQL, SQLite all support CSV import. Convert JSON data to CSV to load with COPY FROM or LOAD DATA INFILE . 📧 Email reports Stakeholders who don't know JSON can read CSV directly in their email client or attached spreadsheet. 🧪 Data science pandas.read_csv() is the most common way to load data into Python. R's read.csv() is similar. 🔄 Migration When migrating from a JSON-based system to a tabular one, CSV is the intermediate format that travels through almost any pipeline. Common questions FAQ — Json To Csv What's the expected JSON structure for CSV conversion? A JSON array of objects, like [{"name":"Alice","age":30},{"name":"Bob","age":25}] . Each object becomes one row. The union of all keys across all objects becomes the CSV columns. If different objects have different keys, missing values become empty cells. How are nested objects handled? Flattened with dot notation. {"user":{"name":"Alice"}} becomes a column called user.name . Multi-level nesting works the same way: {"a":{"b":{"c":1}}} produces a column a.b.c . What about arrays inside objects? Arrays are preserved as JSON strings in a single cell. {"tags":["a","b"]} produces a cell containing ["a","b"] . We don't expand arrays into multiple rows because that would break the row-to-object correspondence — but if you need that, post-process the CSV in Excel or pandas. How are commas inside values handled? Per RFC 4180: values containing the separator, double quotes, or newlines are wrapped in double quotes, and internal double quotes are escaped by doubling them. So Hello, World becomes "Hello, World" in the CSV. Can I use a different separator? Yes — choose comma, semicolon, tab, or pipe. Semicolon is the standard CSV separator in many European locales (because comma is the decimal separator). Tab gives you TSV (Tab-Separated Values), which avoids most escaping headaches. Will the CSV open correctly in Excel? Yes — the output is RFC 4180 compliant and opens in Excel, Google Sheets, Numbers, and LibreOffice. For non-English locales using semicolon as separator, change the separator setting accordingly. For Excel, you may also need to save the file as UTF-8 with BOM for non-ASCII characters to display correctly — our download includes the BOM automatically. Can I convert CSV back to JSON? Not with this tool — but every spreadsheet program can save as JSON via export, and most programming languages have a one-liner: pandas.read_csv('file.csv').to_dict('records') in Python, or papaparse.parse(csv, {header: true}).data in JavaScript. What if my JSON isn't an array? The converter expects an array as the top-level value. If you have a single object, wrap it in brackets: [{...}] . If you have an object whose values are objects, you may need to transform first — for example, Object.values(yourObject) in JavaScript or list(your_dict.values()) in Python. How big a JSON file can I convert? Up to about 50 MB comfortably. For larger files, use a streaming command-line tool like jq -r 'map([.field1,.field2]|@csv)[]' file.json > file.csv . Does the CSV preserve order of fields? Yes. We preserve insertion order of keys from the first object, then add any new keys from later objects in the order they're encountered. If you need a specific column order, sort the keys before conversion or rearrange the columns in your spreadsheet after. ### https://jsontools.tools/json-to-xml.html JSON to XML Converter Online — Bi-directional Free Converter Skip to main content Bi-directional · Preserves attributes and structure JSON ↔ XML Converter Convert JSON to XML or XML to JSON while preserving attributes, text content, and nesting. Essential when working with legacy SOAP APIs, RSS/Atom feeds, or migrating data between modern and legacy systems. ⇄ Convert Direction: JSON → XML XML → JSON ⊕ Sample ⎘ Copy ✕ Clear Input JSON Output XML Converted output will appear here When you need JSON ↔ XML conversion When you need JSON ↔ XML conversion XML preceded JSON as the dominant data-interchange format on the web, and despite JSON's takeover for new APIs, XML remains everywhere in legacy systems. Anyone working at the boundary between modern and legacy stacks needs a way to convert between the two. Common reasons to convert: SOAP web services still power many enterprise systems (banking, government, healthcare). SOAP envelopes are XML. To integrate with a modern app that prefers JSON, you convert at the boundary. RSS and Atom feeds are XML by spec. To process them with JSON-based tools (most modern data pipelines), convert first. Office Open XML formats (.docx, .xlsx) use XML internally. Tools that introspect Word or Excel files often work with the XML directly. Configuration files in older Java/.NET projects often use XML. Migrating to modern JSON-based tooling means a one-time conversion. EDI and HL7 healthcare data, banking ISO 20022 messages, and other industry standards still use XML. JSON conversion makes them easier to process in modern stacks. How attributes and text are preserved How attributes and text are preserved XML and JSON have different data models. XML elements can have both attributes (metadata on the element) and text content, plus child elements. JSON only has keys and values. To preserve information, our converter uses a convention: XML attributes become JSON keys prefixed with @ . becomes {"@id": "123"} . Element text content (when an element has both attributes and text) becomes a key called #text . Pure text elements (no attributes, no children) become a simple string value. Repeated elements become arrays in JSON. This convention is the de facto standard used by libraries like xml-js, fast-xml-parser, and Underscore's XML helpers. It survives round-trips cleanly: XML → JSON → XML produces a structurally equivalent document. Common questions FAQ — Json To Xml How are XML attributes converted to JSON? Attributes become JSON keys prefixed with @ . So Alice becomes {"user": {"@id": "42", "@role": "admin", "#text": "Alice"}} . This is the de facto convention used by most XML-to-JSON libraries. Are XML namespaces supported? Basic namespace prefixes are preserved as part of element names (so becomes a JSON key "ns:tag" ). Full namespace resolution with xmlns declarations is not performed — the converter treats prefixes as opaque strings. What happens to CDATA sections? CDATA content is preserved as plain text in the JSON. When converting JSON back to XML, special characters in the text are properly escaped — but they won't be re-wrapped in CDATA sections unless you explicitly request it. Does this handle SOAP envelopes? Yes, structurally. SOAP's envelope/body/header nesting converts cleanly. The namespace declarations on the envelope are preserved as @xmlns:soap attributes. You may need to manipulate the resulting JSON to feed it into a modern API. Can I convert XHTML or HTML? XHTML (which is well-formed XML) converts fine. Plain HTML (which often isn't well-formed — unclosed tags, missing quotes) will fail XML parsing. For HTML-to-JSON, use a dedicated HTML parser like Cheerio or BeautifulSoup. How are XML comments handled? XML comments ( ) are stripped during conversion to JSON since JSON has no comment representation. Going back from JSON to XML, comments aren't reconstructed. What about XML processing instructions and DOCTYPE? The XML declaration ( ) is preserved on output but not represented in the JSON. DOCTYPE declarations are stripped — JSON has no equivalent. Can I convert RSS or Atom feeds to JSON? Yes, both convert cleanly. The result is structurally close to what dedicated RSS-to-JSON parsers produce, though the key names follow the @/# convention rather than the more opinionated keys some libraries use. Will the JSON validate against an XML Schema? Not directly — XML Schema (XSD) is XML-specific. But you can write a JSON Schema that mirrors your XSD's constraints, then validate the converted JSON against it using our JSON Schema Validator . How big a document can I convert? Up to about 10 MB on most browsers. XML parsing is slower than JSON parsing because the DOM tree is larger in memory. For larger documents, use a command-line tool like xq (XML + jq). ### https://jsontools.tools/jwt-decoder.html JWT Decoder Online — Free JSON Web Token Decoder Skip to main content JWT decode · Header · Payload · Signature · Expiration check JWT Decoder Online Decode JSON Web Tokens to inspect the header and payload. Detects expired tokens, displays issuance and expiration times in human-readable form. 100% browser-based — your tokens never leave your device. ⇣ Decode ⊕ Sample JWT ✕ Clear Encoded JWT 🎯 Header 📦 Payload 🔏 Signature What is a JSON Web Token (JWT)? What is a JSON Web Token (JWT)? A JSON Web Token (JWT) is a compact, URL-safe way to transmit claims between two parties. JWTs are everywhere in modern web authentication: OAuth flows, single sign-on (SSO), API authentication, and microservice communication all commonly use them. A JWT consists of three parts joined by dots: header.payload.signature . The header and payload are base64url-encoded JSON. The signature is a cryptographic signature over the header and payload, using either an HMAC secret (symmetric) or an RSA/ECDSA key (asymmetric). JWTs are not encrypted by default — they're encoded. Anyone with the token can decode and read the contents. The signature only prevents tampering: changing the payload invalidates the signature, but the original payload is readable. This is a common source of security misunderstanding. How to decode a JWT online How to decode a JWT online Paste your JWT into the input field. It should look like three base64-encoded strings joined by dots. The decoder runs automatically. The header and payload appear immediately, parsed and pretty-printed. Check the status. The tool detects standard claims and displays their values in human-readable form — including a warning if the token has expired. The signature is shown but not verified. Verification requires the secret key (for HMAC) or public key (for RSA/ECDSA), which you should never paste into a website. To verify signatures, use a server-side library or self-hosted tool. Understanding JWT structure Understanding JWT structure 1 Header Tiny JSON describing the token type ( typ: "JWT" ) and the signing algorithm ( alg ). Common algorithms: HS256 (HMAC with SHA-256), RS256 (RSA with SHA-256), ES256 (ECDSA). 2 Payload The claims — facts the token asserts. Standard claims (defined in RFC 7519): sub (subject/user ID), iss (issuer), aud (audience), exp (expiration), iat (issued at), nbf (not before), jti (token ID). Custom claims can be added freely. 3 Signature Cryptographic proof the token wasn't modified after being issued. For HMAC: HMACSHA256(base64url(header) + "." + base64url(payload), secret) . For RSA/ECDSA: a signature using the private key. Verifying the signature requires the matching secret or public key. JWT security: what you need to know JWT security: what you need to know JWTs are not encrypted. The payload is base64-encoded, which is reversible. Never put secrets, passwords, or sensitive PII in a JWT payload. If you need encryption, use JWE (JSON Web Encryption) instead. Check exp on every use. JWT libraries usually do this automatically, but if you're hand-rolling validation, expiration is the most commonly missed check. Validate alg on the server. A well-known vulnerability: an attacker sets alg: "none" and supplies an unsigned token. The server, if not careful, accepts it. Always validate the algorithm matches what your application expects. Use strong secrets. For HMAC-signed tokens, the secret should be at least 256 bits of randomness. Weak secrets can be cracked offline once an attacker has any valid token. Rotate keys periodically. Build in key rotation from day one. JWT headers can include a kid (key ID) that identifies which signing key was used. Short-lived tokens with refresh. Best practice is to issue short-lived access tokens (5-15 minutes) plus long-lived refresh tokens stored more securely. This limits blast radius if a token leaks. Common questions FAQ — Jwt Decoder Is a JWT encrypted? No. JWT payloads are base64-encoded, which is just an encoding — fully reversible by anyone. The signature prevents tampering, but the content is readable. If you need actual encryption, use JWE (JSON Web Encryption). Never store passwords, credit card numbers, or other secrets in a JWT payload. Why isn't the signature verified by this tool? Signature verification requires the secret key (for HMAC algorithms like HS256) or the public key (for RSA/ECDSA). Asking users to paste their server's secret key into a web page would be a serious security mistake — anyone watching the network or with access to the browser could capture it. To verify signatures, use a server-side library or run a verifier on your own machine. How do I tell if a JWT is expired? Look for the exp claim in the payload — it's a Unix timestamp (seconds since 1970-01-01 UTC). Compare it to the current time. Our decoder does this automatically and shows EXPIRED in red if applicable. Note: a future exp doesn't mean a token is valid — it just means it hasn't expired yet. You still need to verify the signature on the server. What does the alg field mean? It specifies the signing algorithm. Common values: HS256 (HMAC with SHA-256, symmetric, used when the same party signs and verifies), RS256 (RSA with SHA-256, asymmetric, used when the verifier doesn't have the signing key — common for SSO), ES256 (ECDSA with SHA-256, asymmetric and faster than RSA). Less common: HS384 , HS512 , RS384 , RS512 , PS256 , EdDSA . What's the maximum length of a JWT? Technically unlimited, but most servers cap HTTP headers at 8 KB. JWTs over 4 KB are usually a code smell — JWTs should carry identity and minimal claims, not entire user records. If you're approaching the size limit, you're probably putting too much in the token. Where should I store JWTs in a browser? Depends on your threat model. localStorage is convenient but vulnerable to XSS. httpOnly cookies are safer against XSS but ### https://jsontools.tools/faq.html JSON Tools FAQ — 136 Questions Answered Skip to main content 136 questions · searchable Frequently Asked Questions Everything about the tools on this site — privacy, limits, standards, and the behaviour that surprises people. Where an answer quotes a number, it comes from a measurement in this repository rather than an impression. All 136 JSON basics 27 Formatting & validating 9 Errors & troubleshooting 8 Numbers & precision 6 Escaping 8 Large files 8 JSON Schema 9 JSONPath 6 Patch & signing 8 Converters 5 Type generation 5 JWT 3 Standards 7 Practical advice 12 Privacy & technical 15 No question matches that. Try a shorter phrase, or ask us — unanswered questions are how this page grows. JSON basics What is JSON, in plain language? JSON (JavaScript Object Notation) is a way to write down structured data so that any program can read it. It uses three main shapes: objects (key-value pairs wrapped in {} ), arrays (lists wrapped in [] ), and primitive values (strings, numbers, booleans, null). Despite the JavaScript in the name, JSON is supported by every modern programming language. It's the default data format for most web APIs and many configuration files. What's the difference between JSON and JavaScript objects? JSON is text — a specific syntax for representing data that any language can parse. JavaScript objects are live in-memory data structures that include methods, prototypes, and references. JSON is a subset: any valid JSON parses into a JavaScript object, but most JavaScript objects can't be represented as JSON (functions, undefined values, circular references, Symbol keys, and Dates all fail to serialize). Is JSON case-sensitive? Yes — both keys and string values are case-sensitive. "name" and "Name" are different keys. This is a common source of bugs when consuming JSON: an API documents a field as customerId but actually returns customerID , and your code silently fails to find it. Pretty-printing the JSON and inspecting it with the formatter is the fastest way to catch these mismatches. What data types does JSON support? Six types: string (double-quoted text), number (integer or floating-point), boolean (true or false), null , object (unordered key-value pairs), and array (ordered list). Notably missing: dates (use ISO 8601 strings), binary data (use Base64-encoded strings), and big integers above 2^53 (use strings to preserve precision). Can JSON have comments? No. Standard JSON does not support comments — neither // line comments nor /* block comments */ . There are non-standard supersets that do: JSONC (JSON with Comments, used by VS Code) and JSON5 (a more flexible superset). If you need comments in a config file, choose one of those — but the receiving tool must support the format. Our tools strictly validate against standard JSON. Why is my JSON invalid even though it looks correct? The most common culprits, in order of frequency: (1) trailing commas — a comma right before a closing brace or bracket; valid JavaScript but not JSON. (2) single quotes instead of double quotes — JSON requires double quotes everywhere. (3) unquoted object keys — every key must be in double quotes. (4) comments — JSON has no comment syntax. (5) invisible characters like a UTF-8 BOM at the start, or smart quotes pasted from a word processor instead of straight ASCII quotes. How do I fix 'Unexpected token' errors in JSON? The error message names the specific token the parser didn't expect, and our tools also report the line and column. Common cases: 'Unexpected token } ' usually means a missing comma between properties or a trailing comma. 'Unexpected token : ' usually means an unquoted key. 'Unexpected end of JSON input' means a missing closing brace or bracket. Look at the line/column the error points to and the character just before it — that's almost always where the real problem is. Why doesn't JSON allow trailing commas? Historical reasons. JSON was designed in 2001 as a strict subset of JavaScript object literal syntax, and at the time, JavaScript itself was inconsistent about trailing commas (different engines treated them differently). Douglas Crockford chose strictness for maximum portability. Modern JavaScript allows trailing commas, but JSON's spec was already in wide use and couldn't be loosened without breaking implementations. JSON5 and JSONC both allow trailing commas — switch to those if you need them. My JSON has thousands of nested levels and the parser fails. Why? Most JSON parsers hit the call stack limit around 500-2000 levels deep, depending on the runtime. This usually indicates a bug in the program generating the JSON — real data rarely needs more than 10-20 levels of nesting. If your structure is genuinely that deep, consider flattening it (use composite keys like "a.b.c.d" instead of {a:{b:{c:{d:1}}}} ) or splitting it across multiple documents linked by ID. What's the maximum JSON file size I can use here? Comfortably up to 50 MB on modern browsers. Between 50 MB and 100 MB, expect noticeable lag — the tools still work, but pasting and formatting take longer. Above 100 MB, the browser's memory limits become a problem and we'd recommend a command-line tool like jq instead, which can stream gigabyte-scale files. Why does formatting a large JSON file freeze my browser? Browser JavaScript runs on a single thread. While the tool is parsing and formatting, the UI can't repaint or respond. For files under 10 MB, this is imperceptible. For larger files, you'll see the tab become unresponsive for a few seconds. If your file is too big to handle comfortably in the browser, use jq or a language-specific streaming parser. How fast are your JSON tools compared to others? Faster than most online formatters because we use the browser's native JSON.parse and JSON.stringify rather than a JavaScript reimplementation. Native parsing is typically 5-10x faster than a JS-implemented parser. For a 10 MB JSON file, formatting completes in well under a second on modern hardware. Do you support JSON5 or JSONC? Not currently. We strictly validate standard JSON per RFC 8259. JSON5 allows comments, trailing commas, unquoted keys, and other relaxations; JSONC (used in VS Code config files) is essentially JSON5 lite. Native JSON5/JSONC support is on our roadmap — for now, strip comments and convert single quotes to double quotes before pasting. Can I save my JSON or share a link to it? We deliberately don't store anything server-side, so there's no shareable URL with your data baked in. To share, copy the formatted JSON and paste it into a gist (gist.github.com), Pastebin, or any paste service. Avoid pasting sensitive JSON to public services — for that, share via a private channel. Do you have a CLI or API I can use? No, and intentionally so. The value of this site is browser-side processing without an API call. For programmatic use, every language has built-in JSON support: JSON.stringify(obj, null, 2) in JavaScript, json.dumps(obj, indent=2) in Python, json.MarshalIndent in Go, serde_json::to_string_pretty in Rust. For CLI work, jq is the standard. How does this site compare to JSONLint, jsoneditoronline, or codebeautify? Functionally similar — all of them format, validate, and convert JSON. The differences worth knowing: (1) most competitor sites send your JSON to their server for processing; ours doesn't. (2) Our error reporting is line/column precise. (3) Our interface is uncluttered with no ads inside the tool itself. (4) The site loads faster because we don't use heavy front-end frameworks. If privacy and speed matter to you, we'd argue ours is the better choice. What is JSON Schema and when should I use it? JSON Schema is a way to describe the structure of JSON data — required fields, types, allowed values, regex patterns, ranges. Think of it as a type system for JSON. Use it when you need to validate inputs (incoming API requests), document outputs (API responses), generate type definitions, or auto-generate tests. Our JSON Schema Validator handles this. JSON Schema is the foundation of OpenAPI and AsyncAPI. What is JSONPath and how does it differ from jq? JSONPath is a path query language for JSON — like XPath for XML. $.users[*].email extracts every user's email. jq is a more powerful language that can also transform and aggregate data, not just select. For simple extraction, JSONPath is easier to learn; for complex pipelines, jq is more capable. Our JSONPath tester uses the Goessner dialect, supported by most JSON libraries. What's the difference between JSON formatting and JSON minification? Both operate on the same data — only the whitespace differs. Formatting (also called pretty-printing or beautifying) adds indentation, newlines, and spaces so humans can read the JSON. Minification removes all unnecessary whitespace to produce the smallest valid representation, typically 30-60% smaller. Use formatting during development; use minification for production APIs, storage, and over-the-wire transmission. Should I use JSON or YAML for my config files? Depends on who's editing them. YAML is easier to write by hand (less punctuation, comments allowed) and is the standard for Kubernetes, GitHub Actions, Docker Compose, and Ansible. JSON is easier to generate programmatically and faster to parse. For configs that humans edit frequently, YAML wins. For configs that programs generate and consume, JSON wins. Our JSON ↔ YAML converter lets you switch between them. Can I convert JSON to CSV with nested objects? Yes — our JSON to CSV converter flattens nested objects using dot notation. {"user":{"name":"Alice"}} becomes a CSV column called user.name . Arrays inside objects are preserved as JSON strings in a single cell, keeping the information intact without breaking the row-to-row correspondence. How do I compare two JSON files to find what changed? Use our JSON Diff tool . It does semantic comparison — key order doesn't matter, whitespace doesn't matter, only real data differences are reported. Each difference is labeled with a JSON path like $.users[2].email so you can navigate directly to it. This is much more accurate than text-based diff for JSON. How does the tool handle Unicode and emoji in JSON? Fully supported. JSON strings can contain any Unicode character including emoji, CJK characters, and right-to-left scripts. Our tools use the browser's native parser which is fully Unicode-aware. Characters outside the Basic Multilingual Plane (like emoji) are typically represented as surrogate pairs in JSON — both forms (raw character and \uD83D\uDE00 escape) round-trip correctly. Does the formatter preserve numeric precision? JavaScript stores all numbers as 64-bit IEEE 754 floats, which means integers larger than 2^53 (about 9 quadrillion) lose precision when parsed. This is a JavaScript limitation, not a tool limitation. If your JSON contains huge integer IDs like Twitter snowflake IDs or 64-bit database IDs, store them as strings ( "id": "123456789012345678" ) to preserve precision. How does the tool handle dates and timestamps? JSON has no native date type — dates are conventionally stored as ISO 8601 strings ( "2026-05-13T12:34:56Z" ) or Unix timestamps ( 1747140896 ). The formatter preserves whichever representation you use as plain strings or numbers. For JWT tokens, our JWT decoder automatically converts Unix timestamps in iat , exp , and nbf claims to human-readable times. Why does my JSON show duplicate keys after pasting? JSON technically allows duplicate keys — the spec doesn't forbid them, though it warns that behavior is undefined. Most parsers silently keep only the last value for a duplicate key, which is what JavaScript's JSON.parse does. If you see this happening, the original data has duplicate keys; check the source. Our tools don't flag duplicates because they're valid JSON, but they're almost always a bug. Can I validate JSON against a schema embedded as a URL? Not currently — our Schema validator requires you to paste both the schema and the data. We don't fetch external $ref URLs because that would require network requests, which contradicts our privacy-first design. To validate against a schema-by-URL, inline the schema first with a tool like json-dereference-cli . Formatting & validating What is the difference between the Formatter and the Validator? Both parse your JSON and report the same errors. The Formatter is built around producing readable output, so it leads with the indented result. The Validator is built around the verdict, so it leads with valid or invalid and the exact location. If you only want to know whether a document parses, use the Validator — on a large file it does strictly less work and uses no memory for output. Which indentation options do you support? Two spaces, four spaces, and tabs. Two is the default because it is what JSON.stringify(x, null, 2) produces and what most style guides assume. Tabs are worth choosing if your team's editor config uses them, since mixing the two in one repository causes noisy diffs. Does formatting change my data in any way? No. Formatting only adds or removes insignificant whitespace between tokens. Every string, number literal, key order and structure is preserved byte for byte. Our streaming formatter copies number literals verbatim, so 9223372036854775807 stays exactly that rather than being rounded — which is not true of tools that parse to an object and re-serialise. Why does my formatted output differ from another tool's? Almost always number normalisation. A tool that parses to a native object and re-serialises turns 1e2 into 100 and 1.0 into 1 , and rounds any integer beyond 2 53 −1. We copy the original literal instead. See which languages silently corrupt large JSON numbers . Can I sort object keys alphabetically? Not in the formatter, deliberately — reordering keys changes the document, and JSON object member order is not significant but is often meaningful to humans reading a diff. If you need a deterministic key order for hashing or signing, use the canonicalizer , which sorts keys as RFC 8785 requires. What does the Repair button do? It attempts common mechanical fixes — removing trailing commas, converting single quotes to double quotes, quoting unquoted keys, and stripping comments. It is a convenience for hand-edited files, not a parser. Always check the result: repair cannot know whether a missing comma belonged before or after the line it guessed. Is there a limit on how much JSON I can paste? Pasting is limited by what your browser can hold in a textarea, which starts to struggle well before 10 MB. Above 4 MB, upload the file instead — it switches to the streaming reader and handles up to 100 MB without loading the document into memory. Is a JSON beautifier the same as a JSON formatter? Yes. Beautifier , formatter and pretty-printer all describe the same operation: taking JSON and re-laying it out with indentation and line breaks so a person can read it. The terms come from different tools rather than from any difference in what they do, and none of them appears in RFC 8259 — the standard has nothing to say about whitespace beyond permitting it between tokens. The formatter on this site is the beautifier; there is no separate tool to look for. Does beautifying JSON change the data? It should not, and here it does not. Whitespace between tokens carries no meaning in JSON, so adding it cannot change a value. The catch is how a tool does it: most parse the document into memory and re-serialise it, which quietly rounds a large integer such as 9223372036854775807 and rewrites 1e10 as 10000000000. This formatter re-emits the original text and copies every number literal verbatim, so the only thing that changes is the whitespace. Errors & troubleshooting What is the JSON error registry? A reference mapping the exact error message your parser printed back to the mistake that caused it. It holds 1,050 error strings captured by running 50 malformed documents through 21 parsers across 12 runtimes — not transcribed from documentation, but recorded from actual execution. Search your message . Why does my error message differ from the one in the tutorial I read? Because every parser words it differently, and V8 changed its own wording in Node 20. A trailing comma is Expected double-quoted property name in JSON at position 8 in Chrome, JSON.parse: expected double-quoted property name… in Firefox, and JSON Parse error: Property name must be a string literal in Safari. Side by side . What does 'Unexpected token < in JSON at position 0' mean? You received HTML, not JSON — almost always a server error page, a login redirect, or a proxy interstitial. The JSON is not malformed; there is no JSON. Check the HTTP status and Content-Type before parsing, and log the first 200 characters of the body so the real page shows up in your logs. Why does my file fail at position 0 when it looks perfectly fine? Usually a UTF-8 byte order mark. Windows editors, Excel exports and PowerShell's Out-File add one by default, and it is invisible in your editor. RFC 8259 §8.1 says a JSON text must not begin with one. Check with head -c 3 file.json | xxd . My JSON has duplicate keys. Why does nothing complain? Because nothing is required to. RFC 8259 §4 says member names should be unique, not must, and leaves the result undefined. All 21 parsers we tested accept it; most keep the last value, and System.Text.Json keeps both. There is no parse error to catch — you have to look for it deliberately. Can I trust an error's line and column number? Ours, yes — they are computed from the byte offset against a newline index. But note that a reported position often points at the token after the problem. A missing comma is reported at the start of the next key, so look one token to the left of wherever you land. Why is a trailing comma invalid when my editor allows it? Your editor is probably showing you JSONC or JSON5, not JSON. RFC 8259 §4 and §5 give the object and array grammar with no trailing separator. tsconfig.json and VS Code settings are JSONC, which is why comments and trailing commas work there and nowhere else. Are comments allowed in JSON? No. JSON has no comment syntax at all — RFC 8259 §2 lists the complete token set, and comments are not in it. If you need them, you want JSONC or JSON5 and a parser for that dialect. The common workaround is a "_comment" key, which is ugly but survives every parser. Numbers & precision Why did my ID change after passing through a JSON tool? It exceeded 2 53 −1. JSON permits arbitrary-precision numbers, but most parsers map them to an IEEE 754 double, which holds integers exactly only up to that point. A Snowflake ID such as 1541815603606036480 comes back as 1541815603606036500 in every JavaScript engine and in Go. No error is raised. Which languages preserve a 64-bit integer and which round it? Measured across 11 parsers: Java (Jackson, Gson), .NET (System.Text.Json, Newtonsoft), Ruby and Python preserve it. Every JavaScript engine and Go's encoding/json round it. Full table . How should I transport large identifiers in JSON? As strings. If a value can exceed 2 53 −1 it is an identifier rather than a quantity, and belongs in quotes. This is why Twitter's API has always returned both id and id_str . If you cannot change the producer, use a precision-preserving parser: json-bigint in JavaScript, parse_int= in Python, json.Number in Go. Does this site round my numbers? The formatter and minifier do not — they copy number literals verbatim, so nothing changes. The canonicalizer must, because RFC 8785 is defined in terms of ECMAScript number serialization, and it warns you when it does. The type generator flags any field that exceeds the safe range. Are NaN and Infinity valid JSON? No. RFC 8259 §6 says values that cannot be represented in its number grammar — Infinity and NaN among them — are not permitted. Python's json.dumps emits them by default, which is why they reach production: a round trip inside Python succeeds while every other language rejects the output. Pass allow_nan=False to catch it at write time. Why does 0.1 + 0.2 not equal 0.3 in my JSON pipeline? That is IEEE 754 binary floating point, not JSON. The JSON text is exact; the double you parse it into is not. If you are handling money, carry amounts as integer minor units or as strings, and never as JSON floats. Escaping What does JSON actually require me to escape? Three things, per RFC 8259 §7: the quotation mark, the reverse solidus, and the control characters U+0000–U+001F. Everything else is optional. Every difference you see between serializers is a choice they made beyond that minimum. Why does Go escape <, > and & in my JSON? json.Marshal escapes them to \u003c , \u003e and \u0026 so JSON embedded in HTML cannot be reinterpreted as markup. Use an Encoder with SetEscapeHTML(false) to stop it. Go's encoding/json/v2 drops this default. Why does Python turn café into caf\u00e9? json.dumps() defaults to ensure_ascii=True , escaping every non-ASCII character. Pass ensure_ascii=False for UTF-8 output. Both are valid and represent the same string — they are just not byte-identical, which matters if you are diffing or hashing. Why do Gson and Jackson produce different output for the same object? Usually the apostrophe. Gson escapes ' to \u0027 and Jackson does not. Gson also escapes HTML-significant characters. Measured side by side on the escape tool page . What is U+2028 and why do some tools escape it? LINE SEPARATOR. RFC 8259 §12 notes it is legal in JSON but illegal in JavaScript, so JSON containing it can break a inside a string could end the block early. What is a lone surrogate and why does it break things? Characters outside the Basic Multilingual Plane — emoji, mostly — are encoded as a UTF-16 surrogate pair. Slicing a string by code unit can cut one in half, leaving a high surrogate with no partner. RFC 8259 §8.2 calls the behaviour of receiving software unpredictable. Our unescape tool rejects it rather than guessing. Large files What is the largest JSON file this site can handle? 100 MB for validating, formatting and minifying, which stream. Tools that need the parsed values in memory — the JSONPath tester, schema validator and diff — cap near 20 MB. We publish both numbers rather than one headline figure, because a single number would be wrong for half the tools. How can a browser format a 100 MB file without running out of memory? By never building an object. A byte-level scanner reads the file in chunks inside a Web Worker, tracks only the container nesting, and writes formatted output straight to a Blob. Measured on a 101 MB file: 620 ms and about 1 MB of heap, against 2.9 s and 299 MB for JSON.parse . Full numbers in the benchmark . Is my large file uploaded to a server? No. Upload is the browser's word for choosing a local file. The bytes are read by JavaScript on your machine through the File API and never leave it. You can confirm this in your browser's Network tab: no request is made when you select a file. Why does the editor only show part of my large file? Rendering 100 MB of syntax-highlighted text would use several gigabytes — rendering, not parsing, is what kills the tab at that size. We show the first 200 KB as a preview and give you the full result as a download. The formatter found an error at 85% of my file. Did it read the rest? No. Scanning stops at the first syntax error, which is why the panel tells you how much was read. On a 101 MB file with a trailing comma at 85%, we report the line and column in 412 ms having read 86 MB. A tool built on JSON.parse must load the whole document before it can say anything. Which browsers support the large-file mode? It needs Web Workers and Blob.stream() — Chrome 76+, Firefox 69+, Safari 14.1+. On anything older we tell you plainly rather than falling back to the method that would freeze the tab. Can I test the large-file handling without finding a big file? Yes. The test file generator builds a file of any size from 5 MB to 150 MB in your browser, valid or deliberately broken. The 150 MB option exists specifically so you can see the refusal message work. Why is there a 100 MB limit at all? Formatting 100 MB produces roughly 180 MB of output, which a browser can hold as a Blob but not comfortably as a single JavaScript string — V8 caps strings near 512 MB. Rather than fail unpredictably somewhere above that, we stop at a number we have actually tested. For larger files, a command-line tool such as jq is the right instrument. JSON Schema Which JSON Schema drafts do you support? draft-07 and 2020-12, scored against the official JSON-Schema-Test-Suite: 904/906 for draft-07 and 1221/1226 for 2020-12. Those figures exclude two categories we do not implement and report as errors rather than skipping — remote $ref URLs, which need network access a browser tool cannot make, and $dynamicRef . Across every test in the suite including those, the raw figures are 915/929 and 1244/1301. Why does the validator warn me even when my document is valid? Because valid can be misleading if part of your schema was never applied. If you use prefixItems under draft-07, or misspell a keyword, that constraint does nothing — and no validator is required to tell you. We list every keyword that is not being enforced so valid never quietly means partly checked . What does 'keywords beside $ref are ignored' mean? In draft-07, $ref replaces the entire schema object, so any sibling keyword is discarded. Write {"$ref": "#/$defs/user", "minProperties": 3} and the minProperties rule does nothing. We audited all 646 schemas in the SchemaStore catalogue and 133 of them do this , including tsconfig.json . Can the validator fetch a remote $ref? No, and it says so rather than skipping it. Everything runs in your browser, so an external URL cannot be resolved. Bundle the referenced schema into $defs , or inline it. A validator that silently ignored an unresolvable reference would report valid for a document it never fully checked. Why is my schema treated as draft-07 when I expected 2020-12? Either it declares $schema for draft-07, or it declares nothing and we inferred the draft from the keywords it uses. The draft selector lets you override it, and the result always states which draft was applied. Add $schema to your schema to remove the ambiguity. Is `format` enforced? By default here, yes — but the specification says format is an annotation, not an assertion, and implementations vary wildly. The toggle lets you switch to spec-strict behaviour. Do not rely on format for security-relevant validation in any implementation. What is the schema registry for? It publishes a field-by-field reference for 249 real-world schemas — package.json, tsconfig, GitHub Actions, Docker Compose and others — generated from the schemas themselves, each with our validator preloaded so you can check your own file. Browse it . Why do you only publish 249 of the 646 schemas you audited? Because a page that lists six undocumented properties helps nobody. We publish schemas with at least eight properties, at least 70% of them carrying descriptions, and a filename pattern to match — the ones where a generated reference is worth reading. Which JSON Schema keywords are not supported? $dynamicRef and $dynamicAnchor , and remote $ref URLs. Both are reported as errors rather than passed over. Everything else in draft-07 and 2020-12 is implemented, including unevaluatedProperties with full annotation collection across allOf , anyOf , $ref and if / then . JSONPath Is your JSONPath tester standards-compliant? Yes. JSONPath became an IETF Standards Track document — RFC 9535 — in February 2024, and our tester scores 703/703 on the official Compliance Test Suite: 456/456 evaluation and 247/247 rejection of invalid queries. Most implementations predate the RFC and behave differently. Why does my query work elsewhere but fail here? RFC 9535 §2.1 requires a conforming implementation to reject a query that does not match the grammar rather than guess. Expressions like $[] , $.. , $[0,] and $[@.a] are invalid and older tools accepted them. If you get a rejection, the query was never portable. Why does $[?@.a=="1"] not match the number 1? Because RFC 9535 comparisons are strictly typed — a string is never equal to a number. Pre-standard implementations often coerced, which quietly returned extra rows. If you want both, use $[?@.a=="1" || @.a==1] . Which JSONPath functions can I use? The five the RFC defines: length() , count() , value() , match() and search() . The last two use I-Regexp (RFC 9485). Arguments are type-checked when the query is parsed, so a mistyped call is an error rather than a wrong result. What is a Normalized Path? The canonical, unambiguous location of a matched node, defined in RFC 9535 §2.7 — for example $['users'][0]['name'] . We show one for every match, and you can paste it straight back in as a query to select exactly that node. Is JSONPath the same as jq? No. JSONPath is a query language for selecting nodes; jq is a full transformation language with its own syntax, filters and output formatting. JSONPath expressions do not run in jq and vice versa. JSONPath is closer in scope to XPath for XML. Patch & signing What is the difference between JSON Patch and JSON Merge Patch? JSON Patch (RFC 6902) is a list of operations addressing locations by JSON Pointer; Merge Patch (RFC 7386) is a document shaped like the target where null means delete. Measured over 39,000 changes, Merge Patch is smaller 96% of the time and cannot express 10% of changes at all. The comparison . Why can't Merge Patch set a field to null? Because null already means remove this member , so there is no way to distinguish deletion from setting a null value. If your API has nullable fields, Merge Patch is the wrong format. Our generator detects the case and tells you instead of emitting a patch that quietly deletes the field. Is the patch you generate the smallest possible one? No, and no tool can honestly claim that for arrays — several different patches correctly transform the same source into the same target. We compare array elements positionally and do not emit move or copy : those patches are shorter but harder to read. Every patch we produce is verified to reproduce the target exactly. What is the test operation for? Optimistic concurrency. {"op":"test","path":"/version","value":7} asserts a value before the patch changes anything, and RFC 6902 §5 requires the whole patch to be atomic — so if the document has moved on, nothing is applied. No ETag, no lock, no extra round trip. What is JSON canonicalization for? Hashing and signing. Two byte-different JSON documents can represent the same data, so a signature over raw bytes is meaningless. RFC 8785 defines an invariant serialization — no whitespace, keys sorted by UTF-16 code unit, ECMAScript number formatting, UTF-8 output — so the same data always produces the same bytes. Can canonicalization change my data? Yes, and this is the trap. Because RFC 8785 uses ECMAScript number serialization, {"id":9223372036854775807} canonicalizes to {"id":9223372036854776000} . A signature over the canonical form does not cover the number you sent. Our tool detects and reports every value that changes — carry large identifiers as strings. Why does the canonicalizer reject 1e400? It is grammatically valid JSON but outside the IEEE 754 double range, and RFC 8785 constrains input to I-JSON (RFC 7493), which does not permit it. There is no canonical form to produce. RFC 8259 §6 names 1E400 as exactly this interoperability problem. Why does my hash not appear? crypto.subtle only exists in a secure context, so the digest needs https or localhost. On plain http the canonical form is still correct — only the hash is unavailable, and we say so rather than failing silently. Converters Is the JSON ↔ YAML conversion lossless? From JSON to YAML, yes — JSON is a subset of YAML 1.2. The other direction is not always: YAML has anchors, aliases, multiple documents per file, comments and non-string keys, none of which JSON can represent. Anything that cannot be expressed is reported rather than silently dropped. How do you flatten nested objects for CSV? Nested keys are joined with a dot, so {"user":{"name":"Ada"}} becomes a column user.name . Arrays of scalars are joined; arrays of objects cannot be flattened into a single row and are reported. CSV is a flat format, so any conversion from nested JSON loses structure by definition. What does the CSV converter do with missing fields? The header is the union of all keys across all records, and a record missing a key gets an empty cell. That keeps the row count honest — you can tell an absent field from an empty string by checking the source. Why does JSON to XML need element names? XML has no anonymous values: every value needs an element. Keys that are not valid XML names — anything starting with a digit, or containing a space — must be renamed, and array items need a repeated wrapper element. The converter picks sensible defaults and shows you what it chose. Can I convert CSV back to JSON here? Not yet. The honest reason is that CSV to JSON is ambiguous in ways JSON to CSV is not: every value is a string unless you infer types, and inference guesses wrong on zip codes, phone numbers and leading zeros. We would rather not ship a converter that quietly turns 01234 into 1234 . Type generation Which languages can you generate types for? TypeScript interfaces, Go structs, Python dataclasses, Rust serde structs, C# classes and Java classes with Jackson annotations. The output for a deliberately awkward sample is compiled on every change with tsc --strict , go build , CPython, cargo build , dotnet build and javac . How do you decide whether a field is optional? By presence. If a field is absent from any object in an array of samples, it becomes optional. If a field is ever null , it becomes nullable. These are different things and the generated types keep them separate. What happens if a field has different types in different records? You get the language's escape hatch — unknown , interface{} , Any , serde_json::Value — plus a warning naming the field. No correct concrete type exists, so guessing one would only move the failure to runtime. How are keys that are not valid identifiers handled? Renamed safely and mapped back with the right annotation for each language: a json: tag in Go, #[serde(rename)] in Rust, [JsonPropertyName] in C#, @JsonProperty in Java. So user-name , 2fa and class all round-trip correctly. What are the limits of inferring types from a sample? It is one sample. A field absent from your sample will be absent from the types, and a field that happens to contain only whole numbers will be typed as an integer even if it can hold decimals. Paste the widest sample you have. For a guarantee rather than an inference, start from a JSON Schema. JWT Does the JWT decoder verify the signature? No. It decodes and displays the header and payload so you can read the claims. Verification needs the signing key, and pasting a production signing key into any website is a bad idea. Verify in your own backend. Is it safe to paste a JWT here? The decoding happens entirely in your browser and nothing is transmitted. That said, a JWT is a credential: if it is a live production token, treat pasting it anywhere as a decision worth thinking about, and rotate it if in doubt. Why is my JWT payload readable without a key? Because a JWT is signed, not encrypted. The header and payload are base64url-encoded, not secret. Anyone holding the token can read every claim. Never put anything confidential in a JWT payload. Standards Which standard actually defines JSON? Two, and they agree. RFC 8259 (STD 90, IETF, 2017) and ECMA-404 2nd edition (Ecma International, 2017) define the same grammar using different formalisms. RFC 8259 additionally gives interoperability guidance that ECMA-404 does not. Both are normatively referenced by the other. What is I-JSON? RFC 7493 — a restricted profile of JSON for maximum interoperability. It requires unique member names, UTF-8, and numbers within the IEEE 754 double range. RFC 8785 canonicalization requires I-JSON input, which is why canonicalizing a document with duplicate keys or a 64-bit integer is a problem. Is a bare string valid JSON? Yes. RFC 8259 §2 defines a JSON text as a single value with optional whitespace, so "hello" , 42 and true are all complete JSON documents. Earlier specifications required an object or array at the top level, which is why some older parsers reject them. Must JSON be UTF-8? For anything exchanged between systems, yes — RFC 8259 §8.1 requires it. Earlier specifications allowed UTF-16 and UTF-32; in practice UTF-8 is the only encoding that achieves interoperability. What is the correct MIME type for JSON? application/json , registered in RFC 8259 §11. No charset parameter is defined, because the encoding is already fixed as UTF-8. Related types exist for specific uses: application/json-patch+json , application/merge-patch+json , application/schema+json . Does JSON preserve the order of object keys? The specification says object member order is not significant, and RFC 8259 §4 notes that libraries differ on whether they expose it. In practice most parsers preserve insertion order, but relying on it makes your code dependent on an implementation detail. Use an array if order matters. Is there a maximum nesting depth in JSON? Not in the grammar. RFC 8259 §9 explicitly permits an implementation to set limits on nesting depth, text size, number range and string length. Deeply nested input from an untrusted source is a real availability risk — cap the depth at your API boundary rather than at the parser. Practical advice Should I minify JSON before sending it over an API? It helps less than most pages claim. Across 799 real documents, minifying saves a median 36% of raw bytes but only 11.6% once the response is gzipped — and almost every API is. Turning compression on is worth 82.8%. Minifying still matters for storage, logs and URL embedding. gzip or brotli for JSON? Brotli, where you can. On already-minified JSON it saves a further median 17.8% over gzip — more than minifying saves on top of gzip. It is supported by every current browser. How should I represent dates in JSON? JSON has no date type, so pick a convention and document it. RFC 3339 date-time strings — 2026-01-15T09:30:00Z — are the safest default: unambiguous, sortable as text, and supported by every language. Epoch integers are compact but hide the timezone question rather than answering it. Should I use null or omit a field? Be consistent, and prefer whichever your consumers can distinguish. Note that JSON Merge Patch cannot express set to null at all, so if your API uses Merge Patch, nullable fiel ### https://jsontools.tools/glossary.html JSON Glossary — 207 Terms Explained Skip to main content 207 terms · searchable JSON Glossary Every term you will meet working with JSON — the grammar, the standards that define it, schemas, JSONPath, encoding, tooling and the failure modes. Where a term is fixed by a specification, the section is named so you can check it. All 207 Data modelling 14 Encoding & Unicode 15 Errors & parsing 19 Formats & dialects 16 JSON Schema 20 JSON grammar 17 JSONPath 11 Numbers 11 Patch & signing 11 Performance 11 Security 12 Standards 18 Tools & processing 16 Web & APIs 16 Nothing matches that term. Try a shorter word, or tell us what is missing . # # $anchor JSON Schema A named location inside a schema, referenced as #name . Introduced in 2019-09 to replace the older practice of putting #name in $id . # $defs JSON Schema The place to put reusable subschemas in 2020-12, renamed from definitions . Both are recognised by the default meta-schema. also: definitions # $dynamicRef JSON Schema A reference resolved at validation time against the dynamic scope, for recursive extension. Powerful and rarely needed; many validators, including ours, do not implement it. also: $dynamicAnchor # $id JSON Schema The base URI of a schema, against which relative references resolve. Changing it mid-document changes how nested $ref s are interpreted. # $ref JSON Schema A reference to another schema, by JSON Pointer, anchor or URI. In draft-07 and earlier, $ref replaces the whole schema object and every sibling keyword is ignored — a defect in 133 of 646 real schemas. Audit . # $schema JSON Schema The keyword declaring which draft a schema is written for. Omitting it forces validators to guess, and different guesses give different results. A # additionalProperties JSON Schema Applies to properties not matched by properties or patternProperties . Setting it to false is the usual way to forbid unknown fields. # Additive change Data modelling A schema change that existing clients tolerate, such as adding an optional field. The basis of backward-compatible API evolution. also: backward compatible # Ajv JSON Schema The most widely used JSON Schema validator for JavaScript, and the usual reference implementation when comparing validator behaviour. # Allocation churn Performance Repeated allocation and collection of short-lived objects. The dominant cost in naive parsers, and what zero-copy techniques avoid. # Annotation JSON Schema A keyword that attaches information without affecting validity — title , description , default , and by default format . # application/json Web & APIs The media type for JSON, registered by RFC 8259 §11. No charset parameter is defined because the encoding is already fixed as UTF-8. also: MIME type, Content-Type # Applicator JSON Schema A keyword that applies subschemas rather than asserting anything itself — allOf , anyOf , properties , items . They can only fail through the subschemas they apply. # Array JSON grammar An ordered sequence of values in square brackets, separated by commas. RFC 8259 §5 imposes no requirement that the values share a type. also: JSON array # Assertion JSON Schema A keyword that makes a claim about the instance and can fail — type , required , minimum , pattern . # Astral plane Encoding & Unicode Informal name for code points above U+FFFF — emoji, historic scripts, many CJK extensions. The characters most likely to break naive string handling. also: supplementary plane # Atomicity Patch & signing The requirement that a patch applies entirely or not at all. If any operation fails the document is left untouched. B # Backpressure Performance Slowing a producer when a consumer cannot keep up. Relevant to streaming JSON over a network or into a file. # base64url Web & APIs A URL-safe base64 variant using - and _ instead of + and / , with padding usually omitted. The encoding used throughout JWT. # Basic Multilingual Plane Encoding & Unicode Unicode code points U+0000 to U+FFFF, each representable as a single \uXXXX escape. Anything above needs a surrogate pair. also: BMP # Bigint Numbers An arbitrary-precision integer type. JavaScript's BigInt cannot be produced by JSON.parse , so libraries such as json-bigint exist to preserve large values. also: arbitrary precision # Billion laughs Security An entity-expansion attack from XML. JSON has no entities and so is immune, which is one of the reasons it displaced XML for untrusted input. # Blob Tools & processing A browser object holding binary data outside the JavaScript heap. Formatted output of 180 MB fits in one when it would not fit in a string. # Breaking change Data modelling A change that invalidates existing clients — removing a field, renaming a key, tightening a type, or making an optional field required. # brotli Web & APIs A newer compression algorithm supported by all current browsers, saving a further median 17.8% over gzip on minified JSON. # BSON Formats & dialects Binary JSON, used by MongoDB. Adds types JSON lacks — dates, binary data, 64-bit integers, ObjectId — at the cost of not being text. # Byte offset Errors & parsing The position of a character counted in bytes from the start of the document. More reliable than a character index for locating an error in a file with multi-byte characters. also: offset # Byte order mark Encoding & Unicode U+FEFF at the start of a file. RFC 8259 §8.1 says implementations must not add one and may ignore one. Invisible in editors, which is why it causes errors at position 0 in files that look fine. also: BOM C # Canonical form Data modelling The single agreed representation of data that has several valid encodings. Required before hashing or signing. # Canonicalization Patch & signing Producing an invariant byte sequence for data that has several valid representations, so a hash or signature is reproducible. For JSON this is RFC 8785. Tool . also: JCS # CBOR Formats & dialects Concise Binary Object Representation, RFC 8949. A compact binary format modelled on the JSON data model, common in constrained and IoT contexts. # Chunked reading Performance Processing a file in fixed-size pieces. Requires a resumable parser, because a token or a multi-byte character can straddle a chunk boundary. # Claim Web & APIs A name/value pair in a JWT payload. Registered claims include iss , sub , aud , exp , iat . # Code point Encoding & Unicode A single Unicode character value, written U+0041 . Distinct from a code unit: characters above U+FFFF take two UTF-16 code units. # Code unit Encoding & Unicode The fixed-size piece an encoding works in — 16 bits for UTF-16, 8 for UTF-8. JavaScript string indexes and lengths are in UTF-16 code units, which is why slicing can split an emoji. # Cold parse Performance The first parse of a document, before any JIT warm-up or cache. The number that matters for a one-shot tool, and often several times slower than a benchmark loop suggests. # Conformance test suite Tools & processing A shared set of cases an implementation is scored against, such as the JSON-Schema-Test-Suite or the JSONPath Compliance Test Suite. The only credible basis for a compliance claim. also: CTS # Content negotiation Web & APIs The HTTP mechanism by which a client states what it can accept and a server chooses a representation. Most 'unexpected token <' errors are a server ignoring it and returning an HTML error page. # Content sniffing Security A browser guessing a response's type when the header is wrong or missing. Serving JSON with the correct Content-Type and X-Content-Type-Options: nosniff avoids it. # Content-Encoding Web & APIs The HTTP header naming the compression applied to a response — gzip or brotli. Distinct from contentEncoding in JSON Schema, which describes a string's contents. # Control character Encoding & Unicode U+0000 to U+001F. RFC 8259 §7 requires them to be escaped inside a string, which is why a literal newline or tab in a string value is a syntax error. # CORS Web & APIs Cross-Origin Resource Sharing: the browser mechanism that lets a page fetch JSON from another origin. Its absence is a common cause of an empty response body. # Current node identifier JSONPath @ , meaning the node a filter is currently testing. Distinct from $ , which always means the document root even inside a filter. also: @ D # Decimal string Numbers Carrying a number as a quoted string to preserve exact precision, the standard workaround for currency and large identifiers. # Deep equality Data modelling Comparing two values by structure and content rather than identity. Object member order must not affect the result — which is why JSON.stringify comparison is wrong. # Denial of service by nesting Security Deeply nested input exhausting a recursive parser's stack. RFC 8259 §9 permits a depth limit for exactly this reason; classified as CWE-674. also: CWE-674 # dependentRequired JSON Schema Requires certain properties when another is present — creditCard implies billingAddress . Called dependencies in draft-07. also: dependentSchemas # Deserialization Errors & parsing Parsing JSON into language-native objects, usually with type mapping — Unmarshal in Go, fromJson in Gson, Deserialize in .NET. also: unmarshalling # Detached signature Patch & signing A signature stored separately from the data it covers. Canonicalization is what makes one verifiable for JSON, since the document can be reformatted in transit. # Digest Patch & signing The fixed-size output of a hash function over the canonical bytes — SHA-256 and friends. Comparing digests is how you compare documents without transmitting them. also: hash # Discriminated array Data modelling An array whose elements have different shapes distinguished by a type field. Requires oneOf per element rather than a single items schema. # Discriminator Data modelling A field whose value determines the shape of the rest of the object, such as type . Modelled with oneOf plus if / then in JSON Schema. also: tagged union # Discriminator collision Data modelling Two branches of a oneOf that both match an instance. JSON Schema requires exactly one to match, so this makes the document invalid rather than ambiguous. # DOM-style parsing Errors & parsing Building the whole document as an in-memory tree, as JSON.parse does. Convenient and memory-hungry: a 101 MB file costs about 299 MB of heap. also: tree parsing # Draft JSON Schema A version of the JSON Schema specification. draft-07 (2018) is still by far the most used — 92% of the SchemaStore catalogue — with 2020-12 the current release. # Duplicate key attack Security Exploiting the fact that parsers disagree on which duplicated value wins, so two services reading the same document see different data. E # ECMA-262 Standards The ECMAScript language specification. RFC 8785 builds its number and string serialization directly on ECMA-262 rather than defining its own. also: ECMAScript # ECMA-404 Standards Ecma International's standard for the JSON syntax, 2nd edition (2017). Defines the same grammar as RFC 8259 using a different formalism; each document normatively references the other. # Element JSON grammar A single value inside an array, addressed by its zero-based index. # Empty array JSON grammar [] — valid, and giving no information about what element type it would contain, which is why type generators cannot infer one. # Empty object JSON grammar {} — valid, and distinct from null and from an absent field. Three different things that are frequently conflated in APIs. # ensure_ascii Encoding & Unicode The Python json.dumps option, on by default, that escapes every non-ASCII character to \uXXXX . Set it to False for UTF-8 output. # Envelope Data modelling A wrapper object carrying metadata alongside the payload — status, pagination, errors. Common in REST responses. # Epsilon comparison Numbers Comparing floats within a tolerance rather than for exact equality. Necessary whenever JSON numbers have been through a double. # Error recovery Errors & parsing Continuing after a syntax error to report more than the first problem. Useful in editors, misleading in validators — subsequent errors are often artefacts of the first. # Escape sequence Encoding & Unicode A backslash followed by a character, representing something that cannot appear literally. JSON defines exactly eight two-character escapes plus \uXXXX ; there is no \x and no \0 . # Escaping Tools & processing Replacing characters with escape sequences so they can appear inside a string. RFC 8259 requires three; everything beyond that is a serializer's choice. Tool . # ETag Web & APIs An HTTP header carrying a version identifier, used with If-Match for concurrency control. The JSON Patch test operation achieves the same thing inside the payload. # eval() Security The JavaScript function sometimes misused to parse JSON. RFC 8259 §12 calls it an unacceptable security risk, and it does not handle all valid JSON. # Exponent Numbers The e or E part of a number. 1e2 and 100 are the same value but different literals — canonicalization normalises them, formatting should not. also: scientific notation # Extra data Errors & parsing Content after the end of the first complete value. A JSON text is exactly one value, so two concatenated documents are an error — usually a file appended to rather than overwritten. F # Fail fast Errors & parsing Stopping at the first error rather than continuing. On a 101 MB file it is the difference between an answer in 412 ms and reading 15 MB that cannot matter. # Filter selector JSONPath A predicate applied to each child, written ? followed by a logical expression, e.g. $[?@.age > 40] . Comparisons are strictly typed in RFC 9535. # Flattening Tools & processing Collapsing nested structure into a single level with compound keys such as user.address.city . Necessary for CSV, and lossy by definition. # format JSON Schema A keyword naming a semantic type such as email or date-time . By specification an annotation, not an assertion, and implementations validate it to wildly varying degrees — do not rely on it for security. # Function extension JSONPath One of the five built-ins RFC 9535 defines: length() , count() , value() , match() , search() . Arguments are type-checked when the query is parsed. G # GeoJSON Formats & dialects RFC 7946: a JSON format for geographic features, with a fixed structure of geometry types and coordinate arrays in longitude, latitude order. # gzip Web & APIs The compression almost every HTTP server applies by default. It removes most of what minifying removes, which is why minifying saves a median 11.6% on an already-gzipped response rather than 36%. H # Heap Performance Memory a language runtime manages for objects. The constraint that decides how large a document a browser tool can parse. # HJSON Formats & dialects A relaxed JSON dialect for human editing, allowing comments, unquoted keys and multiline strings. # HTML escaping Encoding & Unicode Escaping < , > and & so JSON can be embedded in HTML safely. Go's encoding/json does it by default; most others do not. Compared . I # I-JSON Standards Internet JSON, RFC 7493 : a restricted profile requiring unique member names, UTF-8, and numbers within the IEEE 754 double range. RFC 8785 canonicalization requires I-JSON input. also: RFC 7493 # Idempotency Data modelling The property that repeating an operation changes nothing further. A JSON Merge Patch is idempotent; a JSON Patch with add on an array index is not. # IEEE 754 Standards The standard for binary floating-point arithmetic. Its binary64 (double) type is what most JSON parsers use for numbers, which is the origin of large-integer precision loss. also: binary64, double precision # Integer vs number Numbers JSON has one number type. JSON Schema adds an integer type that matches any number with a zero fractional part, so 1.0 is an integer to a schema validator. J # jq Tools & processing A command-line JSON processor with its own transformation language. Not JSONPath — different syntax, larger scope. # JSON JSON grammar JavaScript Object Notation: a text format for structured data, defined by RFC 8259 and ECMA-404 . It has four primitive types (string, number, boolean, null) and two structured types (object, array). also: JavaScript Object Notation # JSON Feed Formats & dialects A JSON alternative to RSS and Atom for syndication. # JSON injection Security Building JSON by string concatenation so that attacker-controlled text alters the structure. Serialize with a library instead; the entire class disappears. # JSON Merge Patch Patch & signing A patch shaped like the target document, where null means remove. Simpler than JSON Patch and unable to express roughly one change in ten. Comparison . also: merge patch # JSON Patch Patch & signing An array of operations transforming one document into another: add , remove , replace , move , copy , test . RFC 6902. Tool . # JSON Pointer Patch & signing A string that addresses one value, as in /users/0/name . Defined by RFC 6901; ~1 escapes a slash and ~0 escapes a tilde. # JSON Schema JSON Schema A vocabulary for describing and validating the structure of JSON documents. Published at json-schema.org; the 2020-12 drafts are the current specification of record. Validator . # JSON Schema dialect Formats & dialects A specific combination of vocabularies a schema uses, identified by its meta-schema URI in $schema . # JSON Streaming Formats & dialects Any convention for sending many JSON values over one connection — NDJSON, length-prefixed records, or concatenated values with a parser that reads one at a time. # JSON text JSON grammar A complete JSON document: one value with optional surrounding whitespace. RFC 8259 §2 defines it as JSON-text = ws value ws , so a bare 42 or "hello" is a valid JSON text. also: JSON document # JSON-LD Formats & dialects JSON for Linked Data, a W3C recommendation that adds a @context mapping keys to IRIs. The format Google reads for structured data. # JSON5 Formats & dialects An extension of JSON adding comments, trailing commas, single quotes, unquoted keys, hex numbers and NaN . A separate format with its own parsers. # JSONC Formats & dialects JSON with comments and trailing commas, used by VS Code settings and tsconfig.json . Not JSON — a standard parser rejects it. also: JSON with comments # JSONP Formats & dialects An obsolete technique for cross-origin requests that wrapped JSON in a callback. Superseded by CORS and best avoided — it executes arbitrary script. # JSONPath JSONPath A query language for selecting values inside a JSON document, standardised as RFC 9535 in 2024 after two decades of divergent implementations. Tester . # JWE Web & APIs JSON Web Encryption, RFC 7516. Unlike a JWT's signature, this actually conceals the payload. # JWK Web & APIs JSON Web Key, RFC 7517. A JSON representation of a cryptographic key, usually served at a jwks_uri for signature verification. # JWS Web & APIs JSON Web Signature, RFC 7515. The signing mechanism underneath a JWT. # JWT Web & APIs JSON Web Token, RFC 7519. Three base64url-encoded parts — header, payload, signature — joined by dots. Signed, not encrypted: the payload is readable by anyone. Decoder . also: JSON Web Token L # Lazy parsing Performance Deferring work until a value is actually accessed, so untouched parts of a document are never materialised. # Leading zero Numbers A zero before another digit, as in 013 . Forbidden by RFC 8259 §6 to avoid any suggestion of octal. Zip codes and zero-padded IDs must therefore be strings. # Lenient parsing Errors & parsing Accepting input the specification forbids — trailing commas, comments, single quotes. Newtonsoft.Json is lenient by default; System.Text.Json is not, which is why .NET migrations surface files that were quietly invalid. also: permissive parsing # Line and column Errors & parsing A human-readable position derived from the byte offset by counting newlines. In a minified single-line document the column can run into the millions, which is why the byte offset is also reported. # Literal name JSON grammar One of true , false , null . RFC 8259 §3 requires them to be lowercase, which is why Python's True and None are rejected. # Lone surrogate Encoding & Unicode A high or low surrogate without its partner, usually from slicing a string on a UTF-16 boundary. RFC 8259 §8.2 calls the behaviour of receiving software unpredictable. also: unpaired surrogate M # Mass assignment Security Binding a parsed JSON body straight onto a model so a client can set fields it should not. Mitigated by an explicit allowlist, or additionalProperties: false in a schema. also: over-posting # Member JSON grammar One name/value pair inside an object. The name and value are separated by a colon; members are separated by commas. also: name/value pair, property # Merge vs replace Patch & signing The distinction between updating named fields and substituting a whole value. Merge Patch always merges objects and always replaces arrays, which surprises people editing lists. # MessagePack Formats & dialects A binary serialization format with a JSON-like data model, chosen for size and speed over readability. # Meta-schema JSON Schema A schema that describes schemas. Every schema must validate against its own meta-schema, which is how a mistyped keyword can be caught. # Minification Tools & processing Removing insignificant whitespace to shrink a document. Saves a median 36% of raw bytes and 11.6% once gzip is applied. Tool . also: minify # multipleOf Numbers The JSON Schema keyword asserting that a number divides evenly by a given value. Floating-point division makes it unreliable for decimals — 0.1 against multipleOf: 0.01 is a classic false negative. # MUST / SHOULD / MAY Standards Requirement levels defined in RFC 2119 and clarified by RFC 8174, meaningful only in capitals. RFC 8259 says names SHOULD be unique — a recommendation, not a rule, which is why duplicate keys parse. also: RFC 2119 N # NDJSON Formats & dialects Newline-delimited JSON: one complete document per line. Used by log pipelines and streaming exports because each line can be processed independently. Not a single JSON document. also: JSON Lines, JSONL # Negative zero Numbers -0 , distinct from 0 in IEEE 754 and preserved by some parsers but not others. Rarely intended, occasionally load-bearing. # Nesting depth JSON grammar How many containers enclose the deepest value. The grammar sets no limit, but RFC 8259 §9 explicitly permits an implementation to impose one — unbounded depth from untrusted input is a denial-of-service vector. also: depth # Nodelist JSONPath The result of a query: a list of nodes, which may be empty. RFC 9535 does not stipulate the order of results for object wildcards. # Normalized Path JSONPath The canonical, unambiguous location of a node, as in $['users'][0]['name'] . Defined in RFC 9535 §2.7 and usable as a query in its own right. # Normative reference Standards A referenced document you must follow to conform. RFC 8259 lists ECMA-404 as normative specifically to make clear that the two definitions of JSON do not diverge. # Nosniff Security The X-Content-Type-Options: nosniff header, which stops a browser guessing a response type. Worth setting on any endpoint returning JSON. # Nothing JSONPath The absence of a value in a JSONPath filter, distinct from null . Comparing Nothing with anything except Nothing is false. # Nullable Data modelling Able to hold null . Distinct from optional: a nullable field is present with a null value, an optional field may be absent entirely. # Number Numbers A base-10 value with an optional minus sign, fraction and exponent. RFC 8259 §6 forbids leading zeros, and permits no + prefix, hex, NaN or Infinity . O # Object JSON grammar An unordered collection of name/value pairs wrapped in curly brackets. A name is always a string. RFC 8259 §4 says names should be unique but does not require it. also: JSON object # Object graph Performance The in-memory tree a parser builds. For a 101 MB flat document it costs roughly 299 MB; deeply nested data with many small objects can cost five to eight times the text size. # OpenAPI Formats & dialects A specification for describing HTTP APIs, written in JSON or YAML. Version 3.1 uses JSON Schema 2020-12 as a proper superset. also: Swagger # Optimistic concurrency Patch & signing Allowing concurrent edits and detecting conflicts at write time rather than locking. The JSON Patch test operation and HTTP If-Match both implement it. # Optional field Data modelling A member that may be absent. In JSON Schema, any property not listed in required . # Oracle Tools & processing A trusted implementation used to check a new one. Ajv serves as the oracle for our schema engine; JSON.stringify for the formatter. P # Parser Errors & parsing Software that turns JSON text into a representation your language can use. RFC 8259 §9 requires it to accept every text matching the grammar, and permits it to accept extensions or impose limits. # PATCH Web & APIs The HTTP method for partial updates. Its body should be a JSON Patch or JSON Merge Patch with the matching media type, not an arbitrary partial object. # Payload Web & APIs The body of a request or response. In JWT, specifically the middle segment holding the claims. # Position reporting Errors & parsing How a parser describes where a failure occurred: byte offset, line and column, a text snippet, or nothing at all. It varies enormously, which is why the same bug looks different in each language. # Precision loss Numbers Silent rounding when a number needs more precision than the parser's type provides. A Snowflake ID 1541815603606036480 becomes 1541815603606036500 in every JavaScript engine. Measured . # prefixItems JSON Schema Positional array validation in 2020-12, replacing the array form of items . Under 2020-12 an array-valued items is simply invalid. # Pretty-printing Tools & processing Adding indentation and newlines for readability. The inverse of minification, and equally lossless. Tool . also: formatting, beautify # Prototype pollution Security An attack where keys such as __proto__ in parsed JSON modify object prototypes in JavaScript. JSON.parse itself is safe; the danger is in merge and assign helpers applied afterwards. R # Recursive descent Errors & parsing A parsing technique that uses the call stack for nesting. Simple and fast, but it means deeply nested input can overflow the stack — the reason many parsers cap depth. # ReDoS Security Regular-expression denial of service, where a crafted input makes a pattern backtrack exponentially. A real risk anywhere a schema's pattern comes from an untrusted source. # Relative JSON Pointer Patch & signing An extension addressing a value relative to another, by walking up a number of levels first. Used by JSON Schema's relative-json-pointer format. # Replacement character Encoding & Unicode U+FFFD, substituted when a decoder meets bytes it cannot interpret. Seeing it in parsed output usually means the input was not actually UTF-8. # REST Web & APIs An architectural style for HTTP APIs. JSON is its usual representation format, though REST specifies no format at all. # RFC 3339 Standards Date and Time on the Internet. Its date-time production is the format behind JSON Schema's date-time , date , time and duration formats. # RFC 3629 Standards The definition of UTF-8. RFC 8259 §8.1 requires it for JSON exchanged between systems. # RFC 3986 Standards The URI generic syntax. Governs how $id and $ref are resolved in JSON Schema, and the uri format attribute. # RFC 4627 Standards The original 2006 JSON specification by Douglas Crockford, which registered the application/json media type. Obsoleted twice since. # RFC 6901 Standards JSON Pointer. Defines a string syntax for addressing a single value inside a JSON document, used by JSON Patch and by JSON Schema $ref fragments. # RFC 6902 Standards JSON Patch. Defines a sequence of operations that transforms one document into another, and the application/json-patch+json media type. Tool . # RFC 7159 Standards The 2014 revision of the JSON specification, obsoleted by RFC 8259. It was the first to allow any value at the top level rather than only an object or array. # RFC 7386 Standards JSON Merge Patch. A simpler alternative to JSON Patch where the patch mirrors the target document and null means remove. Media type application/merge-patch+json . # RFC 8259 Standards The IETF Internet Standard for JSON (STD 90, December 2017, T. Bray Ed.). Obsoletes RFC 7159 and RFC 4627. Defines the grammar and adds interoperability guidance on numbers, encoding and duplicate names. also: STD 90 # RFC 8785 Standards JSON Canonicalization Scheme (JCS). Defines an invariant serialization for hashing and signing: no whitespace, keys sorted by UTF-16 code unit, ECMAScript number formatting, UTF-8 output. Tool . also: JCS # RFC 9485 Standards I-Regexp: an interoperable regular-expression format, used by the match() and search() functions in RFC 9535. also: I-Regexp # RFC 9535 Standards JSONPath: Query Expressions for JSON (IETF Standards Track, February 2024). The first standard for JSONPath after twenty years of divergent implementations. Tool . # Root JSON grammar The single outermost value of a JSON text. In JSONPath it is written $ . also: root value # Round trip Data modelling Parsing a document and re-serialising it. A lossless round trip preserves every value; in practice number precision and key order are where it usually fails. # Round-trip test Tools & processing Verifying a transformation by reversing it and comparing with the original. How the escape and patch tools here are checked — 200,000 and 30,000 randomised cases respectively. S # Safe integer Numbers An integer a double represents exactly: −(2⁵³)+1 to 2⁵³−1, or ±9007199254740991. RFC 8259 §6 calls this range interoperable. also: MAX_SAFE_INTEGER # SAX-style parsing Errors & parsing Event-driven parsing that emits callbacks for each token rather than building a tree. Constant memory, but you must track your own state. also: event-driven parsing # Scalar JSON grammar A value that is not a container: a string, number, boolean or null. Sometimes called a primitive. also: primitive # Schema Data modelling A description of the shape data must take. In JSON usually a JSON Schema document, and distinct from a database schema. # Schema inference Tools & processing Generating a JSON Schema from example documents. Useful as a starting point; it can only describe what the samples happen to contain. # Schema poisoning Security Supplying a malicious schema rather than malicious data — an unbounded pattern can cause catastrophic regex backtracking. JSON Schema Validation §10 names this risk. # SchemaStore JSON Schema A community catalogue of JSON Schemas for common configuration files — package.json, tsconfig, GitHub Actions, Docker Compose. Apache 2.0. Our registry . # Secrets in JSON Security Credentials pasted into a tool or committed to a repository. Everything on this site runs locally, but a live token is still worth rotating if it has been pasted anywhere. # Segment JSONPath One step of a JSONPath query. A child segment moves to direct children; a descendant segment ( .. ) applies to a node and all of its descendants. # Selector JSONPath What a segment applies: a name, a wildcard, an index, a slice, or a filter. RFC 9535 allows several in one bracket, as in $[0, 'name', 2:4] . # Serializer Errors & parsing Software that turns in-memory values into JSON text. RFC 8259 §10 requires the output to conform strictly to the grammar. Also called a generator or encoder. also: generator, encoder, marshaller # SIMD parsing Performance Using vector instructions to process many bytes per cycle, as simdjson does. Described in Langdale and Lemire, The VLDB Journal 28, 2019. also: simdjson # Singular query JSONPath A query that can select at most one node — only name and index segments. Only a singular query may be used as a comparable in a filter. # Slice selector JSONPath A Python-style range [start:end:step] over an array. A step of zero selects nothing; a negative step iterates backwards. # Smart quotes Encoding & Unicode Typographic quotation marks U+201C and U+201D, inserted by word processors and chat clients. Not string delimiters in JSON, and nearly invisible in most fonts. also: curly quotes # Sparse object Data modelling An object where most possible keys are absent. Usually preferable to filling every key with null , unless consumers cannot tell absence from null. # Streaming parser Errors & parsing A parser that processes input incrementally without holding the whole document. Necessary for files larger than available memory. Benchmarked . also: incremental parser # Streaming write Performance Emitting output progressively rather than building it in memory. What lets a 180 MB formatted result exist in a browser at all. # Strict parsing Errors & parsing Rejecting anything the grammar does not permit. The safer default, because leniency means the same file behaves differently in different services. # Structural character JSON grammar One of the six characters that shape a JSON document: [ ] { } : , . RFC 8259 §2 permits insignificant whitespace before or after any of them. # Structural diff Tools & processing Comparing two documents by parsed value rather than text, so formatting and key order do not produce false differences. Tool . # Surrogate pair Encoding & Unicode Two UTF-16 code units encoding one character above U+FFFF. RFC 8259 §7 gives "\uD834\uDD1E" for the G clef as the example. # Syntax error Errors & parsing A failure to match the grammar. Every parser detects the same set, but each words the message differently — 1,050 distinct strings across 21 parsers in the registry . # Syntax highlighting Tools & processing Colouring tokens by role. Cheap on a small document and the main cost on a large one — usually the reason a browser tool dies before the parser does. T # test operation Patch & signing The JSON Patch operation that asserts a value before anything is changed. Combined with the atomicity RFC 6902 §5 requires, it gives optimistic concurrency without an ETag. # Time to first byte Performance How quickly a response starts arriving. Streaming JSON improves it; building the whole response before sending does not. also: TTFB # Token JSON grammar The smallest meaningful unit of a JSON document: a structural character, a string, a number, or a literal name. Comments are not tokens, which is why JSON has none. # Tokenizer Errors & parsing The stage that splits input into tokens before any structure is checked. Also called a lexer or scanner. also: lexer, scanner # TOML Formats & dialects A configuration format designed for unambiguous mapping to a hash table. Often chosen over JSON for config because it supports comments. # Trailing comma JSON grammar A comma after the last member or element. Valid in JavaScript, invalid in JSON, and the most common cause of a parse failure in hand-edited files. Details . # Truncated document Errors & parsing A document cut short before its closing bracket, usually by a timeout, a proxy, a size-capped log, or a stream read twice. Produces an unexpected-end-of-input error. # Type generation Tools & processing Producing type declarations from a JSON sample — TypeScript interfaces, Go structs, Rust serde types. Inference from one sample, so absent fields produce absent types. Tool . also: codegen U # U+2028 / U+2029 Encoding & Unicode LINE SEPARATOR and PARAGRAPH SEPARATOR. Legal in JSON, illegal in JavaScript before ES2019 — RFC 8259 §12 names them as the reason eval() cannot parse all valid JSON. also: line separator # Unescaping Tools & processing Turning a JSON string literal back into the raw text it represents, resolving \n , \uXXXX and surrogate pairs. # unevaluatedProperties JSON Schema Constrains properties not already evaluated by any other keyword, including through allOf and $ref . Requires annotation tracking, which is why many validators implement it incorrectly. also: unevaluatedItems # UTF-8 Encoding & Unicode The variable-width encoding required by RFC 8259 §8.1 for JSON exchanged between systems. ASCII characters take one byte; other characters take two to four. V # Value JSON grammar Anything JSON can represent: an object, array, number, string, or one of the three literal names true , false , null . RFC 8259 §3. # Virtual scrolling Tools & processing Rendering only the rows currently visible. Necessary for large documents, because rendering 100 MB of highlighted text can consume several gigabytes. # Vocabulary JSON Schema A named group of keywords a meta-schema declares support for, introduced in 2019-09. It lets a dialect state which parts of JSON Schema it uses. W # Web Worker Tools & processing A browser API for running JavaScript off the main thread. What lets a 100 MB file be scanned without freezing the tab. # Well-formed Errors & parsing Matching the grammar. Distinct from valid , which in JSON usually means conforming to a schema as well. # Whitespace JSON grammar Space, horizontal tab, line feed or carriage return, allowed between tokens and ignored. No other character counts as whitespace in JSON — a vertical tab or form feed is a syntax error. also: insignificant whitespace Y # YAML Formats & dialects A human-friendly data format that is a superset of JSON as of YAML 1.2. Adds anchors, aliases, comments, multi-document files and non-string keys, none of which JSON can represent. Z # Zero-copy parsing Performance Parsing that references the original buffer rather than copying strings out of it. How high-performance parsers avoid allocation. ### https://jsontools.tools/how-it-works.html How JSONTools Works — Browser-Side JSON Processing Explained Skip to main content Transparency · Open about how it works How JSONTools Works Every JSON tool on this site runs entirely in your browser. Here's exactly how that works, why it matters, and how you can verify it yourself. The short version The short version You paste JSON into a page. Your browser's JavaScript engine parses and processes it on your device. The result appears on the same page. Your data never reaches our server because there is no server-side processing — the website is a static collection of HTML, CSS, and JavaScript files. This is fundamentally different from most online JSON tools, which send your data to their server and process it remotely. What happens when you paste JSON What happens when you paste JSON Step by step, when you paste a JSON document and click Format: Your browser already has the page's HTML, CSS, and JavaScript loaded — these were sent by our server when the page first loaded, but they're now cached locally. The JavaScript event listener for the Format button fires inside your browser tab. It reads the value of the input