The Six JSON Syntax Rules Every Developer Must Know

JSON has exactly six rules. Every valid JSON document follows all six. Every invalid JSON document violates at least one. Memorizing these rules is the fastest path to writing and debugging JSON confidently.

Rule 1 — Keys Must Be Strings in Double Quotes

Every key in a JSON object must be a string wrapped in double quotes. Single quotes are not valid JSON. Unquoted keys are not valid JSON. This is the most common mistake made by developers coming from JavaScript, where unquoted object keys are perfectly acceptable.

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

// INVALID — single-quoted key
{ 'name': "Alice" }

// VALID
{ "name": "Alice" }

Rule 2 — No Trailing Commas

JSON does not allow trailing commas — a comma after the last item in an object or array. JavaScript and most modern programming languages do allow trailing commas, which makes this rule feel unnecessary, but it is strictly enforced in all JSON parsers.

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

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

Rule 3 — No Comments

JSON does not support comments of any kind — no // single-line comments and no /* */ block comments. This surprises many developers who want to annotate configuration files. If you need comments in a JSON-like config file, consider JSONC (JSON with Comments), which is supported by VS Code, or switch to YAML which natively supports comments.

Rule 4 — Values Must Be One of Six Types

JSON values must be one of exactly six types: string (in double quotes), number, boolean (true or false — lowercase only), null (lowercase), object, or array. JavaScript undefined, functions, and Date objects are not valid JSON values.

// INVALID
{ "active": True }     // Python boolean — not JSON
{ "score": None }      // Python None — not JSON
{ "value": undefined } // JavaScript undefined — not JSON

// VALID
{ "active": true }
{ "score": null }
{ "value": null }

Rule 5 — Numbers Cannot Have Leading Zeros

JSON numbers cannot have leading zeros (except for decimals like 0.5), cannot use hexadecimal notation, and cannot be Infinity or NaN.

// INVALID
{ "value": 0123 }    // leading zero
{ "value": 0xFF }    // hexadecimal
{ "value": Infinity } // Infinity

// VALID
{ "value": 123 }
{ "value": 3.14 }
{ "value": 1.5e10 }

Rule 6 — Special Characters in Strings Must Be Escaped

Certain characters must be escaped with a backslash inside JSON strings — double quotes, backslashes, and control characters like newlines and tabs.

// INVALID — unescaped double quote inside string
{ "message": "She said "hello" to him" }

// VALID
{ "message": "She said \"hello\" to him" }

// Common escape sequences:
// \"  — double quote
// \\  — backslash
// \n  — newline
// \t  — tab

The Eight Most Common JSON Errors and How to Fix Them

In practice, JSON syntax errors fall into a small set of recurring patterns. Here are the eight you will encounter most often, with examples and exact fixes.

Error 1 — Missing Comma Between Items

// INVALID — missing comma after "name" line
{
  "name": "Alice"
  "age": 30
}

// FIXED — add comma after every item except the last
{
  "name": "Alice",
  "age": 30
}

Error 2 — Trailing Comma

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

// FIXED — remove the last comma
{
  "name": "Alice",
  "age": 30
}

Error 3 — Mismatched Brackets

// INVALID — opened with { but closed with ]
{ "items": [1, 2, 3 }

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

Error 4 — Using JavaScript Values Not Valid in JSON

// INVALID
{
  "active": True,      // must be lowercase: true
  "data": undefined,   // undefined does not exist in JSON
  "date": new Date()   // Date objects are not JSON
}

// FIXED
{
  "active": true,
  "data": null,
  "date": "2026-06-15T10:30:00Z"
}

Error 5 — Single Quotes Instead of Double Quotes

// INVALID
{ 'name': 'Alice' }

// FIXED
{ "name": "Alice" }

Error 6 — Comments in JSON

// INVALID — JSON does not support comments
{
  "name": "Alice",  // this is the user's name
  "age": 30         /* age in years */
}

// FIXED — remove all comments
{
  "name": "Alice",
  "age": 30
}

Error 7 — Unescaped Special Characters in Strings

// INVALID
{ "path": "C:\Users\Alice" }  // backslash not escaped
{ "quote": "He said "hello"" } // quote not escaped

// FIXED
{ "path": "C:\\Users\\Alice" }
{ "quote": "He said \"hello\"" }

Error 8 — Empty or Whitespace-Only Input

An empty string is not valid JSON. Valid JSON must be either an object {}, an array [], a string "", a number, a boolean, or null. An empty input will always fail to parse.

How to Debug JSON Errors Fast

When you receive a JSON parse error, follow this systematic process to find and fix the problem quickly without reading every character manually.

Step 1 — Beautify First, Then Read

Never try to read or debug raw minified JSON. Paste it into a formatter tool first. Beautified JSON with proper indentation makes the structure immediately visible — mismatched brackets, missing commas, and structural errors become obvious within seconds.

Step 2 — Read the Error Message Carefully

JSON parse error messages typically include a line number and character position — "Unexpected token at position 47" or "Expected property name at line 3 column 12." Go to that exact location. The error is almost always at or just before the reported position.

Step 3 — Check the Four Most Common Problems First

• Are there trailing commas anywhere in the document?
• Are all keys wrapped in double quotes?
• Do all opening brackets and braces have matching closing ones?
• Are all string values using double quotes, not single quotes?

Step 4 — Validate Programmatically in JavaScript

try {
  const data = JSON.parse(jsonString);
  console.log('Valid JSON:', data);
} catch (error) {
  console.error('Parse error:', error.message);
  console.log('Attempted to parse:', jsonString);
}

Step 5 — Use jq on the Command Line

# Validate and pretty-print a JSON file
cat data.json | jq .

# Minify JSON
cat data.json | jq -c .

# Extract a specific field
cat data.json | jq '.users[0].name'

Pretty-Print vs Minified JSON — When to Use Each

When to Use Pretty-Printed JSON

• Writing configuration files that humans will read and edit
• Debugging API responses or inspecting data structures
• Storing data in version-controlled files where readable diffs matter
• Generating output intended for human review or documentation

When to Use Minified JSON

• Transmitting data over a network where bandwidth matters
• Storing JSON in databases or caches where storage size is a concern
• Including JSON in HTTP responses from production APIs
• Generating JSON for machine consumption where human readability is irrelevant

How to Toggle Between Formats in Code

// JavaScript
JSON.stringify(data, null, 2);  // pretty-print with 2-space indent
JSON.stringify(data);           // minify

// Python
import json
json.dumps(data, indent=2)                        # pretty-print
json.dumps(data, separators=(',', ':'))            # minify

Best practice: develop and debug with pretty-printed JSON. Deploy and transmit minified JSON. Most JSON libraries toggle between the two with a single parameter change.