Common JSON Errors: Examples, Causes and Fixes

The parser found a comma after the final object property, where it expected another quoted property name.

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

Why it happens: RFC 8259 does not allow a comma after the last property or array element. JavaScript literals may tolerate it, but strict JSON does not.

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

JSON object keys must be strings wrapped in double quotes; bare identifiers such as name are invalid.

{name: "Ana", age: 30}

Why it happens: Unquoted identifiers are valid in JavaScript object literals, but JSON requires every object member name to be a double-quoted string.

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

Strict JSON accepts double-quoted strings only, so the first single quote stops parsing immediately.

{'name': 'Ana', 'age': 30}

Why it happens: Single quotes are valid in JavaScript and Python, but they are not part of the JSON string grammar.

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

The parser completed one property value and found the next key without the required comma separator.

{"name": "Ana" "age": 30}

Why it happens: Every object property and array element must be comma-separated. Parsers do not infer a boundary from whitespace or a line break.

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

Strict JSON has no comment syntax, so a parser rejects the first slash in // or /* */.

{
  // the user's display name
  "name": "Ana"
}

Why it happens: JSONC files such as VS Code settings may allow comments, but JSON.parse and strict RFC 8259 parsers do not.

{
  "name": "Ana"
}

“Unexpected end of JSON input” means parsing reached the end before receiving one complete value. Here, the outer object never closes.

{"items": [1, 2, 3]

Why it happens: Every opening { or [ requires a matching close before the JSON document ends.

{"items": [1, 2, 3]}

The JSON value is already complete, so the final unmatched brace is treated as invalid trailing content.

{"items": [1, 2, 3]}}

Why it happens: A JSON document contains exactly one top-level value followed only by optional whitespace.

{"items": [1, 2, 3]}

Arrays contain values, not key-value members, so a colon cannot follow an array string unless that string sits inside an object.

{"user": ["name": "Ana"]}

Why it happens: A "key": value member is legal only inside an object. Arrays hold an ordered sequence of values.

{"user": {"name": "Ana"}}

A backslash starts a JSON escape, but the following U is not one of the permitted escape characters.

{"path": "C:\Users\Ana"}

Why it happens: JSON permits only a small set of escapes, including newline, tab, quote, backslash, and Unicode escapes. Windows paths therefore need doubled backslashes.

{"path": "C:\\Users\\Ana"}

A literal line break is a control character and cannot appear unescaped inside a JSON string.

{"message": "Line one
Line two"}

Why it happens: Control characters inside JSON strings must use escape notation such as \n, \r, or \t.

{"message": "Line one\nLine two"}

The leading zero completes one number, leaving another digit where the parser expects a comma or closing brace.

{"price": 01.50}

Why it happens: JSON numbers disallow leading zeros, a leading +, trailing decimal points, NaN, and Infinity.

{"price": 1.50}

The word undefined belongs to JavaScript, not JSON, so parsing fails on its first letter.

{"active": undefined}

Why it happens: JSON supports null but has no undefined literal. JSON.stringify normally omits undefined object properties.

{"active": null}

JSON literals are case-sensitive: true, false, and null are the only valid spellings.

{"active": True}

Why it happens: True, False, and None are Python literals. Serialize Python values with json.dumps instead of copying a dictionary representation.

{"active": true}

The parser received only part of a JSON value, often because an API response or stream ended early.

{"user": {"name": "An

Why it happens: The syntax symptom resembles a missing bracket, but intermittent occurrences usually point to transport or server behavior rather than handwritten JSON.

{"user": {"name": "Ana"}}

The response begins with HTML, usually from a 404 page, authentication redirect, or proxy error, rather than the expected JSON body.

<html><body>Not found</body></html>

Why it happens: JSON cannot begin with <. Inspect response.ok, status, headers, and the raw response body before calling response.json().

{"error": "Not found"}

JSON.parse requires one complete JSON value, but the response contains no characters at all.

(empty input)

Why it happens: An HTTP 204 response should not be parsed as JSON. For other responses, read the body and decide explicitly how your application treats an empty value.

const text = await response.text();
const data = text ? JSON.parse(text) : null;

JSON syntax does not require object member names to be unique, but duplicate names produce implementation-dependent behavior.

{"id": 1, "name": "Ana", "id": 2}

Why it happens: For interoperable JSON, object member names should be unique. Duplicate names can be accepted, rejected, or reported differently by consuming software.

{"id": 2, "name": "Ana"}

A JSON string is syntactically valid, but application code fails when it assumes the parsed value is an array.

"Internal Server Error"

Why it happens: Syntax validation only proves that the text is JSON. It does not prove that the result matches the object, array, or field structure your application expects.

const parsed = JSON.parse(response);

if (!Array.isArray(parsed)) {
  throw new TypeError('Expected a JSON array');
}