Example — Broken JSON

{ name: "Alice" 'age': 30, "skills": ["JavaScript", "Python",], "address": {"city": "NYC" }

Issues: unquoted keys, single quotes, trailing comma, missing comma, missing closing brace.

How Auto-Fix Works

Invalid JSON is one of the most common frustrations developers face. A single missing comma, an unquoted key, or a trailing comma can break an entire configuration file or API payload. Rather than manually hunting for errors, this tool automatically detects and repairs common JSON syntax issues.

Issues This Tool Can Repair

Missing commas — Detects values on separate lines without separating commas and adds them
Unquoted keys — Wraps bare property names in double quotes (e.g., name: becomes "name":)
Single quotes — Converts single-quoted strings to proper double quotes
Trailing commas — Removes commas before closing braces } or brackets ]
Smart/curly quotes — Replaces typographic quotes with standard ASCII quotes
Unmatched brackets — Adds missing closing braces or brackets
BOM characters — Removes invisible byte-order marks that break parsing

How Is This Different from JSON Lint?

Traditional JSON validators like JSONLint only tell you what's wrong — they report errors but don't fix them. This tool goes further by actually repairing the broken JSON automatically. It shows you exactly which fixes were applied, so you can learn from the corrections and understand what went wrong.

Related Tools

✨ JSON Formatter & Validator

Pretty-print and validate your fixed JSON.

🔍 JSON Compare & Diff

Compare original vs fixed JSON side-by-side.

🌳 JSON Tree Viewer

Explore your fixed JSON in an interactive tree.

🔄 JSON ↔ XML Converter

Convert your JSON to XML or vice versa.

Common JSON Syntax Errors Explained

JSON has a strict syntax that does not tolerate the flexibility found in JavaScript objects or other data formats. Understanding why these errors occur and how to recognize them will help you write cleaner JSON and debug problems faster. This guide covers each common error type in detail, explains where they come from, and shows you how to prevent them.

Missing Commas

Missing commas between key-value pairs or array elements is the most frequent JSON error. It typically happens when you add a new property or array item and forget to add the comma after the previous one.

// ❌ Invalid - missing comma between properties { "name": "Alice" "age": 30 } // ✅ Valid - comma added { "name": "Alice", "age": 30 }

This error often appears when manually editing JSON files or when copying code from JavaScript where trailing commas are allowed. The parser error message typically says "Expected comma" or "Unexpected string" at the line where the missing comma should be.

Trailing Commas

A trailing comma is a comma after the last item in an object or array. JavaScript allows this, but strict JSON does not. This is one of the most common errors when copying JavaScript objects to JSON files.

// ❌ Invalid - trailing comma after last item { "colors": ["red", "green", "blue",] } // ✅ Valid - no trailing comma { "colors": ["red", "green", "blue"] }

Many modern code editors and linters can automatically remove trailing commas. This tool detects and removes them automatically during the fix process.

Unquoted Keys

In JavaScript, object keys do not need quotes if they are valid identifiers. JSON requires all keys to be quoted strings with double quotes. This error commonly appears when copying JavaScript object literals directly into JSON files.

// ❌ Invalid - unquoted keys { name: "Alice", age: 30 } // ✅ Valid - keys in double quotes { "name": "Alice", "age": 30 }

This tool automatically wraps bare identifiers in double quotes. However, if the key contains special characters or spaces, manual quoting may be required.

Single Quotes Instead of Double Quotes

JSON strictly requires double quotes for strings. Single quotes, which are valid in JavaScript, Python, and many other languages, cause parse errors in JSON.

// ❌ Invalid - single quotes { 'name': 'Alice', 'city': 'New York' } // ✅ Valid - double quotes { "name": "Alice", "city": "New York" }

This error often appears when copying data from Python dictionaries or JavaScript using single-quote style. The fix tool automatically converts all single quotes to double quotes.

Unmatched Brackets and Braces

Every opening bracket [ needs a closing ], and every opening brace { needs a closing }. Missing brackets typically occur when editing deeply nested structures or when copy-pasting partial JSON.

// ❌ Invalid - missing closing brace { "user": { "name": "Alice", "address": { "city": "NYC" } // ✅ Valid - all brackets matched { "user": { "name": "Alice", "address": { "city": "NYC" } } }

This tool attempts to add missing closing brackets at appropriate nesting levels. However, for severely malformed JSON, manual intervention may be needed to ensure the structure is correct.

Understanding JSON.parse Error Messages

When JSON fails to parse, browsers and runtimes provide error messages that can help locate the problem. Understanding these messages speeds up debugging:

"Unexpected token" — The parser found a character where it expected something else. Often indicates missing quotes or commas.
"Unexpected end of JSON input" — The JSON ended before the parser expected. Usually means missing closing brackets.
"Expected property name" — The parser expected a quoted key but found something else. Often means unquoted keys.
"Expected ':' after property name" — A key was found but the colon separator is missing.
"Position X" — The character position (from the start) where the error was detected. Useful for locating the problem.

Prevention Strategies

The best way to avoid JSON errors is to prevent them from being introduced in the first place:

Use a JSON-aware editor — VS Code, WebStorm, and other modern editors highlight JSON errors in real-time.
Enable linting — ESLint with JSON plugins catches errors before you save the file.
Validate in CI/CD — Add JSON validation to your build pipeline to catch errors before deployment.
Use TypeScript — When generating JSON from code, TypeScript ensures type safety and proper structure.
Serialize programmatically — Use JSON.stringify() instead of manually constructing JSON strings.

When Auto-Fix Cannot Help

This tool fixes syntax errors, but it cannot fix semantic errors or logical problems:

Wrong data types — If a number should be a string (or vice versa), auto-fix will not change it.
Missing required fields — The tool does not know what fields your application expects.
Incorrect values — Typos in values, wrong IDs, or incorrect data remain unchanged.
Schema violations — Auto-fix makes valid JSON, not JSON that matches a specific schema.
Severely corrupted data — If the JSON is too broken, automatic repair may produce unexpected results.

JSON Validation vs JSON Fixing

Validation and fixing are complementary but different operations. Validation tells you whether JSON is correct and reports specific errors. Fixing attempts to repair those errors automatically. A typical workflow is: try to parse, if it fails then auto-fix, then validate the result to confirm it is correct.

For production systems, always validate JSON at boundaries — when receiving API input, reading configuration files, or processing user uploads. Auto-fix tools are excellent for development and debugging but should not replace proper validation in production code.

Manual Debugging Techniques

When auto-fix cannot solve the problem, try these manual debugging approaches:

Binary search — Delete half the JSON and try parsing. Repeat to narrow down the error location.
Line-by-line validation — Parse incrementally, adding lines until you find the one that breaks.
Bracket matching — Use an editor with bracket highlighting to find unmatched pairs.
Diff against known good — Compare your broken JSON against a working version to spot differences.
Format first — Sometimes formatting reveals structural issues that are hidden in minified JSON.

Understanding these errors and how to fix them makes you a more effective developer. While this tool handles most common issues automatically, knowing what is happening under the hood helps you write better JSON and debug problems faster when they occur.

🔧 Auto-Fix Invalid JSON