How do I repair broken or invalid JSON data?

How it works

Repairing broken JSON starts with identifying the specific syntax error through a validator or parser error message. Common issues include trailing commas, unquoted keys, single quotes instead of double quotes, missing brackets, or unescaped control characters within strings. Once located, you can manually fix simple mistakes by ensuring all keys and string values use double quotes, removing trailing commas before closing braces or brackets, and verifying that every opening brace, bracket, and quote has a matching closing counterpart. For truncated files, you may need to reconstruct missing closing delimiters by counting nesting levels. Automated tools like jsonrepair or language-specific libraries can handle many common malformations programmatically, especially when dealing with output from LLMs or legacy systems that emit near-valid JSON.

Also worth reading: How Does AI Photo Restoration Verify and Repair Old Images? · How to restore vintage family photos using AI colorization and digital repair techniques in 2026? · How to Colorize Biblical Images with AI: A Step‑by‑Step Guide for Beginners?

When automated repair fails, a more surgical approach works best: isolate the problematic section, then parse incrementally using a streaming parser that tolerates errors or a regex-based cleanup pass targeting known patterns like Python-style True/False/None or JavaScript undefined. For large datasets, consider splitting the input and validating chunks independently to locate corruption boundaries. Always preserve the original before modifying, and log repairs for auditability. If the source is controllable, fix the generator rather than patching output — consistent serialization prevents recurring corruption.

What it costs

Repairing broken JSON starts with identifying the syntax error: missing quotes around keys, trailing commas, unescaped control characters, or mismatched brackets. A good first step is to paste the fragment into a validator like jsonlint.com or run it through jq . which will pinpoint the line and column of the failure. For minor issues — single quotes instead of double, comments, or a dangling comma — a quick manual edit often suffices. When the damage is larger, such as truncated files or concatenated objects, you can write a small script using a forgiving parser like Python’s demjson or json5 that tolerates common deviations and outputs strict JSON. If the data comes from a stream, consider wrapping each line as a separate JSON value and processing them incrementally.

Once you have a candidate repair, validate it again against a schema if one exists, or at least spot‑check critical fields for type consistency. Automate the fix in your ingestion pipeline so future malformed payloads are caught early, and log the original bytes for audit purposes. Prevention beats repair: enforce strict serialization on the producer side, use a schema registry, and reject non‑conforming input at the boundary rather than cleaning it downstream.

Common mistakes

When repairing broken or invalid JSON, first preserve the original text and work on a copy. Parse it with a tool that reports the line, column, and nearby characters, then inspect that area for an unescaped quote, missing comma, trailing comma, incorrect bracket, control character, or incomplete value. Also check whether single quotes, comments, unsupported number forms, or raw backslashes and newlines were introduced. Correct one issue at a time and rerun the parser, because fixing an early error may reveal later ones. Comparing an earlier version can also expose accidental edits.

If strict parsing fails, try a repair library or lenient parser, but validate the result before using it. For large files, isolate the failing region without losing bracket or string context. Avoid global find-and-replace operations, since they can damage valid content. Quoted text needs special attention, and recovered records should be checked for duplicates, missing fields, and altered values. Test the repaired data with representative records and keep a backup before overwriting the source.

When to act

Broken JSON often fails for an identifiable reason: a missing comma or quote, a trailing comma, malformed braces, invalid escaping, unquoted keys, or invalid encoding. Preserve the original file or response, then inspect the line and column reported by a parser. Read errors from the bottom up because an early mistake can cause misleading messages later. Check invisible characters, number formats, and unescaped quotes or newlines inside values. For an API response, capture the raw payload before application code transforms it.

After the text parses, repair meaning as well as syntax. Compare it with the expected schema, confirm required fields and value types, and decide how to handle duplicate keys, nulls, or unexpected values. Use a parser that pinpoints trouble rather than deleting text by trial and error. In a file, validate one record or subtree at a time. Save a copy, rerun validation, and test edge cases before replacing production data. If the original is unrecoverable, reconstruct it from a trusted source or rebuild it field by field; never treat partial output as valid.

What to check first

When you encounter broken or invalid JSON, the first step is to verify the basic structure by checking that every opening brace or bracket has a matching closing counterpart and that keys are enclosed in double quotes. Look for common syntax errors such as trailing commas after the last element in an object or array, missing commas between values, or stray characters outside the defined data. Using a JSON validator or an online linting tool can quickly highlight the exact line and column where the parser fails, giving you a clear starting point for correction.

Once the problematic location is identified, you can fix it by adding the missing quote, removing the extra comma, or inserting the needed delimiter. If the file is large, a programmable approach using a language‑specific JSON library to parse, catch the exception, and then apply a heuristic repair—such as stripping non‑JSON characters or balancing braces—can be efficient. After editing, run the validator again to confirm that the output is syntactically correct before feeding it back into your application.

We need to obey user request: start immediately with line "## How the options compare". Then a markdown table with 3 columns and 4 data rows about: "How do I repair broken or invalid JSON data?" So table columns maybe: Option, Description, Pros/Cons? Not specified. Just need 3 columns and 4 rows. Must be about that topic. Then one paragraph about 60 words. No other headings. No JSON. No preamble. Also note that there is a bunch of notes about site colorizethis.io etc. But the instruction says "No other headings. No JSON. No preamble." So we must ignore those notes? The user gave notes but we must produce the required output. The notes seem irrelevant to the request; maybe they are context but we just need to produce the table and paragraph.

We must ensure the paragraph is about 60 words. Let's craft ~60 words. Count words.

Paragraph: "Repairing broken JSON typically involves locating the syntax error—such as missing commas, brackets, or quotes—using a validator or editor that highlights issues, then manually correcting the problematic sections; alternatively, you can write a small script to parse the data, fix common malformed patterns, and re‑serialize it, ensuring the final output conforms to strict JSON standards."

Count words: Let's count.

"Repairing(1) broken2 JSON3 typically4 involves5 locating6 the7 syntax8 error—such9 as10 missing11 commas,12 brackets,13 or14 quotes—using15 a16 validator17 or18 editor19 that20 highlights21 issues,22 then23 manually24 correcting25 the26 problematic27 sections;28 alternatively,29 you30 can31 write32 a33 small34 script35 to36 parse37 the38 data,39 fix40 common41 malformed42 patterns,43 and44 re‑serialize45 it,46 ensuring47 the48 final49 output50 conforms51 to52 strict53 JSON54 standards55."

55 words. Need about 60 words, maybe 60-65. Add a few more words: "and avoid future corruption." Let's add: "and avoid future corruption." That's 4 words? "and"1 "avoid"2 "future"3 "corruption"4. So total 55+4=59. Need about 60, maybe add "overall" as 1 more. So "and avoid future corruption overall." That's 5 words (and, avoid, future, corruption, overall). Let's recount: we had 55, add 5 = 60. Let's recount final paragraph.

Full paragraph: "Repairing broken JSON typically involves locating the syntax error—such as missing commas, brackets, or quotes—using a validator or editor that highlights issues, then manually correcting the problematic sections; alternatively, you can write a small script to parse the data, fix common malformed patterns, and re‑serialize it, ensuring the final output conforms to strict JSON standards and avoid future corruption overall."

Now count words again.

Repairing1 broken2 JSON3 typically4 involves5 locating6 the7 syntax8 error—such9 as10 missing11 commas,12 brackets,13 or14 quotes—using15 a16 validator17 or18 editor19 that20 highlights21 issues,22 then23 manually24 correcting25 the26 problematic27 sections;28 alternatively,29 you30 can31 write32 a33 small34 script35 to36 parse37 the38 data,39 fix40 common41 malformed42 patterns,43 and44 re‑serialize45 it,460