Why does JSON not allow trailing commas?

Trailing commas (a comma after the last item in an object or array) are the single most common JSON error. JSON strictly follows the ECMA-404 standard which does not permit them. Most parsers throw a 'Unexpected token' error. The fix is to remove the comma from the last item. Some tools like JSON5 and JavaScript's object literals do allow trailing commas, but standard JSON does not.

Can JSON keys be unquoted?

No. All JSON keys must be enclosed in double quotes. Unquoted keys like {name: 'Alice'} are valid JavaScript but invalid JSON. This is a very common mistake when converting JavaScript object literals to JSON. All keys must be written as strings: {"name": "Alice"}.

Does JSON allow single quotes?

No. JSON requires double quotes for both keys and string values. Single quotes ('value') are invalid JSON. This is another very common mistake. Always use double quotes: {"name": "Alice"} not {'name': 'Alice'}.

Can I add comments to JSON?

No — standard JSON does not support comments. Neither // single-line nor /* multi-line */ comments are valid JSON. If you need documentation within the data, a common workaround is to add a descriptive field (e.g. _comment: 'This is a note'). If you frequently need comments in JSON-like config files, consider JSONC, JSON5, or YAML formats which support comments.

What data types does JSON support?

JSON supports exactly six data types: string (must use double quotes), number (integer or float, no quotes), boolean (true or false, lowercase, no quotes), null (lowercase, no quotes), object ({key: value pairs}), and array ([ordered list]). JSON does not support: undefined, NaN, Infinity, dates (use ISO 8601 strings instead), functions, or regular expressions.

Common JSON Formatting Mistakes & How to Fix Them

JSON (JavaScript Object Notation) is deliberately simple, but its strictness catches many developers by surprise — especially those used to the more relaxed syntax of JavaScript object literals. A single misplaced comma or missing quote will cause the entire parse to fail. Here are the most common JSON errors, exactly what causes them, and how to fix them.

1. Trailing Commas

The most common JSON error. A comma after the last item in an object or array is invalid JSON.

// ❌ INVALID — trailing comma after "Alice"
{
  "name": "Alice",
  "age": 30,
}

// ✅ VALID — no trailing comma
{
  "name": "Alice",
  "age": 30
}

// ❌ INVALID — trailing comma in array
["red", "green", "blue",]

// ✅ VALID
["red", "green", "blue"]

Why it happens: JavaScript and most modern languages allow trailing commas in arrays and objects. Developers copy-paste or write by habit. Fix: Remove the comma from the last item.

2. Single Quotes Instead of Double Quotes

// ❌ INVALID — single quotes
{'name': 'Alice', 'age': 30}

// ✅ VALID — double quotes everywhere
{"name": "Alice", "age": 30}

JSON requires double quotes for all strings — keys and values. Single quotes are valid in JavaScript but invalid JSON.

3. Unquoted Keys

// ❌ INVALID — unquoted key
{name: "Alice"}

// ✅ VALID — key in double quotes
{"name": "Alice"}

In JavaScript, object keys can be unquoted if they are valid identifiers. JSON requires all keys to be quoted strings.

4. Comments

// ❌ INVALID — JSON has no comment syntax
{
  // This is the user object
  "name": "Alice",
  /* age in years */
  "age": 30
}

// ✅ VALID — no comments, or use a _comment field workaround
{
  "_comment": "This is the user object",
  "name": "Alice",
  "age": 30
}

JSON has no comment syntax. If you need annotated config files, consider JSON5, JSONC (VS Code uses this), or YAML instead.

5. Wrong Values for Booleans and Null

// ❌ INVALID — capitalised or quoted
{"active": True}
{"active": "true"}
{"value": NULL}
{"value": None}   // Python None is not JSON null

// ✅ VALID — lowercase, unquoted
{"active": true}
{"active": false}
{"value": null}

6. Unsupported Data Types

// ❌ INVALID — undefined, NaN, Infinity, functions
{"value": undefined}
{"score": NaN}
{"limit": Infinity}
{"fn": function() {}}

// ✅ VALID alternatives
{"value": null}           // undefined → null
{"score": null}           // NaN → null or omit
{"limit": 9999999}        // Infinity → max integer or omit
// Functions cannot be represented in JSON

JSON supports exactly six types: string, number, boolean, null, object, array. Dates are represented as ISO 8601 strings: "2026-06-16T10:00:00Z".

7. Unescaped Special Characters in Strings

// ❌ INVALID — unescaped double quote inside a string
{"message": "He said "hello""}

// ✅ VALID — escaped with backslash
{"message": "He said \"hello\""}

// ✅ Other escape sequences in JSON strings:
// \\ — backslash
// \/ — forward slash (optional)
// \n — newline
// \r — carriage return
// \t — tab
// \uXXXX — Unicode character

8. Numbers with Leading Zeros

// ❌ INVALID — leading zero
{"postcode": 01234}

// ✅ VALID — use a string for postcodes/phone numbers
{"postcode": "01234"}

JSON does not allow numbers with leading zeros (except 0 itself and 0.5 etc). For identifiers like postcodes or phone numbers that start with 0, always use strings.

Quick Check: Use a JSON Validator

If you receive a JSON parse error and cannot spot the issue manually, paste your JSON into the JSON Formatter & Validator. It highlights the exact character position of errors, making them easy to find in large payloads.