JSON Stringify

Examples

{"name":"CaseSwitch","ok":true}

{
  "name": "CaseSwitch",
  "ok": true
}

[1,2,3]

[
  1,
  2,
  3
]

{"a":{"b":[1,2]}}

{
    "a": {
        "b": [
            1,
            2
        ]
    }
}

"He said \"hi\""

"He said \"hi\""

He said "hi"

(error: Invalid JSON — plain text without JSON structure is rejected)

How to use

1. Paste a valid JSON value (object, array, string, number, true/false/null).
2. Set indent spaces if you want something other than 2.
3. Copy the re-stringified output, or fix parse errors in the source and try again.

What this tool is for

JSON.stringify with indent re-emits a valid JSON document as a stable string after JSON.parse. Use it when you need indent control for a payload, or when you are normalizing a compact object before a review. It requires real JSON first — not a raw unquoted sentence.

How it works

The input is parsed with JSON.parse. On success, JSON.stringify runs with your indent setting (default 2). Indent 0 still keeps structural commas but avoids pretty spacing the way a multi-space indent would. Invalid JSON fails with an error and an empty output panel. Numbers such as 1.0 become 1 after parse. Duplicate keys: the parser keeps the last value.

When to use it

Normalizing an API sample to a team indent, re-serializing a one-line fixture with 4-space indent, and checking that a paste is valid JSON before you commit it. If you only need pretty vs minify toggles, the JSON Formatter is the sibling tool. If you need to recover text from a quoted JSON string literal, use JSON Unstringifier.

When not to use it

Do not paste plain English without JSON quotes — parse will fail. This is not a schema validator. It does not accept JSONC comments or trailing commas. Do not treat stringify as encryption. For YAML output, use JSON to YAML.

How it compares to related tools

JSON Formatter adds an explicit Pretty / Minify mode switch. JSON Unstringifier decodes a quoted JSON string into raw text (newlines included). JSON to YAML changes serialization language. Longer notes: Guide to JSON formatting.

Common mistakes

Expecting raw text like He said "hi" to become a quoted literal — that input is invalid JSON here; wrap it as a JSON string first ("He said \"hi\""). Double-pasting already-stringified values. Assuming comments survive. Using this as a cryptographic canonicalizer without a spec.

Indent control vs the JSON formatter

Both this tool and the JSON Formatter parse with JSON.parse and write with JSON.stringify. The formatter emphasizes Pretty vs Minify as modes. JSON Stringify focuses on choosing an indent width for a valid document. Pick one workflow and stick to it in a PR so diffs stay boring. Neither tool repairs JSONC or JavaScript object literals.

String values vs whole documents

If the input is a JSON string (opening and closing quotes, with escapes), stringify writes that string value back as a quoted literal. If you need the decoded text with real newlines, use Unstringifier instead. If the input is an object or array, you get a pretty document. Plain unquoted text is not JSON and fails.

Related tools