JSON Beautifier

What a JSON beautifier does

A JSON beautifier takes JSON written compactly, usually on one line as an API sends it, and writes it out with a line break after every value and an indent for every level of nesting, so the structure can be read. It is also called pretty printing or formatting, and minifying is the reverse. Beautifying changes only whitespace, which RFC 8259 allows before or after any of the six structural characters (the brackets, the braces, the colon and the comma), so the data is the same before and after.¹ A compact response:

{"order":{"id":1042,"items":[{"sku":"A-17","qty":2},{"sku":"B-03","qty":1}],"total":48.50,"paid":false}}

Beautified with two spaces:

{
  "order": {
    "id": 1042,
    "items": [
      {
        "sku": "A-17",
        "qty": 2
      },
      {
        "sku": "B-03",
        "qty": 1
      }
    ],
    "total": 48.50,
    "paid": false
  }
}

Beautifying needs valid JSON to start from. If the text is not valid, this page says where it stops, with the line, the column and a hint, and Fix common mistakes repairs the usual causes: comments, trailing commas, single quotes, unquoted keys and Python's True and None. For a plain verdict without the layout, use the JSON validator; for a collapsible tree and a larger set of examples of what goes wrong, see the JSON formatter.

The options, with examples

Indent

The indent is the width of one level: 2, 3, 4 or 8 spaces, or a tab. It is a matter of style, so use whatever the file you are pasting into already uses. Python's json.tool indents by 4 spaces unless you pass --indent or --tab (checked with Python 3.12), and JSON.stringify indents by whatever you pass it, up to 10.^{2 3}

Sort keys

Sort keys puts the keys of every object in order, at every level. Keys are compared by their UTF-16 code units, which for ordinary text means capitals before lower-case letters, and two equal keys keep their original order. Arrays are never reordered, because the order of an array is part of the data. Sorting is most useful before comparing two documents with a diff tool. A document with its keys out of order:

{"b": 2, "a": {"z": 1, "y": 2}, "c": [3, 1]}

Sorted:

{
  "a": {
    "y": 2,
    "z": 1
  },
  "b": 2,
  "c": [
    3,
    1
  ]
}

Keep short arrays on one line

A list of numbers or tags takes one line per item when beautified, which makes a short list as tall as a long one. This option keeps an array on one line when it holds only plain values (strings, numbers, true, false or null) and the line would be at most 60 characters. A longer array, and any array that holds an object or another array, is laid out as usual. The same document with the option off:

{
  "name": "Ada",
  "tags": [
    "json",
    "tools",
    "free"
  ],
  "point": [
    23.588,
    58.382
  ],
  "history": [
    1,
    2,
    3,
    5,
    8,
    13,
    21,
    34,
    55,
    89,
    144,
    233,
    377,
    610,
    987,
    1597,
    2584
  ]
}

With it on, the short lists stay compact and the long one still breaks up:

{
  "name": "Ada",
  "tags": ["json", "tools", "free"],
  "point": [23.588, 58.382],
  "history": [
    1,
    2,
    3,
    5,
    8,
    13,
    21,
    34,
    55,
    89,
    144,
    233,
    377,
    610,
    987,
    1597,
    2584
  ]
}

Show \u escapes as characters

Some programs write every non-ASCII character as a \uXXXX escape: Python's json.dumps does by default, which turns Arabic, accented letters and emoji into runs of hexadecimal digits.² The escapes are valid and mean the same thing, but nobody can read them. This option shows each one as the character itself. The value of every string stays the same; only the way it is written changes, and the result parses to exactly the data you put in. Arabic, an accented letter, a symbol and an emoji, with a non-breaking space and a zero-width joiner that stay escaped, as it is written:

{
  "city": "\u0645\u0633\u0642\u0637",
  "hello": "\u0645\u0631\u062d\u0628\u0627",
  "cafe": "Caf\u00e9",
  "price": "\u20ac5",
  "smile": "\ud83d\ude00",
  "gap": "a\u00a0b\u200dc"
}

With the option on:

{
  "city": "مسقط",
  "hello": "مرحبا",
  "cafe": "Café",
  "price": "€5",
  "smile": "😀",
  "gap": "a\u00a0b\u200dc"
}

Only characters that are safe to show are decoded: letters, marks, numbers, punctuation and symbols. Anything that would be invisible, ambiguous or unsafe stays as an escape, with its original digits and letter case:

To get the same result from Python itself, pass ensure_ascii=False to json.dumps, or --no-ensure-ascii to python -m json.tool (Python 3.9 and later).²

How to pretty print JSON in Python, JavaScript and on the command line

In Python, json.dumps takes indent for the layout, sort_keys=True to order the keys and ensure_ascii=False to keep non-ASCII text readable. From a shell, python -m json.tool reads a file and pretty prints it, with the same choices as options.²

In JavaScript, the third argument of JSON.stringify sets the indentation: a number of spaces, clamped to 10, or a string of up to 10 characters.³ It has no option for sorting keys or for keeping short arrays on one line.

What beautifying never changes here

Both routes above parse the text and print it again, and printing from a parsed value can change the data: a whole number beyond 2⁵³ is rounded to the nearest 64-bit float, a trailing zero as in 10.50 is lost, an exponent as in 1E2 becomes 100, and a repeated key keeps only its last value. This page keeps the text of every number, every string (unless you tick the escape option) and every key exactly as written, and keeps duplicate keys in their original order, because it changes the whitespace and nothing else. The JSON formatter shows the numbers example in full.

Frequently asked questions

Sources

1. Bray, T. (ed.), RFC 8259, The JavaScript Object Notation (JSON) Data Interchange Format (IETF, 2017): insignificant whitespace is allowed before or after any of the six structural characters, and any character in a string may be written as a \uXXXX escape (sections 2 and 7).
2. Python Software Foundation, json — JSON encoder and decoder: the indent, sort_keys and ensure_ascii parameters of json.dumps, and the command-line options of json.tool (--indent, --sort-keys, --no-ensure-ascii).
3. MDN Web Docs, JSON.stringify(): the space argument, a number clamped to 10 or a string truncated to 10 characters.

The layouts this page produces are checked, for every combination of options, against a second implementation written separately in Python on thousands of documents, and the rule for which escapes are shown as characters is checked against Python's Unicode tables for every code point. The checks were shown to fail when the code they guard was deliberately broken.

Related tools