JSON formatter

JSON Formatter first parses the input with JavaScript's JSON.parse. If parsing succeeds, it serializes the resulting value with JSON.stringify. Pretty mode uses two spaces for indentation. Minify mode emits the compact string without optional spaces or line breaks. Both modes rebuild the text; they do not merely insert or remove whitespace around the original characters.

Parsing proves the input follows the JSON grammar accepted by the browser. It does not prove that required properties exist, values have the right business meaning, or the object matches an API schema. `{"age":"old"}` is valid JSON even if an endpoint requires age to be a number. Schema validation remains a separate step.

The source field stays unchanged while the result panel shows the new serialization. Copy the output only after checking that restructuring did not affect something the destination treats specially, such as large integers, duplicate keys, or property order.

JSON requires double quotes around property names and string values. Single-quoted JavaScript objects are not JSON. Trailing commas are rejected, as are comments, `undefined`, `NaN`, `Infinity`, functions, and bare identifiers. The top-level value can be an object, array, string, number, boolean, or null; it does not have to be an object.

Backslashes inside strings introduce escapes. A Windows path such as `C: empile.txt` must escape each backslash in JSON text. Newlines inside a string must be written as ` `, not inserted as an unescaped physical line break. A quotation mark inside a value must be escaped. When the parser reports an error near a position, inspect the character before that position as well because an unclosed string can shift the apparent failure.

Numbers cannot start with a plus sign, use hexadecimal notation, or carry a leading zero such as `01`. JSON supports decimal and exponent forms. Yet valid syntax does not guarantee safe numeric precision in JavaScript, especially for large integers.

Copy only the JSON body, not HTTP headers, a shell prompt, Markdown fences, or a log prefix. Select pretty mode and run JSON Formatter. A valid result receives consistent two-space indentation, which makes nesting and array boundaries easier to inspect. If parsing fails, return to the source and locate the first syntax break instead of trying random punctuation changes.

For an API response, verify the top-level type and a few important paths after formatting. Check that arrays contain the expected number of entries, null values were not mistaken for missing fields, and numeric identifiers still display as expected. Formatting does not sort keys. JavaScript serialization follows its property-order rules based on the parsed object.

When sharing a sample, remove secrets and personal data before pasting it into any workbench. Replace values without changing their JSON types if the receiver needs to reproduce a parser issue. A fake number should remain a number, and an omitted property should not be replaced with the string `null`.

Minification removes indentation and optional whitespace from the serialized value. It can make a sample easier to place in a one-line environment variable, test fixture, or request body. It does not compress with gzip or Brotli, and it does not shorten property names or string content. Network compression may save more bytes than whitespace removal for large repetitive JSON.

Because the tool parses and serializes, minified output may differ from a mechanical whitespace stripper. Spaces inside strings remain because they are data. Escape sequences may be serialized consistently, and duplicate object keys collapse during parsing because only one property value survives in the JavaScript object. Treat duplicate keys as an input problem, not a formatting preference.

Do not minify a configuration file when comments are required, because comments are not valid JSON and cannot survive this parser. Formats such as JSON5, YAML, or JavaScript configuration have different rules. Use the parser and formatter designed for the source format.

JavaScript numbers use IEEE 754 double-precision representation. Integers beyond the safe range can lose precision when JSON.parse converts them to numbers, and JSON.stringify then writes the rounded value. Account IDs, database keys, and nanosecond timestamps are common examples. Encode such values as strings when the data contract permits it, or use a parser that preserves arbitrary-precision numbers.

Duplicate property names are another risk. In ` {"role":"user","role":"admin"} `, the parsed object retains one `role` value rather than both textual entries. Different parsers and security layers can disagree about duplicate handling, which makes them dangerous in signed or authorization data. Reject duplicates before reserialization when the distinction matters.

Formatting can also change escape presentation without changing the resulting string value. A Unicode character may appear directly rather than in an escaped form. Systems that compare raw JSON bytes, signatures, or canonical payloads need an agreed canonicalization method. Pretty output is for readability, not a canonical signature format.

Begin at the error position reported by the browser, then scan backward for an unmatched quote, brace, bracket, or escape. Reduce the input to the smallest failing object if the document is large. JSON errors often originate earlier than the visible marker because the parser stayed inside a string or array longer than intended.

Check for copied wrappers. A response may begin with `HTTP/1.1 200 OK`, a log line may add a timestamp, or a Markdown block may include triple backticks. Remove everything outside the JSON value. If the source is a JavaScript object literal, convert it according to JSON rules rather than globally replacing single quotes, which can corrupt apostrophes inside strings.

For machine-generated input, fix the producer. Manual repair can confirm a diagnosis, but it hides an escaping, serialization, or transport bug that will recur. Add the failing case to automated tests and serialize with a library instead of building JSON through string concatenation.

Formatting and validation execute in the current browser tab. The entered JSON and formatted output do not travel to PWRKIT for server-side processing. JSON often contains bearer tokens, API keys, email addresses, internal URLs, database identifiers, or customer records. Local operation does not remove the risks from clipboard history, browser extensions, session recovery, screenshots, and managed-device monitoring.

Redact before pasting. Replace secrets with clearly fake values of the same type and keep only the fields needed to reproduce the issue. Be cautious with nested objects and arrays because sensitive data can appear far below the visible top level. Search for common key names such as token, password, authorization, email, address, and secret, then perform a manual review.

Clearing the workbench removes the visible values but may not clear other copies. Follow the organization's incident and retention process if a production secret was pasted by mistake. Rotating a leaked credential is safer than assuming browser cleanup erased every trace.

Use JSON Formatter to validate JSON grammar and choose readable or compact serialization. Base64 tools only change representation; Base64-decoded text still needs JSON parsing before it can be trusted as structured data. JWT Decoder parses the token's Base64url header and payload as JSON, but it does not verify the signature or claims.

A regex tester can locate text patterns but should not replace a JSON parser. Nested structures, escapes, and strings make general JSON parsing with regular expressions unreliable. Timestamp Converter can interpret a timestamp property after you determine whether the value uses seconds, milliseconds, or a date string. Hash Generator fingerprints the exact serialized text, so pretty and minified forms will have different digests.

Production code should validate parsed data against a schema and handle errors at the boundary. Keep tests for empty input, top-level primitives, escaped characters, deep arrays, large integers, duplicate keys, null values, and malformed commas. The browser tool helps inspect examples; application validation enforces the contract.

An absent property and a property set to null are different JSON shapes. An empty string, zero, false, an empty array, and an empty object are also distinct values. Pretty printing makes them easier to spot but does not decide which meaning the API assigns. Preserve the type when creating a reduced reproduction.

Array order is data. Formatting keeps the parsed array order, while object member order should not be used as a substitute for an ordered list. If request signing or caching depends on raw member order, use the required canonical serialization rather than ordinary JSON.stringify output.

Deeply nested content can remain hard to review even with indentation. Trace a path one segment at a time and note whether each step is an object key or array index. A missing field at one level should not be confused with a null value deeper in a different item.

JSON has no native date, binary, UUID, decimal-money, map, or set type. Such values appear through conventions, usually strings, numbers, arrays, or objects. Formatting cannot verify those conventions. Apply schema and domain validation after parsing.

Strings containing Base64, HTML, URLs, or nested JSON remain strings. The formatter does not recursively decode or parse their contents. Inspect nested encodings only when the data contract says they exist, and keep each transformation as a separate, testable step.

For configuration changes, compare the parsed data and the serialized text. A semantic diff can show values that changed, while a text diff exposes escaping and layout. Review both when downstream tools might consume raw bytes or calculate a signature.

Huge JSON documents can exceed browser memory or become difficult to inspect in one textarea. The parser builds the complete value before serialization, so this is not a streaming viewer. Use command-line tooling, an editor with large-file support, or a streaming parser for large exports. Split only at valid document boundaries rather than cutting the text at an arbitrary byte position.