JSON Formatter

When You Need JSON Formatting

Unformatted JSON shows up constantly in development workflows. API responses from REST endpoints arrive as a single minified line, making it nearly impossible to spot whether a field is missing or has the wrong type. Pasting that response into a formatter and expanding it instantly reveals the structure — a 30-second step that has saved hours of debugging more times than anyone will admit.

Configuration files are another daily scenario. Docker Compose, GitHub Actions, and package.json all use JSON or YAML derivatives; when a CI pipeline fails with a cryptic parse error, a formatter with inline validation pinpoints the offending line immediately. The same applies to log analysis: structured log systems (Datadog, ELK) emit JSON per log line, and piping a single entry through a formatter reveals nested context fields that scroll off the terminal.

JSON itself is defined by RFC 8259 (superseding RFC 4627 in 2017), which specifies that strings must use double quotes, objects must not contain duplicate keys, and trailing commas are illegal. These rules are intentionally strict so that any compliant parser can produce identical output — which is exactly why a validator that flags RFC violations is more useful than one that silently accepts sloppy input.

Formatting JSON Programmatically

Use the browser tool for one-off inspection during debugging. Reach for the Node.js one-liner when you need to format files in a shell pipeline without installing extra dependencies.

// Pretty-print with 2-space indent (most readable for logs/config)
const formatted = JSON.stringify(data, null, 2);

// Minify — strip all whitespace for API payloads or storage
const minified = JSON.stringify(data);

// Safely parse with error handling
function parseJSON(raw) {
  try {
    return { data: JSON.parse(raw), error: null };
  } catch (err) {
    return { data: null, error: err.message };
  }
}

// Node.js CLI: pretty-print a file
// node -e "process.stdout.write(JSON.stringify(JSON.parse(require('fs').readFileSync(0,'utf8')),null,2))"

Common JSON Mistakes

• Trailing commas after the last element in an array or object: `[1, 2, 3,]` is valid JavaScript but illegal JSON per RFC 8259.
• Single quotes instead of double quotes: `{'key': 'value'}` is not JSON. All strings — including keys — must use double quotes.
• Unquoted keys: `{key: 'value'}` is JavaScript object literal syntax, not JSON. Keys must always be quoted strings.
• Comments in JSON: `// comment` and `/* comment */` are not valid JSON. Use JSONC (JSON with Comments) parsers for config files that need annotations.
• Duplicate keys: RFC 8259 says behavior is undefined when keys repeat. Most parsers silently take the last value, which hides bugs in generated JSON.
• NaN and Infinity values: JavaScript's `JSON.stringify` converts `NaN` and `Infinity` to `null` without warning — a silent data loss issue in numeric pipelines.