How to Parse and Clean Messy JSON Data in JavaScript and Python

JSON (JavaScript Object Notation) is the undisputed universal language of web data exchange. But in the real world—especially when copying raw output from server logs, scraping web pages, or pulling data from older APIs—JSON is rarely pristine. Instead of clean, valid structures, developers often encounter what we call "messy JSON." This includes configurations plagued by unquoted keys, data strings wrapped in single quotes, trailing commas left behind by automated arrays, or truncated data streams.

When you pass malformed strings into native parsers like JavaScript's JSON.parse() or Python's json.loads(), your code instantly throws a fatal runtime exception. This guide breaks down exactly how to handle, parse invalid JSON, clean JSON data strings, and format unreadable JSON using robust programmatic strategies in both JavaScript and Python.

Common Causes of Messy JSON Data

Before writing parsing logic, it helps to understand why your JSON strings are failing. True JSON enforces exceptionally strict syntax rules according to the RFC 8259 specification:

• Keys must be wrapped in double quotes ("key").
• Strings must use double quotes ("value"). Single quotes ('value') are completely invalid.
• Trailing commas at the end of objects or arrays are prohibited.

Malformed JSON Snippet	The Structural Issue	Native Error Triggered
{name: "Alice", age: 30}	Keys are missing mandatory double quotes.	Expected property name or '}'
{'user': 'admin'}	Strings or keys are wrapped in single quotes.	Unexpected token ' in JSON
{"data": [1, 2, 3,]}	Trailing comma before a closing bracket.	Unexpected token ]
Response code: 200 {"id": 1}	JSON string is wrapped in logging metadata.	Unexpected token R in JSON

1. Cleaning and Parsing Messy JSON in JavaScript

JavaScript engines provide JSON.parse(), which handles strictly valid JSON strings perfectly. To fix invalid strings before parsing them, we can use regular expressions to sanitize the text or implement third-party libraries for tolerant parsing.

Fixing Single Quotes and Unquoted Keys

You can normalize malformed configurations by targeting keys and strings with specific regex patterns.

function cleanAndParseJS(messyJsonString) {
  let sanitized = messyJsonString.trim();

  // 1. Convert single quotes surrounding keys/values to double quotes
  sanitized = sanitized.replace(/(?:\s*|:|,|\[|\{)'([^']*)'(?=\s*|:|、|,|\]|\})/g, '"$1"');

  // 2. Add double quotes to unquoted alphanumeric keys
  sanitized = sanitized.replace(/([{,]\s*)([a-zA-Z0-9_]+)\s*:/g, '$1"$2":');

  // 3. Remove trailing commas from arrays and objects
  sanitized = sanitized.replace(/,\s*([\]}])/g, '$1');

  try {
    return JSON.parse(sanitized);
  } catch (error) {
    console.error("Failed to parse automatically sanitized JSON:", error.message);
    return null;
  }
}
const messyLog = "{userId: 101, status: 'active', tags: ['admin', 'billing',],}";
console.log(cleanAndParseJS(messyLog)); 
// Output: { userId: 101, status: 'active', tags: [ 'admin', 'billing' ] }

The Safe Alternative: dirty-json

If your application frequently intercepts highly complex, deeply nested, or broken JSON structures, writing massive regular expressions can lead to unexpected edge cases. Instead, utilize specialized fault-tolerant toolkits like dirty-json in Node.js environments.

2. Cleaning and Parsing Messy JSON in Python

Python developers frequently encounter malformed string logs during data extraction and web scraping automation workflows. Python’s native json library is just as strict as JavaScript's engine, but Python offers unique language tools to intercept anomalies cleanly.

Leveraging ast.literal_eval for Pythonic Dictionaries

If your "JSON" looks like a native Python dictionary—meaning it uses single quotes or valid Python boolean syntax (True/False/None instead of true/false/null)—the standard json.loads() will crash. The ast.literal_eval function can safely interpret these structures without running arbitrary malicious code.

Regex Sanitization for True JSON Strings

When working with data containing pure JSON anomalies (like unquoted identifiers), regular expressions keep your parsing logic performant and dependable.

Strategic Best Practices for Production Data Pipelines

• Isolate JSON via Boundary Searching: If your JSON string arrives wrapped in raw system log text (e.g., [INFO] 2026-03-15: {"data": 1}), do not try to regex the text. Instead, locate the first occurrence of { or [ and the final occurrence of } or ] using boundary indices, and slice the string to extract the raw JSON container directly.
• Implement Fail-Safe Default Returns: Never assume your cleaning scripts are bulletproof. Always wrap your parsing logic inside clear try/catch or try/except blocks. If parsing fails entirely, return a safe default structural object (like an empty dictionary {}) to prevent your entire application architecture from crashing.
• Fix Upstream Generation Wherever Possible: While cleaning functions are vital downstream remediation strategies, they add processing overhead. Work with your systems infrastructure or third-party providers to fix the serialization engine at the data origin if the malformed patterns are entirely predictable.