JSON Repair — Fix Broken JSON Online

LLM output is the top source of broken JSON today. Models wrap answers in ```json fences, put a sentence of prose before the payload, and stop mid-token at an output limit. The object inside is often fine; the wrapper and the missing tail are what make JSON.parse throw "Unexpected token" at position 0 or "Unterminated string" at the end.

Python is the second source. print(payload) and logging a dict both emit repr() syntax: single quotes plus True, False, and None with capital letters. json.dumps() would have produced valid JSON, but once the text sits in a log file that option is gone.

JavaScript object literals fail for a different reason. Source code and console output allow bare keys, // comments, trailing commas, undefined, NaN, and Infinity. All of that is valid JavaScript and none of it is valid JSON, which surprises you the first time you paste a config object into a parser.

The rest is transport damage: word processors swap straight quotes for curly ones, a payload gets copied together with the sentence introducing it, or log rotation cuts a line in half. Each of these breaks in a predictable way, which is why a deterministic repairer can fix them.

The repairer first tries a plain JSON.parse; input that already parses comes back pretty-printed and otherwise untouched. Otherwise it strips markdown fences, drops any prose before the first { or [, and normalizes smart quotes. Those three passes alone rescue most AI answers.

Comment stripping and the token pass are string-aware: content inside double-quoted strings passes through untouched, so a URL containing // or a string containing the word True never gets rewritten. The one exception is smart-quote normalization, which runs on the whole text because string boundaries in broken input are not yet trustworthy; a curly apostrophe inside a value comes out straight. The engine re-emits single-quoted strings through JSON.stringify, which escapes embedded quotes and backslashes correctly.

The token pass quotes bare keys, lowercases True and False, and rewrites None, undefined, NaN, and Infinity to null, because JSON defines no representation for them. It also deletes a comma whenever the next token closes an object or array.

Truncation repair runs last: close an unterminated final string, strip a dangling comma or colon, and append closing braces and brackets in stack order. A strict JSON.parse then decides the outcome. Success means pretty-printed output plus the full fix list; failure means you see the remaining parse error.

The JSON validator is read-only: it points at the first offending line and column and leaves your input alone. Reach for it when you control the producer, because fixing the code that emits broken JSON beats repairing its output forever.

Repair is for the consumer side, when the broken JSON comes from a system you cannot change: a third-party API, an old log, a model response. It rewrites the known mechanical breakages, tells you which ones it found, and behaves identically on every run, so you can build a habit around it.

AI Fix, an action inside the editor, handles what no mechanical pass can: keys named inconsistently, values in the wrong shape, a structure that needs reorganizing. It uses credits (signup includes 1,000 free) and, unlike this page, it sends the document to a model. Pick it when the problem is semantic rather than syntactic.

Repair does not invent data. If the input is not roughly JSON-shaped, say a YAML file or a paragraph of prose, the tool throws the remaining parse error instead of producing plausible-looking output. A repairer that always returns something would be worse than one that sometimes refuses.

Some fixes lose information by necessity. NaN, Infinity, undefined, and None flatten to null, comments disappear, and prose outside the payload gets discarded. The fix list exists so you can review each of these decisions; read it before the output goes anywhere important.

Truncation repair restores parseability, not content. The final string may end mid-word, and an array may hold fewer items than the producer intended, with no marker of where the cut happened. When the payload carries counts or checksums, verify them after repair rather than trusting the closed brackets.