Forem: AI JSONMedic

LangChain JsonOutputParser: Fix Malformed JSON from LLMs

AI JSONMedic — Sat, 23 May 2026 22:10:33 +0000

LangChain's JsonOutputParser is one of the most useful tools in the LangChain ecosystem — until your LLM returns malformed JSON and everything crashes.

This article was originally published at AI JSONMedic.

The Problem

LLMs are probabilistic. Even with a structured prompt, models sometimes return:

Single-quoted JSON: {'key': 'value'} instead of {"key": "value"}
Trailing commas: {"key": "value",}
Markdown code fences wrapping the JSON: json\n{...}\n
Truncated responses that cut off mid-object

JsonOutputParser raises OutputParserException on all of these.

Basic Setup

from langchain_core.output_parsers import JsonOutputParser
from langchain_core.prompts import PromptTemplate
from langchain_openai import ChatOpenAI
from pydantic import BaseModel, Field

class MovieReview(BaseModel):
    title: "str = Field(description=\"Movie title\")"
    rating: float = Field(description="Rating from 0 to 10")
    summary: str = Field(description="One sentence summary")

parser = JsonOutputParser(pydantic_object=MovieReview)

prompt = PromptTemplate(
    template="Review this movie: {movie}\n{format_instructions}",
    input_variables=["movie"],
    partial_variables={"format_instructions": parser.get_format_instructions()},
)

model = ChatOpenAI(temperature=0)
chain = prompt | model | parser

result = chain.invoke({"movie": "Inception"})
print(result)

Making It Robust — Auto-Repair Strategy

The most reliable approach is to add a repair step before the parser:

from json_repair import repair_json
from langchain_core.output_parsers import StrOutputParser
import json

def robust_json_parse(text: str) -> dict:
    """Parse JSON from LLM output, with auto-repair for common errors."""
    # Strip markdown code fences if present
    if text.strip().startswith("```

"):
        lines = text.strip().split("\n")
        text = "\n".join(lines[1:-1] if lines[-1] == "

```" else lines[1:])

    # Try direct parse first
    try:
        return json.loads(text)
    except json.JSONDecodeError:
        pass

    # Auto-repair (handles single quotes, trailing commas, etc.)
    repaired = repair_json(text)
    return json.loads(repaired)

# Use with a raw string output parser + manual repair
chain = prompt | model | StrOutputParser() | robust_json_parse

Using OutputFixingParser

LangChain also has a built-in OutputFixingParser that uses a second LLM call to fix bad output:

from langchain.output_parsers import OutputFixingParser

fix_parser = OutputFixingParser.from_llm(
    parser=JsonOutputParser(pydantic_object=MovieReview),
    llm=ChatOpenAI(temperature=0)
)

chain = prompt | model | fix_parser

This works but uses an extra API call per failure. Use it when accuracy is critical and cost is acceptable.

Using RetryOutputParser

For structured retry logic:

from langchain.output_parsers import RetryOutputParser

retry_parser = RetryOutputParser.from_llm(
    parser=JsonOutputParser(pydantic_object=MovieReview),
    llm=model,
    max_retries=3
)

Summary

Strategy	When to use
`json-repair` library	Fast, no extra API calls, handles most cases
`OutputFixingParser`	Critical accuracy, cost not a concern
`RetryOutputParser`	When the original prompt just needs re-running
Manual strip + parse	Code fences only, no other errors

For quick one-off JSON repair from LLM output, AI JSONMedic handles single quotes, trailing commas, Python booleans, and truncated JSON in the browser.

How to Fix JSON Single Quotes: The Complete Guide

AI JSONMedic — Sat, 23 May 2026 22:10:29 +0000

Single-quoted JSON breaks every parser — Python's json.loads, JavaScript's JSON.parse, and every API client on the planet. The fix is straightforward once you understand the rule.

This article was originally published at AI JSONMedic.

Why JSON Rejects Single Quotes

JSON is defined by RFC 8259, which requires all strings — both keys and values — to be wrapped in double quotes only. Single quotes are simply not part of the JSON specification.

This means the following is invalid JSON:

// INVALID
{'name': 'Alice', 'age': 30}

The valid form:

// VALID
{"name": "Alice", "age": 30}

There is no parser setting or "loose mode" that accepts single-quoted JSON.

What Causes the Single Quote Error

Python dictionary literals. When you call str() on a Python dict, Python prints it with single quotes. This is NOT valid JSON:

data = {"name": "Alice"}
print(str(data))
# Output: {'name': 'Alice'}  ← NOT valid JSON

LLM and AI output. Language models sometimes generate Python-dict-style output instead of strict JSON.

Manual editing. Developers who write JSON by hand sometimes use single quotes from JavaScript or Python habit.

Fix in Python

Option 1 — Use `json.dumps()` instead of `str()`

import json

data = {"name": "Alice", "age": 30}
good = json.dumps(data)
print(good)
# Output: {"name": "Alice", "age": 30}

Option 2 — `ast.literal_eval` for Python dict strings

If the string is specifically Python dict syntax, ast.literal_eval is the most reliable repair:

import ast, json

broken = "{'name': \"it's Alice\", 'city': 'London'}"
data = ast.literal_eval(broken)
valid_json = json.dumps(data)

Option 3 — `json-repair` library for production

from json_repair import repair_json

broken = "{'name': 'Alice', 'scores': [95, 87, 91]}"
fixed = repair_json(broken)
# Output: {"name": "Alice", "scores": [95, 87, 91]}

Fix in JavaScript

// Never build JSON with single quotes — use JSON.stringify()
const data = { name: "Alice", age: 30 };
const validJson = JSON.stringify(data);

// For basic strings without apostrophes in values:
const broken = "{'name': 'Alice', 'age': 30}";
const fixed = broken.replace(/'/g, '"');
const obj = JSON.parse(fixed);

Online Fix

For a quick browser-based repair without writing any code, AI JSONMedic automatically detects and fixes single quotes, trailing commas, Python booleans (True/False/None), and other common JSON errors.

Summary

Scenario	Fix
Python dict → JSON	Use `json.dumps()`
Python dict string	Use `ast.literal_eval()` then `json.dumps()`
LLM / production pipeline	Use `json-repair` library
JavaScript	Use `JSON.stringify()`
Quick one-off repair	AI JSONMedic

5 Ways ChatGPT Breaks Your JSON (And How to Fix Each One)

AI JSONMedic — Wed, 20 May 2026 12:26:13 +0000

If you've ever asked ChatGPT to return JSON, you've probably seen this error:

SyntaxError: Unexpected token

ChatGPT and GPT-4o are great at generating almost valid JSON — close enough for a human to read, but broken enough to crash JSON.parse(). After repairing thousands of broken JSON documents, here are the 5 most common ways ChatGPT breaks your JSON, with fixes for each.

1. Markdown Code Fence Wrapping

The problem: You ask for JSON. ChatGPT wraps it in markdown:

Here is the JSON you requested:

\`\`\`json
{"name": "Alice", "role": "engineer"}
\`\`\`

The fix: Strip everything before the first { and after the last }:

const raw = chatgptResponse;
const start = raw.indexOf('{');
const end = raw.lastIndexOf('}');
const clean = raw.slice(start, end + 1);
JSON.parse(clean);

2. Trailing Commas

The problem: ChatGPT adds trailing commas after the last array/object item:

{"items": ["apple", "banana", "cherry",]}

This is valid JavaScript but illegal in strict JSON.

The fix:

cleaned = json.replace(/,(\s*[}\]])/g, '$1');

3. Python Booleans

The problem: ChatGPT sometimes outputs Python-style booleans:

{"active": True, "deleted": False, "metadata": None}

The fix:

cleaned = cleaned
  .replace(/\bTrue\b/g, 'true')
  .replace(/\bFalse\b/g, 'false')
  .replace(/\bNone\b/g, 'null');

4. JavaScript Comments

The problem: ChatGPT adds helpful comments that break JSON:

{
  // User profile
  "id": 42,
  "name": "Alice" /* primary user */
}

The fix: Strip both line and block comments (careful not to touch strings):

// Simple version (doesn't handle comments inside strings)
cleaned = cleaned
  .replace(/\/\/.*$/gm, '')
  .replace(/\/\*[\s\S]*?\*\//g, '');

5. Truncated Responses

The problem: When ChatGPT hits its token limit, JSON gets cut off mid-stream:

{"users": [{"id": 1, "name": "Alice"}, {"id": 2, "na

The fix: This one is hard to fix with regex. You need to close unclosed strings, arrays, and objects. A robust approach:

// Close unclosed structures
let depth = { brace: 0, bracket: 0, inString: false };
// ... (requires a state machine parser)

The Easy Way: Use a JSON Fixer

Writing all these cleanup rules yourself is tedious and error-prone. I built AI JSONMedic — a free online tool that handles all 5 of these cases (and more) in one click.

Just paste the raw ChatGPT output — markdown wrappers, Python booleans, comments, and all — and get clean, valid JSON back instantly. It runs entirely in your browser, so your data never leaves your device.

Try it free: aijsonmedic.com

TL;DR

Error	Cause	Quick Fix
Markdown wrapping	ChatGPT adds code fences	Strip before first `{`
Trailing commas	JS habit, illegal in JSON	Regex remove
Python booleans	True/False/None	Replace with true/false/null
Comments	Helpful but illegal	Strip // and /* */
Truncation	Token limit hit	Close unclosed structures

Have you run into other ChatGPT JSON bugs? Drop them in the comments!

Forem: AI JSONMedic

LangChain JsonOutputParser: Fix Malformed JSON from LLMs

The Problem

Basic Setup

Making It Robust — Auto-Repair Strategy

Using OutputFixingParser

Using RetryOutputParser

Summary

How to Fix JSON Single Quotes: The Complete Guide

Why JSON Rejects Single Quotes

What Causes the Single Quote Error

Fix in Python

Option 1 — Use json.dumps() instead of str()

Option 2 — ast.literal_eval for Python dict strings

Option 3 — json-repair library for production

Fix in JavaScript

Online Fix

Summary

5 Ways ChatGPT Breaks Your JSON (And How to Fix Each One)

1. Markdown Code Fence Wrapping

2. Trailing Commas

3. Python Booleans

4. JavaScript Comments

5. Truncated Responses

The Easy Way: Use a JSON Fixer

TL;DR

Option 1 — Use `json.dumps()` instead of `str()`

Option 2 — `ast.literal_eval` for Python dict strings

Option 3 — `json-repair` library for production