Common JSON Errors and How to Fix Them

Why JSON Errors Happen

JSON (JavaScript Object Notation) is the universal data format for web APIs, configuration files, and data exchange. Its syntax is strict by design: the RFC 8259 specification deliberately excludes features like comments, trailing commas, and single quotes that other formats allow. This strictness is what makes JSON universally parseable, but it also means a single character out of place will break everything.

Most JSON errors fall into one of three categories: syntax borrowed from JavaScript that JSON does not support (trailing commas, single quotes, comments), data type confusion (using undefined, NaN, or leading zeros), and encoding issues (BOM characters, unescaped control characters). Each section below covers specific errors with bad and good examples.

The fastest way to find and fix JSON errors is to paste your data into our JSON Formatter & Validator, which highlights the exact error position with line numbers and provides auto-fix suggestions.

Trailing Commas

Trailing commas are the number one cause of JSON parse failures. JavaScript, TypeScript, Python, and most programming languages allow trailing commas in arrays and objects, so developers naturally include them when writing JSON by hand. But the JSON specification forbids them.

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

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

["red", "green", "blue",]

["red", "green", "blue"]

Quote and Key Errors

JSON requires double quotes for all strings and keys. No exceptions. These errors typically come from writing JSON as if it were a JavaScript object literal.

{'name': 'Alice'}

{"name": "Alice"}

{name: "Alice", age: 30}

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

{
  // user info
  "name": "Alice",
  /* age */ "age": 30
}

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

Need to convert your JSON data to another format? Try our JSON to YAML Converter for a format that supports comments natively.

Data Type Mistakes

JSON supports six data types: strings, numbers, booleans (true/false), null, arrays, and objects. Anything else causes a parse error.

{"value": undefined, "ratio": NaN, "max": Infinity}

{"value": null, "ratio": 0, "max": 9999999}

{"code": 007, "zip": 01onal}

{"code": 7, "zip": "01onal"}

{"name": "Alice", "name": "Bob"}

{"name": "Bob"}

Working with tabular JSON data? Our JSON to CSV Converter can flatten nested objects and export clean spreadsheet data.

Encoding and Character Issues

These errors are the hardest to spot because the problematic characters are often invisible or look correct in a text editor.

{"path": "C:\Users\file.txt", "msg": "line1
line2"}

{"path": "C:\\Users\\file.txt", "msg": "line1\nline2"}

\uFEFF{"name": "Alice"}

{"name": "Alice"}

Mixed encoding between UTF-8 and other character sets (like Latin-1 or Windows-1252) can also cause parsing failures. Smart quotes (“ ”) from word processors are not the same as straight double quotes (") and will break JSON. Always ensure your JSON files are saved as UTF-8 without BOM.

Debugging JSON in Code

When working with JSON programmatically, always use safe parsing patterns that handle errors gracefully instead of letting your application crash.

Safe JSON.parse() in JavaScript

function safeJsonParse(jsonString) {
  try {
    return { data: JSON.parse(jsonString), error: null };
  } catch (err) {
    return { data: null, error: err.message };
  }
}

// Usage
const { data, error } = safeJsonParse(apiResponse);
if (error) {
  console.error("JSON parse failed:", error);
  // error message includes position:
  // "Unexpected token , in JSON at position 42"
} else {
  console.log("Parsed successfully:", data);
}

Producing Valid JSON from JavaScript

Never build JSON by concatenating strings. Always use JSON.stringify():

// BAD: Manual string building
const bad = '{"name": "' + name + '", "age": ' + age + '}';

// GOOD: Let JSON.stringify handle escaping
const good = JSON.stringify({ name, age });

// Pretty-print with 2-space indentation
const pretty = JSON.stringify({ name, age }, null, 2);

// JSON.stringify handles special cases:
JSON.stringify({ a: undefined });  // '{}' (undefined removed)
JSON.stringify({ a: NaN });        // '{"a":null}' (NaN → null)
JSON.stringify({ a: Infinity });   // '{"a":null}' (Infinity → null)

Stripping Comments and Fixing Common Issues

If you receive JSON-like data with comments or trailing commas (common with config files), you can clean it before parsing:

function cleanJsonString(str) {
  return str
    // Remove BOM
    .replace(/^\uFEFF/, '')
    // Remove single-line comments
    .replace(/\/\/.*$/gm, '')
    // Remove multi-line comments
    .replace(/\/\*[\s\S]*?\*\//g, '')
    // Remove trailing commas before } or ]
    .replace(/,\s*([}\]])/g, '$1');
}

// Usage
const cleaned = cleanJsonString(dirtyJson);
const parsed = JSON.parse(cleaned);

For a more robust solution, use a dedicated JSONC parser like the jsonc-parser npm package, which handles all edge cases. Or simply paste your problematic JSON into our JSON Formatter for instant error detection and auto-fix.

Frequently Asked Questions

Related Tools