What are the most common JSON syntax errors?

Trailing commas after the last item in an object or array (not allowed in JSON, unlike JavaScript), single-quoted strings instead of double quotes, unquoted object keys, using undefined instead of null, and JavaScript-style comments — none of the last three are part of the JSON spec at all.

What exactly is the difference between JSON and a JavaScript object literal?

JSON is a strict subset: it requires double-quoted keys and string values, forbids trailing commas, comments, functions, and undefined, and only allows six value types (object, array, string, number, boolean, null). A JavaScript object literal allows all of the syntax JSON disallows, which is why copy-pasting a JS object directly as JSON often fails validation.

Can I format JSON directly from a live API URL?

Not directly inside this tool — paste the response body text into the input. To get that text, open your browser DevTools Network tab, find the request, and copy the response, or use curl / an API client and paste its output here.

Why does my JSON fail even though it looks correct at a glance?

The most common invisible culprits are a trailing comma before a closing } or ], a smart/curly quote character accidentally pasted in from a word processor instead of a straight double quote, or an extra or missing brace somewhere deep in a large nested structure. The parser error message names the exact character position so you can count into the string and find it.

Does minifying JSON change any of the actual data?

No — minifying only removes whitespace between tokens. It runs through the exact same JSON.parse step as formatting, so the parsed value is identical either way; only how many bytes of formatting surround that value differs in the two outputs.

Is there a size limit on how much JSON I can format?

No hard limit is imposed by the tool — it is bounded only by your browser's available memory and how large a string JSON.parse can handle, which in practice comfortably covers anything from a small config file to a multi-megabyte API dump.

Can JSON have comments like // or /* */?

No — comments are not part of the JSON specification at all, unlike JSON5 or JSONC (JSON with Comments) which some editors and config files support as a superset. If your input includes comments, JSON.parse will reject it; strip them first or use a JSON5-aware tool instead.

Is it safe to paste API keys, tokens, or database records into this tool?

Yes — parsing, formatting, and minifying all happen entirely inside your browser tab using the native JSON.parse/JSON.stringify functions. Nothing is transmitted to any server, so it is safe to inspect sensitive payloads, internal schemas, or user data exports here.

What does the error position number actually refer to?

It is the character offset (not a line/column pair) into the exact string you pasted, counting from zero at the very first character. For a large minified blob on one line, count that many characters in from the start, or paste the JSON into a code editor with a "go to character" feature to jump straight there.

All ToolsJSON Formatter

JSON Formatter

Format, minify, and validate JSON. Shows detailed error messages for invalid JSON.

ilovedocstools.com

JSON Formatter

Processing…

Processed on your device

What is JSON Formatter?

JSON Formatter takes raw, minified, or malformed JSON and either expands it into readable 2-space-indented output, collapses it into the smallest possible single-line string, or simply validates it against the strict JSON grammar — all three from the same input box.

JSON has become the default data-interchange format for the web precisely because it is a tiny, unambiguous subset of JavaScript object literal syntax: objects, arrays, strings, numbers, booleans, and null, nothing else. That minimalism is a feature for machines but a real cost for humans — a JSON API response is typically returned as one dense, unindented line with no regard for readability, since whitespace only adds bytes to the wire with zero benefit to a program parsing it. The moment you need to actually read that response — debugging an API integration, inspecting a JSONB column pulled from Postgres, reviewing a webhook payload, or auditing a config file — you need it expanded back into a structure a human can visually trace.

What makes JSON stricter, and therefore easier to validate deterministically, than its close cousin the JavaScript object literal is exactly the set of things it disallows: JSON requires double-quoted keys and string values (no single quotes, no unquoted identifiers), has no concept of undefined, functions, comments, or trailing commas, and every value must terminate in exactly one of its six allowed types. Those restrictions are why a JSON.parse() failure is always a real, fixable syntax problem rather than an ambiguous judgment call — the browser's native parser is the same strict, spec-compliant JSON engine used everywhere from Node.js to REST clients, so if it parses here, it will parse identically in your actual application code.

Minification runs in the opposite direction from formatting — it removes every byte of whitespace between tokens, which matters when JSON is embedded directly in source code, hardcoded into a small config file, or returned from an API where every kilobyte of response body affects latency on a slow connection. Both directions use the exact same JSON.parse/JSON.stringify round trip under the hood, just with a different indent argument, so the structural content is always identical — formatting and minifying a piece of JSON back and forth never changes a single key or value, only the whitespace between them.

How It Works

The tool feeds your input directly into the browser's native JSON.parse(), the same strict engine used across Node.js, browsers, and virtually every JSON library — there is no custom parsing logic that could behave differently from your actual application. On success, JSON.stringify(parsed, null, 2) rebuilds the value with 2-space indentation for the Format action, or JSON.stringify(parsed) with no indent argument for Minify, producing the smallest valid representation. If parsing fails, the exact error message JSON.parse throws — which names the unexpected token and the character position it occurred at — is surfaced directly, so you can count into the raw input and find precisely where the syntax broke rather than guessing. The Validate action runs the identical parse step and reports success or the same detailed error without producing new output. Everything happens synchronously in your browser tab.

How to Use

1
Paste your JSON
Paste raw JSON text into the input editor — a minified API response, a database export, or a config file all work, whether single-line or already partially formatted.
2
Format or minify
Click "Format" to pretty-print with 2-space indentation and clear nesting, or "Minify" to collapse the exact same data into the smallest valid single-line string.
3
Validate independently
Click "Validate" to check well-formedness without producing new output — useful when you just need a pass/fail check on a config file before committing it.
4
Read the error if one appears
If the JSON is invalid, the native parser's exact error message and character position are shown so you can count into the raw input and fix the precise spot that broke.
5
Copy the result
Click Copy to grab the formatted or minified output and paste it into your codebase, config file, or documentation.

Who Uses This Tool

🔍

Debugging API Responses

Paste raw JSON from an API call and instantly expand it into readable indented form to inspect nested fields.

✅

Validating Config Files

Check that JSON configuration files (package.json, tsconfig.json, etc.) are syntactically correct before committing.

📦

Minifying for Production

Collapse a pretty-printed JSON data file into a single line to reduce payload size for HTTP responses.

🛠️

Fixing Broken JSON

Use the detailed error messages with character positions to locate and fix malformed JSON quickly.

📋

Sharing Readable Data

Format raw JSON before including it in documentation, Slack messages, or GitHub issues for easy reading.

🗄️

Database Record Inspection

Beautify JSON stored in database columns (like PostgreSQL JSONB) to review record structure at a glance.

Why Choose This Tool

Three Tools in One

Format, minify, and validate JSON with dedicated buttons so you can perform all common JSON tasks without switching tools.

Precise Error Messages

JSON.parse error output includes the exact character position and description, making malformed JSON fast to diagnose.

Instant Valid Badge

A green "Valid JSON" indicator confirms your data is well-formed without producing unnecessary output.

No Size Limit

Handles large JSON payloads directly in the browser without timeouts or file-size restrictions.

Privacy First

All processing runs client-side so sensitive data like API keys and tokens never leaves your browser.

One-Click Copy

Copy the full formatted or minified output to your clipboard instantly without selecting text manually.

Also Try

Format XML Validate XML JS Beautifier CSS Beautifier HTML Beautifier Regex Tester

Key Benefits

Format JSON with clean 2-space indentation using the native JSON.parse/stringify engine
Minify JSON to the smallest valid single-line representation
Validate JSON independently and get the exact parser error and character position
Handles deeply nested objects and arrays of any size your browser can hold
Copy the formatted, minified, or validated result with one click
100% browser-based — safe for API tokens, schemas, and internal data

Frequently Asked Questions

Also Known As

json formatter online freejson beautifier and validatorpretty print json onlineformat json with indentationjson minifier onlinevalidate json syntax onlineonline json viewer formatterfix json errors online