Format (pretty-print) or minify JSON and validate it against RFC 8259, with the line and column of any syntax error explained in plain words.
By AdminDrafted with AI writing toolsUpdated Checked examples: 6
The JSON is valid. Values: 10; keys: 6; nesting depth: 2. Pretty-printing takes it from 127 to 170 bytes.
{
"name": "CalcOpenly",
"version": "1.0.0",
"precision": 50,
"domains": [
"math",
"finance",
"programming"
],
"offline": true,
"license": null
}| Type | Count |
|---|---|
| Objects | 1 |
| Arrays | 1 |
| Strings | 5 |
| Numbers | 1 |
| Booleans | 1 |
| Nulls | 1 |
Valid JSON: Objects: 1, Arrays: 1, Strings: 5, Numbers: 1, Booleans: 1, Nulls: 1.
Keys in total: 6; deepest nesting level: 2.
One member or item per line, indented 2 spaces per level.
Strings and numbers are copied exactly as written, so escapes and number formats are unchanged.
The validator parses the text with the RFC 8259 grammar: objects, arrays, double-quoted strings, numbers, true, false and null, and nothing else. If parsing succeeds, it prints the same values back, either with one member per line and 2 spaces, 4 spaces or a tab per level, or minified with every space outside strings removed. If it fails, it reports the line and column where the grammar broke and what it expected there.
Developers use it to read API responses and config files and to shrink payloads. The default object has 6 keys and 10 values nested 2 levels deep, and pretty-printing it with 2 spaces grows it from 127 to 170 bytes.
Strings and numbers are copied exactly as written, so escapes survive and a large integer such as 12345678901234567890123 keeps every digit.
JSON is valid when it follows the RFC 8259 grammar: objects in braces, arrays in brackets, double-quoted strings and keys, numbers, true, false and null, with commas only between items. Formatting changes whitespace only. Pretty-printing puts each member on its own line, and minifying strips every space outside strings.
This 25-byte document:
{"id":7,"tags":["a","b"]}
Pretty-printed with 2 spaces, it becomes 47 bytes:
{
"id": 7,
"tags": [
"a",
"b"
]
}
With 4 spaces it is 61 bytes. All three versions parse to the same data, so minify for transfer and pretty-print for reading and diffs.
[1, 2,]{'a': 1}{a: 1}// and /* */ belong to JSONC and JSON5, not JSON.NaN, Infinity, 0x10, +1, 007 and .5 are all invalid. Write 0.5, and use null or a string for a missing value.\t or \n.A parser reports where it noticed the problem, which can be after the actual mistake. Here the missing comma belongs at the end of line 2, but the error points to line 3, column 3, where "b" starts:
{
"a": 1
"b": 2
}
Check the character just before the reported position first, then look further back for an unclosed quote or bracket.
| Scenario | Keys | Depth | Values | Output bytes |
|---|---|---|---|---|
| Default | 6 | 2 | 10 | 170 |
| Minified default | 6 | 2 | 10 | 127 |
| Root number | 0 | 0 | 1 | 2 |
| Duplicate keys | 5 | 2 | 6 | 64 |
| Large exact integer | 1 | 1 | 2 | 42 |
Default is a 127-byte object, {"name":"CalcOpenly",…,"license":null}, pretty-printed with 2 spaces to 170 bytes. Minified default is the same object minified, and Root number is the document 42, which is valid JSON on its own.
Values count every object, array, string, number, boolean and null. The default's 10 are 1 object, 1 array, 5 strings, 1 number, 1 boolean and 1 null; its 6 keys are counted separately. Depth counts nested containers: 0 for a bare 42, 1 for a flat object.
RFC 8259 allows any number of digits, but many parsers store numbers as IEEE 754 doubles, which are exact only up to 2^53 − 1 = 9,007,199,254,740,991.
JavaScript's JSON.parse turns 12345678901234567890123 into 1.2345678901234568e+22, so send IDs that large as strings. Number tokens are copied as written here, which is how the Large exact integer row keeps a 30-digit id intact.
Duplicate keys are legal but unreliable: RFC 8259 says names SHOULD be unique, and JSON.parse('{"a":1,"a":2}') keeps only the last value.
The Duplicate keys row, {"a":1,"a":2,"nested":{"a":3,"a":4}}, keeps all four a members and warns, so you can fix the source before another parser picks a different one.
\u00e9 are copied as written, not turned into é.If a digest must match, hash the exact bytes with the hash calculator: indentation, key order and a trailing newline all change them.
Checked against: Independent calculation
Checked against: len = 45, output 33 bytes
Checked against: RFC 8259 §2 (any value may be the top-level text)
Checked against: Independent calculation
Trailing commas, single quotes and unquoted keys cause most failures, because JSON requires double quotes around every string and key and allows no comma after the last item. Comments, NaN, Infinity and hex numbers are also invalid under RFC 8259, although JavaScript accepts some of them in code. The error message here gives the line and column, so you can go straight to the character that broke the parse.
No. RFC 8259 and ECMA-404 define no comment syntax, so a standard parser rejects // and /* */. Douglas Crockford removed comments from the format early on because people were using them to hold parser directives. Config files that need comments use JSON5 or JSONC, the format of VS Code's settings.json, and this validator reports those files as invalid JSON.
RFC 8259 sets no limit, but it warns that only integers between −(2^53 − 1) and 2^53 − 1 = 9,007,199,254,740,991 are sure to interoperate, since many parsers use IEEE 754 doubles. This tool copies numbers digit for digit, but JavaScript's JSON.parse turns 12345678901234567890123 into 1.2345678901234568e22, so send large IDs as strings.
RFC 8259 says the names within an object SHOULD be unique, so duplicates are legal but unreliable: JavaScript's JSON.parse and Python's json module keep only the last value, while other parsers keep the first or reject the document. This validator accepts them but warns with the line and column of the object, so you can remove the duplicate before another system reads it differently.
Pretty-printing puts each member on its own line with 2 or 4 spaces or a tab per level, which makes the data easy to read and diff; minifying removes every space and line break outside strings for transfer. Both describe exactly the same data. The default example grows from 127 to 170 bytes when pretty-printed, and the minify example shrinks from 45 to 33 bytes.
This calculator includes 6 worked examples with independently sourced answers. They run in the test suite, and you can run them here too.