JSON Formatter

What does this JSON formatter do?

This tool cleans up strict JSON in the browser so you can either read it comfortably or compress it into a single line. The current page exposes three core capabilities:

• pretty: expands JSON with indentation for inspection and debugging.
• minify: removes extra whitespace for transport or embedding.
• sortKeys: recursively sorts object keys so repeated comparisons are easier to read.

This is not a JSON5 editor and not a schema validator. The implementation relies on native JSON.parse(), so it does not accept comments, trailing commas, single quotes, or unquoted keys.

When key sorting is enabled, object keys are reordered recursively, but array order stays intact. That makes the output useful for readability and review, but not a full canonical JSON representation.

Good fits

• Inspecting REST or GraphQL payloads.
• Cleaning up fixtures and config snippets.
• Compressing JSON before pasting into env vars or query parameters.
• Normalizing field order before using a diff tool.

References

• RFC 8259 defines valid JSON syntax.
• ECMA-404 describes the core JSON grammar.
• MDN documents JSON.parse() and JSON.stringify().

How to use it

1. Paste valid JSON

Put your JSON into the left textarea. A valid example looks like this:

{"name":"devtool","enabled":true,"items":[3,2,1]}

2. Choose an output mode

• pretty: multi-line output for humans.
• minify: single-line output for transport.

3. Pick indentation and sorting

The UI currently offers 2 and 4 spaces. If you enable key sorting, object keys are sorted recursively while arrays keep their original order.

4. Read the result

• On success, the right side updates immediately and can be copied.
• On failure, the page shows the parse error. Common causes are trailing commas, comments, single quotes, or missing quotes around property names.

Recommended workflow

1. Paste the raw payload.
2. Use pretty to inspect structure.
3. Turn on sortKeys when comparing versions.
4. Switch to minify only when you need compact output.

References

• RFC 8259
• MDN: JSON.parse()
• MDN: JSON.stringify()

Option reference

The page is backed by formatJson(input, options). Its behavior can be summarized like this:

Success shape

Successful formatting returns:

• ok: true
• parsed: the parsed JavaScript value
• value: the rendered output string

Failure shape

Failed parsing returns:

• ok: false
• error: the native JSON.parse() error message

Important boundaries

• No file import or export.
• No schema validation.
• The formatter accepts any numeric indent internally, but the page only exposes 2 and 4.
• Key sorting is not the same as the canonical JSON rules from RFC 8785.

References

• MDN: JSON.parse()
• MDN: JSON.stringify()
• RFC 8785

FAQ

Why does commented JSON fail?

Because the current implementation uses native JSON.parse(). Under RFC 8259, comments are not valid JSON syntax.

Why are trailing commas and single quotes rejected?

They are common in JavaScript object literals and JSON5, but not in standard JSON. For API payloads and cross-language data exchange, strict JSON is usually the safer target.

Can key sorting change the meaning of my data?

Usually not for plain objects, but it can change how output looks in reviews, snapshots, signatures, or tools that depend on original field order. Arrays are not reordered.

Why does empty input not show an error?

The tool treats empty input as “nothing to format yet”, which makes it easier to clear the editor and start over.

Is this a replacement for schema validation?

No. It checks syntax only. It does not validate required fields, enums, data types, or business rules.

References

• RFC 8259
• ECMA-404
• MDN: JSON.parse()

JSON vs object literals vs canonicalization

JSON is often confused with JavaScript object literal syntax, but the overlap is not complete.

This tool intentionally stays on the “strict JSON” side, because that is the safer model for API exchange and interoperable data handling.

Why key sorting is not canonical JSON

Many workflows only need stable-looking output so humans can compare it more easily. Full canonical JSON goes further and standardizes number formatting, Unicode handling, escaping, and serialization details. This tool only sorts object keys recursively, so it improves readability but does not implement the full JSON Canonicalization Scheme from RFC 8785.

Use it for:

• cleaner reviews
• lower visual noise in diffs

Do not use it as-is for:

• digital signatures
• hashing pipelines
• byte-for-byte canonical output requirements

References

• ECMA-404
• RFC 8259
• RFC 8785

Practical tips

Expand first, compress later

If your source is already minified, switch to pretty first so you can inspect structure, nesting, and data types before compressing it again.

Sort keys before diffing

When upstream systems emit unstable object key order, turning on sortKeys makes version comparisons much easier.

Do not sign the sorted output blindly

The current output is useful for humans, not guaranteed canonical bytes. Use a dedicated canonicalization strategy for signing or hashing.

Watch for these common parse failures

• copied from JavaScript source with comments or trailing commas
• copied from logs with prefixes or timestamps
• copied as an escaped JSON string instead of raw JSON

Split huge payloads while debugging

If the error is hard to spot, isolate smaller fragments first, then move back to the full object once you find the malformed area.

References

• MDN: JSON.parse()
• MDN: JSON.stringify()
• RFC 8785