JSON Beautifier

JSON Beautifier

What the JSON beautifier does

This page takes a JSON document and prints it with indentation and line breaks. In Beautify mode it uses four spaces per level and leaves forward slashes unescaped, so URLs stay readable. It can also switch to Minify mode, though the dedicated JSON Minifier page is a better fit if compact output is the only goal. The input limit is 200,000 characters, and the formatting happens on the server.

How to use it

Choose JSON as the language and Beautify as the mode. Paste the document into the editor, or use the URL tab to fetch a public JSON endpoint. Press the format button. The pretty-printed result appears in a read-only editor with input and output character counts. Use copy for the clipboard or download for a .json file. If the document is invalid, the page shows an error instead of a partial result.

What pretty printing changes

Beautify changes whitespace only. It adds indentation and line breaks so objects and arrays are easier to scan. It does not add comments, reorder keys, rename fields or repair missing commas. Key order is generally preserved in the output, but JSON objects are unordered by specification, so another parser may present the same data differently. The output is still JSON, not JavaScript with comments.

Invalid JSON is rejected

If the input has a trailing comma, a single quote, an unquoted key, a comment or an incomplete value, the parser will fail and the page will show an error. That is useful feedback, but it does not tell you exactly where every mistake is. For a large document, paste smaller sections or validate with a local linter. A successful beautify does not prove that the data matches your application's schema.

The empty-object edge case

The current server routine decodes JSON into a PHP array and then re-encodes it. An empty object written as a pair of braces can come back as an empty array written as a pair of brackets. Other objects with keys normally stay objects. If a downstream system distinguishes an empty object from an empty array, check that case before using the output. This is a real limitation, not a cosmetic detail.

Numeric string keys and arrays

When JSON is decoded into an associative array, keys that look like integers can be treated as list indexes. A document with keys such as 0, 1 and 2 may come back as a JSON array rather than an object. That changes the type of the value. If your data uses numeric string keys deliberately, keep the original or use a parser that preserves objects exactly.

Duplicate keys and large numbers

Most JSON parsers keep only one value when a key appears twice. The later value may win, and the duplicate is lost. Very large integers can also lose precision when they pass through a floating-point representation. If you are working with identifiers, money in minor units or snowflake IDs, compare the output with the source and consider a parser that preserves raw numbers.

Loading JSON from a URL

The URL tab asks the server to fetch a public address. The endpoint must return JSON directly; a login page, an HTML error page or a JavaScript-rendered response will fail. The server enforces the 200,000-character limit after fetching. Do not use this option for private APIs or endpoints that require credentials. Paste the response into the editor instead.

Limits and server processing

The server parses and re-encodes the document, with a maximum input of 200,000 characters and a depth limit of 512. Very deeply nested JSON will fail. Very large documents should be processed locally. The page returns the result to your browser and does not publish it. Download the output if you need to keep it.

Privacy and sensitive data

JSON payloads often contain customer records, tokens or internal configuration. Manual input is sent to the server, and URL loading is server-side. Do not paste secrets or personal data unless you accept that handling. For confidential payloads, use a local formatter or a command-line tool such as jq, and keep the data inside your own environment.

Common problems

If the output is empty, the input may be invalid or the request may have failed. Check for trailing commas, comments and single quotes. If an object became an array, look for numeric keys or an empty object. If a large number changed, precision was lost. If the page is slow, reduce the input size. If URL loading fails, confirm that the endpoint returns raw JSON without authentication.

When to use it

Use the page for a quick readability pass on an API response, a config file or a test fixture. It is convenient when you do not have jq or an editor with JSON formatting installed. For production data transformations, use a tested parser and a schema check. Do not use a beautifier as a migration tool or as proof that two documents are semantically equal.

Formatting for review

Pretty-printed JSON is easier to review in a pull request because each field sits on its own line. A reviewer can see a changed value instead of a wall of text. It is also easier to compare two documents side by side when both use the same indentation. The page does not produce a structural diff, so use a version-control diff or a JSON-aware comparison tool for that. Formatting is the first step; reviewing the meaning is still your job.

Keep the indentation style consistent with the rest of the repository. If the project uses two spaces rather than four, convert the result with the project's formatter before committing. The beautifier is a quick reading aid, not a replacement for the repository's rules.

Before and after: what the re-encoding does to values

Because the server parses the document and then writes it out again, the output is a fresh encoding of the data, not your original text with spaces added. Most of the time that makes no difference. A few values do come back in a different form, and it helps to see them side by side. Take this compact input:

{"name":"café 😀","url":"https://a.b/c","price":1.0,"limit":1e3,"html":"<b>&</b>"}

Beautify returns:

{
    "name": "café 😀",
    "url": "https://a.b/c",
    "price": 1,
    "limit": 1000,
    "html": "<b>&</b>"
}

Three changes are worth knowing about:

• Non-ASCII text is escaped. Accented letters, non-Latin scripts and emoji are written as \u escape sequences. The value is the same to any JSON parser, but it is much harder for a person to read, and a diff against the original will show every such line as changed.
• Number spelling can change. 1.0 is written as 1, and exponent notation such as 1e3 is written out as 1000. A consumer that checks for an integer versus a float, or a test that compares raw text, may notice.
• Slashes and HTML stay as typed. Forward slashes are not escaped, so URLs remain readable, and angle brackets and ampersands are left alone rather than turned into escape codes.

Practical tips for the page itself

The page opens on the URL Input tab. To format text you already have, switch to Manual Code, paste, and press Process Code. A fetched URL lands in the Manual Code editor first, so you can trim it before processing. The download is named beautify-output.json, or minify-output.json if you switched modes, so rename it before saving it next to the source. Changing the mode does not re-run the job on its own; press Process Code again. If you only want to read a document that contains a lot of non-English text, keep the original open alongside the output, since the escaped form is accurate but slow to scan.

Frequently Asked Questions