How to Fix Broken JSON from ChatGPT & Other LLMs — Free Online Repair Tool

Why Do ChatGPT and Other LLMs Output Invalid JSON?

LLMs are text prediction engines, not strict parsers. They generate JSON by predicting the most likely next token based on training data — which includes enormous amounts of JavaScript, Python, YAML, and JSON5 in addition to strict JSON. These formats all look similar but have different rules.

JavaScript object literals allow trailing commas and unquoted keys. Python dictionaries use single quotes. YAML and JSON5 allow comments. The model has learned all of these conventions and conflates them, especially when generating longer or more complex JSON structures where attention on earlier formatting rules degrades.

Even with a system prompt that says "return only valid JSON," models slip up. The fix is either preventing the issue at the prompt/API level, or having a reliable repair step before you call JSON.parse().

Fix Broken LLM JSON in 60 Seconds (No Code)

Every Common LLM JSON Error — and How to Fix Each One

Here is a complete breakdown of every JSON error type that LLMs produce, why it happens, and the exact fix — both manually and automatically.

{
  "name": "Alice",
  "role": "admin",   ← trailing comma
}

{
  "name": "Alice",
  "role": "admin"
}

{
  'name': 'Alice',
  'role': 'admin'
}

{
  "name": "Alice",
  "role": "admin"
}

{
  name: "Alice",
  role: "admin"
}

{
  "name": "Alice",
  "role": "admin"
}

{
  "name": "Alice",
  // user role
  "role": "admin"
}

{
  "name": "Alice",
  "role": "admin"
}

{
  "users": [
    {"id": 1, "name": "Alice"},
    {"id": 2, "name": "Bob"
  // response cut off here

Requires manual completion or re-prompting the model

```json
{
  "name": "Alice"
}
```

{
  "name": "Alice"
}

Fix Broken LLM JSON in Python

For automated pipelines that call LLM APIs and parse the response, you need a robust repair step before json.loads(). These examples range from a simple fence-stripper to a production-grade wrapper with schema validation.

Fix Broken LLM JSON in JavaScript / TypeScript

Whether you're calling the OpenAI API from a Next.js route handler, a browser app, or a Node.js script, you need the same defensive parsing layer. Here are the patterns that cover the most common cases.

function parseLlmJson(text) {
  // Strip markdown fences
  text = text.trim();
  if (text.startsWith("```")) {
    text = text
      .replace(/^```(json)?\n?/, "")
      .replace(/\n?```$/, "")
      .trim();
  }
  return JSON.parse(text);
}

// Example
const response = `
\`\`\`json
{
  "name": "Alice",
  "role": "admin"
}
\`\`\`
`;

const data = parseLlmJson(response);
console.log(data.name); // "Alice"

function repairLlmJson(text) {
  text = text.trim();

  // Strip markdown fences
  if (text.startsWith("```")) {
    text = text.replace(/^```(json)?\n?/, "").replace(/\n?```$/, "").trim();
  }

  // Remove inline comments (// ...)
  text = text.replace(/\/\/[^\n]*/g, "");

  // Remove block comments (/* ... */)
  text = text.replace(/\/\*[\s\S]*?\*\//g, "");

  // Remove trailing commas before } or ]
  text = text.replace(/,\s*([}\]])/g, "$1");

  // Replace single-quoted keys/values with double-quoted
  // (simplified — handles straightforward cases)
  text = text.replace(/'/g, '"');

  return JSON.parse(text);
}

const broken = `{
  'name': 'Alice',
  role: 'admin',   // unquoted key + trailing comment
  'scores': [95, 87,],
}`;

const data = repairLlmJson(broken);
console.log(data); // { name: 'Alice', role: 'admin', scores: [95, 87] }

How to Prevent Broken JSON Output from LLMs

Repair is the safety net. Prevention is the better strategy for production systems. These three approaches reduce invalid JSON output significantly.

const response = await openai.chat.completions.create({
  model: "gpt-4o",
  response_format: { type: "json_object" }, // Enforces valid JSON
  messages: [
    {
      role: "system",
      content: "You are a data extractor. Always respond with valid JSON.",
    },
    {
      role: "user",
      content: "Extract name and role from: Alice is an admin.",
    },
  ],
});

const data = JSON.parse(response.choices[0].message.content);

const systemPrompt = `
You are a data extraction assistant.
Always respond with valid JSON matching this exact structure — 
no trailing commas, no comments, double-quoted keys and strings:

{
  "name": "string",
  "role": "string",
  "scores": [number]
}
`;

// Using Zod (TypeScript)
import { z } from "zod";

const UserSchema = z.object({
  name: z.string(),
  role: z.enum(["admin", "user", "viewer"]),
  scores: z.array(z.number()).optional(),
});

function parseLlmUser(text) {
  const raw = JSON.parse(stripFences(text));
  return UserSchema.parse(raw); // Throws if structure is wrong
}

Privacy — Your JSON Never Leaves Your Browser

The ToolLance JSON repair tool runs entirely in your browser using JavaScript. No data is sent to any server. This matters for LLM workflows specifically — your JSON output may contain your system prompt structure, sensitive business logic, user data extracted from documents, or internal API responses. You can verify this by opening your browser's Network tab and confirming no outbound requests fire when you paste and repair.

Related Tools

After repairing, use the JSON Formatter's Tree View to explore nested LLM-generated structures visually — useful for understanding deeply nested AI outputs before parsing them in code. If you're comparing two versions of an LLM's JSON output (a before/after prompt change), the Diff tab highlights exactly what changed between the two responses. Need to get the repaired JSON into a spreadsheet? JSON to CSV Converter converts it in one click — also fully browser-based.