25 JSON Mistakes Every Developer Makes

A developer's guide to debugging syntax flaws, escaping characters, and parsing data without the headaches.

JSON (JavaScript Object Notation) is the backbone of modern web communication. It’s human-readable, lightweight, and universally supported. Yet, because its specification is incredibly strict, even seasoned developers regularly trip over its syntax.

Here are 25 of the most common JSON mistakes, categorized by syntax, data types, environments, and architecture—along with exactly how to avoid them.

The Syntax Traps

1. Using Single Quotes

JavaScript, Python, and PHP let you use single quotes (') for strings. JSON absolutely forbids it. All keys and string values must use double quotes (").

• 
  Wrong: {'name': 'Alex'}
  


• 
  Right: {"name": "Alex"}
  

2. Trailing Commas

Leaving a comma after the last item in an object or array is standard practice in modern programming languages to keep git diffs clean. In JSON, it causes a fatal parsing error.

• 
  Wrong: {"id": 1, "status": "active",}
  


• 
  Right: {"id": 1, "status": "active"}
  

3. Missing Commas Between Elements

On the flip side, when manually editing JSON or generating it via string concatenation, it’s easy to forget commas separating key-value pairs or array items.

• 
  Wrong: {"a": 1 "b": 2}
  


• 
  Right: {"a": 1, "b": 2}
  

4. Unquoted Keys

In standard JavaScript objects, keys don't need quotes unless they contain special characters. In JSON, every single key must be wrapped in double quotes.

• 
  Wrong: {username: "dev_123"}
  


• 
  Right: {"username": "dev_123"}
  

5. Mismatched Brackets or Braces

In deeply nested structures, forgetting to close a curly brace } or a square bracket ] will immediately break the parser.

6. Misplacing Object/Array Notation

Using curly braces {} where square brackets [] belong (or vice versa)—such as wrapping a flat list of items in an object without assigning keys.

• 
  Wrong: {"apple", "banana"}
  


• 
  Right: ["apple", "banana"]
  

Data Type Misconceptions

7. Serializing undefined

JSON has no concept of undefined. If you pass a JavaScript object containing an undefined value to JSON.stringify(), that key will be completely stripped out.

• 
  Result: JSON.stringify({ data: undefined }) becomes {}. Use null instead if you need to preserve the key.

8. Relying on NaN and Infinity

Numeric values like NaN (Not a Number), Infinity, and -Infinity are not supported by the JSON specification.

• 
  Result: JSON.stringify({ value: NaN }) converts the value to null ({"value": null}).

9. Forgetting JSON Doesn’t Have a Date Type

JSON has no native Date data type. When you stringify a Date object, it turns into an ISO timestamp string. If you don't parse it back manually on the receiving end, it stays a string.

• 
  Example: {"created_at": "2026-06-26T00:00:00.000Z"} is just text until you pass it to new Date().

10. Forgetting Hexadecimal, Binary, or Octal Numbers

JSON numbers must be base-10. You cannot use 0x, 0b, or leading zeros for octals.

• 
  Wrong: {"mask": 0xFF}
  


• 
  Right: {"mask": 255}
  

11. Storing Functions or Methods

JSON is strictly for static data. You cannot serialize functions, closures, or class methods. Attempting to do so will result in the property being skipped or throwing an error.

12. Treating Comments as Valid

JSON does not support comments (// or /* */). Adding them to explain your configuration files will cause parsers to reject the entire file. If you need comments, consider using JSONC or YAML instead.

String and Character Escaping

13. Unescaped Double Quotes

If your text data contains literal double quotes (e.g., dialogue or HTML attributes), they must be escaped using a backslash (\").

• 
  Wrong: {"quote": "He said "Hello" "}
  


• 
  Right: {"quote": "He said \"Hello\" "}
  

14. Unescaped Control Characters (Newlines)

You cannot hit "Enter" inside a JSON string value to create a newline. Multi-line text must use explicit control characters like \n or \r\n.

• 
  Wrong:
  

{"text": "Line one

Line two"}

• 
  Right: {"text": "Line one\nLine two"}
  

15. The Backslash Pitfall

Because the backslash (\) is the escape character in JSON, if your data includes literal backslashes (like Windows file paths or regex patterns), you must escape the backslash itself (\\).

• 
  Wrong: {"path": "C:\Users\Admin"}
  


• 
  Right: {"path": "C:\\Users\\Admin"}
  

Code and Environment Errors

16. JSON.parse() on an Object (or JSON.stringify() on a String)

Passing something that is already a JavaScript object to JSON.parse() will trigger an [object Object] error. Similarly, stringifying an already stringified JSON creates a mess of escaped slashes ("{\"a\":1}").

17. Forgetting that JSON Keys are Case-Sensitive

{"userId": 1} and {"userid": 1} are entirely different keys. Typos in casing are a leading cause of silent frontend bugs where values show up as undefined.

18. Assuming Object Key Order is Guaranteed

While modern environments often preserve insertion order for object keys, the JSON specification does not guarantee key order. Never write logic that relies on keys appearing in a specific sequence.

19. Vulnerable Evaluation (eval())

Historically, developers used eval("(" + jsonString + ")") to parse JSON. This is a catastrophic security vulnerability that allows for Remote Code Execution (RCE). Always use JSON.parse().

Advanced and Architectural Mistakes

20. Truncating Large Integers (The BigInt Issue)

JavaScript numbers are double-precision floats, which lose precision above $2^{53} - 1$ (Number.MAX_SAFE_INTEGER). If your backend passes a massive 64-bit ID as a pure number, the frontend will corrupt it during parsing.

• 
  The Fix: Pass large IDs as strings: {"id": "9223372036854775807"}.

21. Silent Failures due to Missing try...catch

JSON.parse() is a synchronous, blocking operation that throws a hard error if the input string is invalid. Failing to wrap it in a try...catch block means an unexpected network payload can instantly crash your entire app.

22. Circular References

If Object A references Object B, and Object B references Object A, calling JSON.stringify(A) will throw a TypeError: Converting circular structure to JSON. You must break the cycle or use custom replacer functions.

23. Confusing JSON with JavaScript Object Literals

Just because they look similar doesn't mean they are the same. JS objects allow unquoted keys, functions, trailing commas, and single quotes; JSON allows none of these.

24. Misinterpreting Empty Payloads

An empty string "" is not valid JSON. Attempting to run JSON.parse("") will throw an unexpected end-of-input error. A blank payload must at least be an empty object {} or array [].

25. Manually Editing JSON without a Linter

Whether you are configuring a package.json or fixing an API payload on the fly, typing raw JSON without formatting tools is an open invitation for bugs.

How to Handle and Prevent JSON Errors Easily

You don't have to keep all 25 rules memorized to write flawless payloads. The best defense is utilizing dedicated tooling to catch mistakes before they hit production:

• 
  Use a Dedicated Validator: Before pasting or sending JSON config files, drop them into the JSON Formatter & Validator. It will instantly beautify your structure, validate the syntax against official specs, and cleanly point out the exact line causing a headache.


• 
  Automate in your IDE: Keep extensions like Prettier active in your editor to auto-format files on save and strip out illegal trailing commas.


• 
  Defensive Coding: Always safely handle dynamic parsing with a standard block:
  

try {

    const cleanData = JSON.parse(incomingPayload);

} catch (err) {

    console.warn("Invalid JSON structure received:", err.message);

    // fallback smoothly here

}