How to Format JSON: Pretty Print and Beautify Guide 2026

# How to Format JSON: Pretty Print and Beautify Guide

Formatting JSON properly is essential for readability and debugging. Whether you're working with API responses, configuration files, or data exports, this comprehensive guide will show you every method to format and beautify JSON in 2026.

Why Format JSON?

Readability

{"name":"John","age":30,"address":{"street":"123 Main St","city":"NYC"},"hobbies":["reading","coding"]}

{
  "name": "John",
  "age": 30,
  "address": {
    "street": "123 Main St",
    "city": "NYC"
  },
  "hobbies": [
    "reading",
    "coding"
  ]
}

Debugging

Formatted JSON makes it easier to:

• Spot syntax errors
• Identify missing commas
• Verify data structure
• Track down issues

Version Control

Properly formatted JSON produces cleaner diffs in Git.

Method 1: Online JSON Formatters

Big JSON Viewer

Fast, handles large files:

JSONLint

Validates and formats:

JSON Formatter

Simple and quick:

Method 2: Command Line Tools

Using jq

The most powerful command-line JSON processor:

# Format JSON file
jq . input.json

# Format and save
jq . input.json > formatted.json

# Format with 4-space indentation
jq --indent 4 . input.json

# Format from API response
curl https://api.example.com/data | jq .

# Compact (minify)
jq -c . input.json

# macOS
brew install jq

# Ubuntu/Debian
sudo apt-get install jq

# Windows (with Chocolatey)
choco install jq

Using Python

Built-in tool:

# Format JSON file (2-space indent)
python -m json.tool input.json

# Format with custom indent
python -m json.tool --indent 4 input.json > formatted.json

# Format from stdin
echo '{"name":"John","age":30}' | python -m json.tool

Using Node.js

Quick one-liner:

# Format JSON file
node -e "console.log(JSON.stringify(require('./input.json'), null, 2))"

# From string
node -e "console.log(JSON.stringify(JSON.parse(process.argv[1]), null, 2))" '{"a":1,"b":2}'

Method 3: Code Editors

Visual Studio Code

{
  "editor.formatOnSave": true,
  "editor.tabSize": 2,
  "[json]": {
    "editor.defaultFormatter": "vscode.json-language-features",
    "editor.formatOnSave": true
  }
}

Sublime Text

Vim

:%!jq .

:%!python -m json.tool

Method 4: Programming Languages

JavaScript/Node.js

// Format with 2-space indentation
const data = {name: "John", age: 30, city: "NYC"};
const formatted = JSON.stringify(data, null, 2);
console.log(formatted);

// Format from string
const jsonString = '{"name":"John","age":30}';
const parsed = JSON.parse(jsonString);
const pretty = JSON.stringify(parsed, null, 2);

// Read file and format
const fs = require('fs');
const rawData = fs.readFileSync('input.json');
const jsonData = JSON.parse(rawData);
const formatted = JSON.stringify(jsonData, null, 2);
fs.writeFileSync('output.json', formatted);

// 4 spaces
JSON.stringify(data, null, 4);

// Tab character
JSON.stringify(data, null, '\t');

// Custom string
JSON.stringify(data, null, '    ');

Python

import json

# Format dictionary
data = {"name": "John", "age": 30, "city": "NYC"}
formatted = json.dumps(data, indent=2)
print(formatted)

# Format from string
json_string = '{"name":"John","age":30}'
parsed = json.loads(json_string)
pretty = json.dumps(parsed, indent=2)

# Read and format file
with open('input.json', 'r') as f:
    data = json.load(f)

with open('output.json', 'w') as f:
    json.dump(data, f, indent=2)

# Sort keys alphabetically
formatted = json.dumps(data, indent=2, sort_keys=True)

# Ensure ASCII (escape unicode)
formatted = json.dumps(data, indent=2, ensure_ascii=True)

PHP

<?php
$data = array(
    "name" => "John",
    "age" => 30,
    "city" => "NYC"
);

// Format with pretty print
$formatted = json_encode($data, JSON_PRETTY_PRINT);
echo $formatted;

// Additional options
$formatted = json_encode($data, 
    JSON_PRETTY_PRINT | 
    JSON_UNESCAPED_SLASHES | 
    JSON_UNESCAPED_UNICODE
);

// Read and format file
$jsonString = file_get_contents('input.json');
$data = json_decode($jsonString, true);
$formatted = json_encode($data, JSON_PRETTY_PRINT);
file_put_contents('output.json', $formatted);
?>

Java

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;

public class JsonFormatter {
    public static void main(String[] args) {
        // Create Gson instance with pretty printing
        Gson gson = new GsonBuilder()
            .setPrettyPrinting()
            .create();

        // Format object
        Person person = new Person("John", 30);
        String formatted = gson.toJson(person);
        System.out.println(formatted);

        // Format from string
        String jsonString = "{\"name\":\"John\",\"age\":30}";
        Object obj = gson.fromJson(jsonString, Object.class);
        String pretty = gson.toJson(obj);
    }
}

C#

using System;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;

class Program
{
    static void Main()
    {
        // Format object
        var person = new { Name = "John", Age = 30 };
        string formatted = JsonConvert.SerializeObject(person, 
            Formatting.Indented);
        Console.WriteLine(formatted);

        // Format from string
        string jsonString = "{\"name\":\"John\",\"age\":30}";
        JObject obj = JObject.Parse(jsonString);
        string pretty = obj.ToString(Formatting.Indented);
    }
}

Method 5: Browser DevTools

Chrome/Edge DevTools

Or use Console:

// Format in console
const data = '{"name":"John","age":30}';
console.log(JSON.parse(data));

// Or
copy(JSON.stringify(JSON.parse(data), null, 2));
// Then paste formatted JSON

Firefox DevTools

Similar to Chrome, with automatic JSON formatting in Network tab.

Advanced Formatting Options

Custom Replacer Function

const data = {
  name: "John",
  password: "secret123",
  age: 30,
  createdAt: new Date()
};

// Hide sensitive data and format dates
const formatted = JSON.stringify(data, (key, value) => {
  if (key === 'password') return '';

  if (value instanceof Date) return value.toISOString();
  return value;
}, 2);

function sortKeys(obj) {
  if (typeof obj !== 'object' || obj === null) return obj;
  if (Array.isArray(obj)) return obj.map(sortKeys);

  return Object.keys(obj)
    .sort()
    .reduce((sorted, key) => {
      sorted[key] = sortKeys(obj[key]);
      return sorted;
    }, {});
}

const formatted = JSON.stringify(sortKeys(data), null, 2);

import json

# Custom indent width
json.dumps(data, indent=4)  # 4 spaces

# Tab indentation
json.dumps(data, indent='\t')

# Custom separator
json.dumps(data, indent=2, separators=(',', ': '))

# Minify with jq
jq -c . input.json > minified.json

// Minify in JavaScript
JSON.stringify(data);  // No spacing

Bash script:

#!/bin/bash
for file in .json; do
  jq . "$file" > "formatted_$file"
done

import json
import os
import glob

for filepath in glob.glob('.json'):

    with open(filepath, 'r') as f:
        data = json.load(f)

    with open(filepath, 'w') as f:
        json.dump(data, f, indent=2)

#!/bin/bash
# .git/hooks/pre-commit

for file in $(git diff --cached --name-only | grep -E '\.json$'); do
  jq . "$file" > "$file.tmp" && mv "$file.tmp" "$file"
  git add "$file"
done

{
  "name": "John",  // Comments not allowed
  'age': 30,       // Single quotes not allowed
  "city": "NYC",   // Trailing comma not allowed
}

jq . large-file.json > formatted.json

with open('file.json', 'r', encoding='utf-8') as f:
    data = json.load(f)

# .editorconfig
[.json]
indent_style = space
indent_size = 2
end_of_line = lf
charset = utf-8
trim_trailing_whitespace = true
insert_final_newline = true

Conclusion

Formatting JSON is a fundamental skill for developers. Whether you prefer online tools, command-line utilities, or programming language built-ins, there's a method that fits your workflow.

For quick tasks, use online formatters or browser DevTools. For automation and large files, use command-line tools like jq. For integration into your code, use language-specific JSON libraries.

Remember: formatted JSON is easier to read, debug, and maintain. Make formatting a habit in your development workflow.