How do I pretty print JSON with 2 spaces in JavaScript?

Call JSON.stringify(value, null, 2) where 2 is the number of spaces to use for each indentation level. The second argument null means no replacer is applied. The result is a string with newlines and two spaces of indentation per nesting level. For example: JSON.stringify({ name: "Alice", roles: ["admin"] }, null, 2) produces a multiline string with each nested value on its own line. Two spaces is the most widely used convention for JSON in documentation, config files, and debugging output. Four spaces (null, 4) is also common in some projects.

Can I pretty print JSON directly in the browser console?

Yes. In Chrome, Firefox, and Safari DevTools, console.log automatically formats objects in an expandable tree view — you do not need to stringify at all for interactive inspection. If you want the formatted string itself, run JSON.stringify(yourObject, null, 2) in the console and the result will appear as a formatted multiline string. You can also log console.dir(yourObject) for an interactive object explorer. For inspecting a JSON string received from an API, paste it into the console and call JSON.parse on it, then log the result for the tree view.

Pretty Print JSON in JavaScript: Browser and Node.js Examples

Q: What is the difference between pretty print and minify for JSON?

Pretty printing adds newlines and indentation to make JSON readable by humans, increasing the file size. Minifying removes all unnecessary whitespace and newlines to produce the smallest possible string, reducing the file size. Pretty print is used for debugging, documentation, config files, and version-controlled data where readability matters. Minify is used for network payloads, API responses, and storage where bandwidth and size matter. In JavaScript, JSON.stringify(value) produces minified JSON by default. JSON.stringify(value, null, 2) produces pretty-printed JSON. A JSON formatter tool can do both directions interactively.

Q: How do I pretty print JSON in Node.js?

In Node.js, read the file with fs.readFileSync or fs.promises.readFile, parse it with JSON.parse, then stringify with indentation: const pretty = JSON.stringify(JSON.parse(raw), null, 2). Use console.log(pretty) to print it to stdout. To write it back to a file, use fs.writeFileSync("output.json", pretty). For one-liners from the command line, the node -e flag works: node -e "const d=require('./data.json');console.log(JSON.stringify(d,null,2))". Alternatively, pipe through Python: cat data.json | python3 -m json.tool, which is often available without installing anything.

Q: What is the maximum indentation JSON.stringify supports?

The JSON.stringify space parameter is clamped to a maximum of 10. If you pass a number greater than 10, it is treated as 10. Passing a string instead of a number uses that string as the indentation unit, and the string is truncated to 10 characters if it is longer. In practice, 2 or 4 spaces covers virtually all use cases. Using more than 4 spaces rarely improves readability and increases file size unnecessarily. Tab indentation (null, "\t") is another common choice for config files where tabs are a project convention.

Q: How do I pretty print JSON to a file in Node.js?

Use fs.writeFileSync with the formatted string: import { readFileSync, writeFileSync } from "node:fs"; const data = JSON.parse(readFileSync("input.json", "utf8")); writeFileSync("output.json", JSON.stringify(data, null, 2) + "\n"). The trailing newline keeps the file POSIX-compliant and avoids "no newline at end of file" warnings in version control diffs. For large files, use the async streaming alternatives (fs.promises.writeFile) to avoid blocking the event loop. Most JSON config files in Node.js projects use 2-space indentation, matching the default for npm, ESLint, and Prettier configurations.

Last updated: May 11, 2026

Pretty-printing JSON adds indentation and line breaks to make compact JSON human-readable. In JavaScript, JSON.stringify(value, null, 2) does it in 1 call — the 3rd argument sets indent width (0–10 spaces, or '\t' for tabs). In the terminal, python -m json.tool and jq . both format without installing anything. Passing null as the replacer argument preserves all fields; passing an array of key strings or a replacer function filters or transforms values. This guide covers browser and Node.js JSON.stringify usage, the space edge cases (values above 10 are clamped to 10), pretty-printing inside a <pre> HTML tag, terminal options (python -m json.tool, jq ., cat file.json | python3 -m json.tool), and the toJSON() override method.

Pretty print a JavaScript object

If you already have a JavaScript object, stringify it with a spacing argument. Two spaces is the safest default for docs, config examples, and debug output.

const data = {
  user: {
    id: 42,
    name: 'Alice'
  },
  roles: ['admin', 'editor']
}

const pretty = JSON.stringify(data, null, 2)
console.log(pretty)

Pretty print a JSON string

If the input is already a JSON string, parse it first, then stringify the parsed value.

const raw = '{"user":{"id":42,"name":"Alice"},"roles":["admin","editor"]}'
const pretty = JSON.stringify(JSON.parse(raw), null, 2)

console.log(pretty)

// {
//   "user": {
//     "id": 42,
//     "name": "Alice"
//   },
//   "roles": [
//     "admin",
//     "editor"
//   ]
// }

Handle invalid JSON safely

Pretty printing a string requires parsing, and parsing can throw. Wrap untrusted input intry/catch.

function prettyPrintJson(raw) {
  try {
    return {
      ok: true,
      value: JSON.stringify(JSON.parse(raw), null, 2)
    }
  } catch (error) {
    return {
      ok: false,
      error: error instanceof Error ? error.message : 'Invalid JSON'
    }
  }
}

Choose 2 spaces, 4 spaces, or tabs

The third argument accepts a number or a string. Numbers are clamped to 10 spaces. Strings are used as the indentation unit.

JSON.stringify(data, null, 2)   // 2 spaces
JSON.stringify(data, null, 4)   // 4 spaces
JSON.stringify(data, null, '	') // tabs

For shared examples, use 2 spaces unless your project has a strong convention.

Pretty print JSON in the browser

A small browser formatter can read a textarea, parse the JSON, and write formatted output.

const input = document.querySelector('#json-input')
const output = document.querySelector('#json-output')

try {
  output.textContent = JSON.stringify(JSON.parse(input.value), null, 2)
} catch (error) {
  output.textContent = 'Invalid JSON'
}

Pretty print JSON in Node.js

For scripts, parse stdin or file content, then output formatted JSON.

import { readFileSync } from 'node:fs'

const raw = readFileSync('data.json', 'utf8')
const pretty = JSON.stringify(JSON.parse(raw), null, 2)

console.log(pretty)

Common mistakes

Calling JSON.stringify(raw, null, 2) on a JSON string instead of parsing it first.
Expecting pretty printing to fix invalid JSON syntax.
Forgetting that functions, undefined, and symbols do not appear in JSON output.
Pretty printing large files in the UI thread without considering browser performance.

Pretty print JSON instantly

Use Jsonic's JSON Formatter when you want readable output, validation errors, minification, file upload, and copy/download actions in one place.

Open JSON Formatter

Frequently asked questions

How do I pretty print JSON with 2 spaces?

Call JSON.stringify(value, null, 2). The third argument is the indentation width. Two spaces is the most common convention for documentation, config files, and debug output.

What is the difference between pretty print and minify?

Pretty printing adds newlines and indentation for human readability, increasing file size. Minifying removes all whitespace for compact network payloads. JSON.stringify(value)minifies by default.

How do I pretty print JSON in Node.js?

Read the file with fs.readFileSync, parse it, then stringify with indentation:JSON.stringify(JSON.parse(raw), null, 2). Write back withfs.writeFileSync.

Can I pretty print JSON in the browser console?

The browser DevTools console automatically formats objects as an expandable tree. For the formatted string, run JSON.stringify(obj, null, 2) in the console.

What is the maximum indentation JSON.stringify supports?

The space argument is clamped to 10. Numbers above 10 are treated as 10. You can also pass a string like '\t' for tab indentation.

How do I pretty print JSON to a file in Node.js?

Use fs.writeFileSync('output.json', JSON.stringify(data, null, 2) + '\n'). The trailing newline keeps the file POSIX-compliant and avoids diff noise in version control.