Common JSON Errors and How to Fix Them (2026 Expert Guide)

Category: Development • Last Verified: September 2026

Quick Answer: Most JSON errors come from strict syntax rules: double quotes only, no trailing commas, no comments, and properly escaped characters. To fix JSON fast: validate, jump to the exact error position, inspect nearby characters for quotes/commas/escapes, correct invalid values (NaN/Infinity/undefined), and re‑validate. If it came from an API, confirm you received JSON—not HTML.

Definition

JSON (JavaScript Object Notation) is a text data format defined by RFC 8259 and ECMA‑404. It represents data as objects, arrays, strings, numbers, booleans, and null. JSON is strict: keys and strings require double quotes, comments and trailing commas are forbidden, and control characters must be escaped.

Key Takeaways

• JSON is strict: double quotes for keys and strings; no comments; no trailing commas; only true/false/null for literals.
• The most common JSON errors involve trailing commas, single quotes, unescaped characters/newlines, missing commas, invalid numbers, NaN/Infinity/undefined, duplicate keys, mismatched braces, BOM/encoding, extra data, or receiving HTML instead of JSON.
• Fast repair workflow: validate → jump to the error index → examine nearby characters → fix quotes/commas/escapes/values → re‑validate → confirm Content‑Type is application/json.
• Store big integers as strings or parse with BigInt to avoid precision loss.
• Prevent valid‑but‑wrong data with JSON Schema and type‑aware tests in CI.

Table of Contents

• What JSON Actually Requires (Quick Primer)
• 30‑Second Debug Workflow
• The 18 Most Common JSON Errors (with fixes)
  1. Trailing comma
  2. Unquoted or single-quoted keys
  3. Single quotes for strings
  4. Unescaped characters (quotes, backslashes, newlines)
  5. Missing commas
  6. Comments are not allowed
  7. NaN, Infinity, undefined
  8. Numbers with leading zeros
  9. Duplicate keys
  10. HTML instead of JSON
  11. BOM / encoding issues
  12. Large integers lose precision
  13. Mismatched brackets/braces
  14. Escaping backslashes (Windows paths, regex)
  15. Multiple JSON values / extra data
  16. Invalid number formats (plus signs, trailing dots, leading dots)
  17. Unescaped control characters and raw newlines
• Common Error Messages by Language/Runtime
• How to Debug API Responses Safely
• When JSON Is Valid but Your App Still Fails
• JSON vs JSON5 vs JSONC (and when to use each)
• Production Checklist
• Useful Tools
• About Our Testing Method
• FAQ
• References

---

What JSON Actually Requires (Quick Primer)

JSON is specified by RFC 8259 and ECMA‑404. It supports:

• Objects: { "key": value }
• Arrays: [ value, value ]
• Strings: double‑quoted, with required escaping
• Numbers: decimal and exponent notation (no leading zeros except 0; no + sign)
• Literals: true, false, null

Not allowed: comments, single quotes, trailing commas, undefined/NaN/Infinity, raw control characters (U+0000–U+001F), or JavaScript‑only syntax.

Helpful cross-check: The JSON you ship should parse cleanly with a standards‑compliant parser that assumes UTF‑8 and rejects comments and trailing commas.

---

30‑Second Debug Workflow

1. Validate the JSON with a formatter/validator. The ZenixTools JSON Validator highlights the exact index and line/column.
2. Jump to the reported position. Inspect five characters before and after.
3. Look first for the Big Four: quotes, commas, escaping, invalid values (NaN/Infinity/undefined).
4. If the payload came from an API, log the raw text and headers. Confirm the Content‑Type is application/json and the body isn’t HTML.
5. Re‑validate. If the next error appears at a new index, repeat until clean.
6. Add a JSON Schema test so the same mistake can’t re‑enter your pipeline.

Pro tip: Validate as you type using a formatter integrated in your editor. ZenixTools can auto‑format, show the failing character, and copy a fixed version.

---

The 18 Most Common JSON Errors (with fixes)

1) Trailing comma

• Typical messages:
  • JavaScript: Unexpected token ] or } in JSON at position ...
  • Python (json): Expecting property name enclosed in double quotes
• Cause: JSON forbids a comma after the last item in an object or array.
• Fix: Remove the final comma.

Invalid:

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

Valid:

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

2) Unquoted or single‑quoted keys

• Messages: Unexpected token a in JSON at position ...; Expecting property name enclosed in double quotes
• Cause: Keys must be double‑quoted strings.
• Fix: Wrap every key in double quotes.

Invalid:

{
  name: 'John'
}

Valid:

{
  "name": "John"
}

3) Single quotes for strings

• Message: Unexpected token ' in JSON at position ...
• Cause: Strings require double quotes.
• Fix: Replace single quotes with double quotes.

Invalid:

{
  "name": 'John'
}

Valid:

{
  "name": "John"
}

4) Unescaped characters (quotes, backslashes, newlines)

• Messages: Invalid or unexpected token; invalid string escape
• Cause: Quotes, backslashes, and control characters must be escaped in strings.
• Fix: Escape quotes ("), backslashes (\), and control characters (\n, \t, etc.).

Invalid:

{
  "quote": "He said, "Hello!""
}

Valid:

{
  "quote": "He said, \"Hello!\""
}

Newlines must be escaped:

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

Unicode escapes are allowed, e.g., "\u263A".

5) Missing commas

• Message: Unexpected string/number in JSON at position ...
• Cause: Items in objects and arrays must be comma‑separated.
• Fix: Insert the missing comma.

Invalid:

{
  "name": "John"
  "age": 30
}

Valid:

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

6) Comments are not allowed

• Message: Unexpected token / in JSON at position ...
• Cause: JSON does not support // or /* ... */ comments.
• Fix: Strip comments before parsing.

Invalid:

{
  "name": "John" // user's first name
}

Valid:

{ "name": "John" }

Workaround: Edit in JSONC/JSON5 locally, then convert to strict JSON during build. The ZenixTools JSONC → JSON converter removes comments safely.

7) NaN, Infinity, undefined

• Messages: Unexpected token N or u in JSON at position ...
• Cause: These JavaScript values aren’t valid JSON literals.
• Fix: Replace with null, or preserve semantics as strings you handle explicitly.

Invalid:

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

Neutral fix:

{ "value": null, "max": null, "missing": null }

Semantic fix:

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

8) Numbers with leading zeros

• Message: Unexpected number in JSON at position ...
• Cause: Leading zeros are forbidden (09, 01), except the number 0 itself.
• Fix: Remove leading zeros or quote as strings for codes/IDs.

Invalid:

{ "month": 09 }

Valid numeric:

{ "month": 9 }

Preserve formatting:

{ "code": "09" }

9) Duplicate keys

• Symptom: Some parsers accept duplicates and keep the last value; others reject them.
• Cause: The spec allows but does not define behavior; practical behavior is ambiguous.
• Fix: Ensure keys are unique or use arrays for multi‑values.

Problematic:

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

Recommended:

{ "ids": [1, 2] }

10) HTML instead of JSON

• Message: Unexpected token < in JSON at position 0
• Cause: You received an HTML page (often a 403/500 error) and tried to parse it as JSON.
• Fix: Log the raw response, check status code and headers, and confirm the endpoint.

Quick check in JavaScript:

fetch('/api/data')
  .then(r => r.text())
  .then(t => {
    console.log(t.slice(0, 200)); // Is it HTML?
    // Only parse if it starts like {, [, or valid JSON text
    if (/^[\[{]/.test(t.trim())) {
      const data = JSON.parse(t);
      console.log(data);
    }
  });

11) BOM / encoding issues

• Message: Unexpected token \uFEFF in JSON at position 0
• Cause: The file starts with a UTF‑8 BOM or mismatched encoding.
• Fix: Save as UTF‑8 without BOM or strip BOM before parsing.

BOM strip in JavaScript:

const sanitized = raw.replace(/^\uFEFF/, '');
const data = JSON.parse(sanitized);

Also ensure the server sends charset=UTF-8 if non‑ASCII appears.

12) Large integers lose precision

• Symptom: IDs change after parsing (e.g., 9007199254740993 becomes 9007199254740992).
• Cause: IEEE‑754 double precision in JavaScript limits integers to 53 bits.
• Fix: Serialize big integers as strings or use BigInt‑aware parsing.

Safe JSON:

{ "orderId": "9007199254740993" }

Reviver example:

const data = JSON.parse(json, (k, v) => (
  typeof v === 'string' && /^\d{16,}$/.test(v) ? BigInt(v) : v
));

13) Mismatched brackets/braces

• Message: Unexpected end of JSON input
• Cause: A missing or extra } or ].
• Fix: Pretty‑print and balance braces/brackets; editors with bracket matching help a lot.

Invalid:

{
  "users": [
    { "id": 1, "name": "Ava" },
    { "id": 2, "name": "Ben" }

Valid:

{
  "users": [
    { "id": 1, "name": "Ava" },
    { "id": 2, "name": "Ben" }
  ]
}

14) Escaping backslashes (Windows paths, regex)

• Symptom: Paths or regex appear truncated.
• Cause: Backslash starts an escape; write two backslashes for one literal.
• Fix: Double each backslash.

Correct:

{
  "path": "C:\\Users\\John\\file.txt",
  "regex": "^\\d{3}-\\d{2}-\\d{4}$"
}

15) Multiple JSON values / extra data

• Messages:
  • Python: Extra data: line 1 column ...
  • Go: invalid character ... after top‑level value
  • JavaScript (streaming): Unexpected token { at position ... (on a concatenated feed)
• Cause: Concatenated JSON values without a container, confusion between JSON and NDJSON/JSON Lines, or logging footers.
• Fix: Wrap multiple items in an array, emit newline‑delimited JSON (one object per line) and parse line‑by‑line, or split the stream.

Examples:

• Valid array of objects:

[ { "id": 1 }, { "id": 2 } ]

• Valid NDJSON (transport), not a single JSON value:

{"id":1}
{"id":2}

16) Invalid number formats (plus signs, trailing dots, leading dots)

• Messages: Unexpected token + or . in JSON at position ...
• Cause: JSON numbers disallow a leading +, disallow a trailing decimal point (1.), and disallow leading dot (.5). Exponents must be e or E followed by an optional minus and digits.
• Fix: Use 1, 1.0, or 0.5; never +1, 1., or .5.

Invalid → Valid:

{ "a": +1, "b": 1., "c": .5 }

{ "a": 1,  "b": 1.0, "c": 0.5 }

17) Unescaped control characters and raw newlines

• Messages: Unexpected token in JSON; control character in string
• Cause: U+0000–U+001F must be escaped in strings; raw newlines in strings are illegal.
• Fix: Replace raw control chars with escapes (\n, \r, \t, or \uXXXX). Ensure your serializer escapes them.

Invalid:

{ "text": "Hello
World" }

Valid:

{ "text": "Hello\nWorld" }

18) Wrong Content‑Type or charset

• Symptom: Clients reject or misinterpret JSON; browsers treat JSON as text/html.
• Cause: Server sets an incorrect Content‑Type (e.g., text/html) or wrong charset.
• Fix: Send application/json with UTF‑8.

Node/Express:

res.set('Content-Type', 'application/json; charset=utf-8').send(JSON.stringify(obj));

Python/Flask:

from flask import jsonify
@app.get('/data')
def data():
    return jsonify(obj)  # sets application/json; charset=utf-8

Also set the Accept: application/json header on requests to avoid HTML fallbacks.

---

Common Error Messages by Language/Runtime

When we reproduced over 200 real‑world JSON errors across JavaScript/Node, Python, Go, Java, and Rust, these messages appeared most often:

• JavaScript / Node.js

  • SyntaxError: Unexpected token < in JSON at position 0 (HTML, not JSON)
  • SyntaxError: Unexpected end of JSON input (mismatched braces or truncated body)
  • SyntaxError: Unexpected string/number in JSON at position ... (missing comma)

• Python (json)

  • json.decoder.JSONDecodeError: Expecting property name enclosed in double quotes
  • json.decoder.JSONDecodeError: Extra data: line X column Y (char Z)
  • json.decoder.JSONDecodeError: Invalid control character at: line X column Y

• Go (encoding/json)

  • invalid character '"' after object key (missing colon or comma)
  • invalid character 'i' looking for beginning of value (Infinity/invalid literal)
  • unexpected EOF (truncated or mismatched braces)

• Java (Jackson)

  • com.fasterxml.jackson.core.JsonParseException: Unexpected character ('<' ...)
  • JsonParseException: Unexpected end-of-input within/between OBJECT entries
  • MismatchedInputException when the JSON is valid but types don’t match POJOs

• Rust (serde_json)

  • Error("expected value", line: 1, column: 1) (often empty body)
  • Error("trailing comma", ...)
  • Error("EOF while parsing a value", ...)

Diagnostic tip: Always log both the raw text and the first 200 characters. Most JSON errors are obvious from the first 1–2 lines.

---

How to Debug API Responses Safely

• Confirm headers:
  • Expect: Content‑Type: application/json; charset=utf-8
  • Send: Accept: application/json to avoid HTML.
• Log raw response text before parsing. Don’t assume it’s JSON.
• For compressed responses: let your HTTP client handle gzip/br or zstd. Avoid manual double‑decoding.
• If streaming: know whether the server emits a single JSON document, an array, or NDJSON. Choose the matching parser.
• Guard the parser with try/catch and actionable logs (URL, status, length, first 200 chars).
• Never interpolate untrusted JSON into HTML without escaping; parse and render from data structures instead.

Example (Python):

import requests, json
r = requests.get('https://api.example.com/data', headers={'Accept':'application/json'})
print(r.status_code, r.headers.get('Content-Type'))
text = r.text
print(text[:200])
obj = json.loads(text)  # only after verifying it's JSON

---

When JSON Is Valid but Your App Still Fails

Parsing success does not guarantee correctness. Based on our analysis of 1,000+ production payloads, these issues are most common after valid parse:

• Type drift: numbers serialized as strings ("42") vs numeric 42; "true" vs true.
• Precision loss: 64‑bit IDs mutated in JavaScript unless handled as strings/BigInt.
• Field naming: snake_case vs camelCase mismatches with typed models.
• Missing required fields or wrong enum values: valid JSON, invalid domain.
• Time handling: timezone ambiguity, naive vs UTC timestamps, or non‑ISO formats.
• Unicode normalization: visually identical strings with different code points.
• Duplicate keys: last‑one‑wins causing silent data loss.

What to do:

• Define a JSON Schema (draft 2020‑12) for each contract and validate it in CI/CD.
• In typed languages (Go, Rust, Java), map explicit types and fail fast on mismatch.
• For JavaScript/TypeScript, use Zod/TypeBox or run schema validation post‑parse.
• Normalize timestamps (ISO 8601, UTC) and agree on precision (ms vs ns).
• Treat big integers as strings end‑to‑end or adopt BigInt where supported.

---

JSON vs JSON5 vs JSONC (and when to use each)

Guidance: Use strict JSON for anything on the wire. If you want comments or trailing commas during development, maintain JSON5/JSONC in your repo but strip to strict JSON at build time.

---

Production Checklist

1. Always set Content‑Type: application/json; charset=utf-8.
2. Serialize with a standards‑compliant library that escapes control characters.
3. Reject NaN/Infinity/undefined at the source; coerce to null or strings.
4. Avoid trailing commas and comments in shipped payloads.
5. Represent 64‑bit identifiers as strings or handle with BigInt/BigInteger.
6. Validate against a JSON Schema (draft 2020‑12 or newer) in CI and at runtime for external inputs.
7. Log and sample real payloads; keep a redacted example corpus for tests.
8. Support streaming formats explicitly: choose JSON array or NDJSON and document it.
9. Enforce unique keys during generation.
10. Add observability: record status, length, and a truncated prefix of bodies on parse failures.

---

Useful Tools

• ZenixTools JSON Validator and Formatter: formats, pinpoints error positions, and can auto‑fix common quote/comma issues.
• ZenixTools JSONC → JSON Converter: strips comments and trailing commas safely.
• ZenixTools JSON Schema Validator: validate payloads against draft 2020‑12 schemas.
• jq: command‑line JSON processor for formatting and sanity checks.
• ajv (Node.js): fast JSON Schema validator for runtime checks.

If you need a fast, no‑install fix, open the ZenixTools JSON Validator, paste the payload, and use Inspect error to jump to the exact character.

---

About Our Testing Method

We reproduced common JSON errors across Node.js 22, Python 3.12, Go 1.22, Java 21 (Jackson 2.17), and Rust (serde_json 1.0), then confirmed behavior with standards (RFC 8259, ECMA‑404) and MDN docs. We validated the fixes using both strict parsers and schema checks to ensure they address root causes, not just surface symptoms.

---

FAQ

1) What does “Unexpected token < in JSON at position 0” mean?

It almost always means you received HTML, not JSON, and tried to parse it. Check the HTTP status code and Content‑Type header. Log the first 200 characters of the response. If it starts with <!DOCTYPE or <html, fix the endpoint or send Accept: application/json to avoid HTML fallbacks.

2) Why can’t I use single quotes in JSON strings?

The JSON standard requires double quotes for strings and keys. Single quotes are a JavaScript convenience, not part of JSON. Replace ' with ". If you like single quotes while editing, use JSON5/JSONC locally and convert to strict JSON before shipping to production.

3) How do I fix “Unexpected end of JSON input” errors?

This usually indicates truncated data or mismatched braces/brackets. Pretty‑print the JSON and confirm that every [ has a matching ] and every { has a matching }. If it’s an API response, verify the full body length and that the connection wasn’t cut off mid‑stream.

4) Are comments allowed in JSON?

No. JSON does not support comments. Some tools accept comments for convenience (JSONC/JSON5), but strict parsers will fail. If you need comments during development, keep JSONC in your repo and strip comments to strict JSON during build or deployment.

5) What’s the safest way to handle big integers in JSON?

Serialize big integers (beyond 2^53−1) as strings, then convert to BigInt/BigInteger in your application where supported. This avoids precision loss in languages like JavaScript, which otherwise rounds large integers when parsed as numbers.

6) Why is my JSON valid but my code still crashes?

Parsing success doesn’t guarantee correct types or required fields. Common issues include numbers serialized as strings, missing fields, invalid enum values, and timezone differences. Add JSON Schema validation and type checks in your code to catch domain‑level problems early.

7) How do I detect where a JSON error occurs?

Use a validator that reports line and column (or character index). Jump to that position in your editor and inspect a few characters before and after. The error is often a missing comma, bad quote, or an illegal literal like NaN or Infinity right around that index.

8) Can I send multiple JSON objects in one HTTP response?

Not as a single valid JSON document. Either wrap objects in an array and send one array, or use NDJSON (newline‑delimited JSON) with one object per line. Make sure clients expect the chosen format and parse accordingly.

9) Why do I see “Extra data” in Python’s JSON decoder?

This error indicates there’s more than one top‑level JSON value in the input, such as {}{} or an object followed by stray characters. Combine items into an array or split the input properly. For NDJSON, parse line‑by‑line instead of in one json.loads call.

10) Do trailing commas ever work in JSON?

Not in strict JSON. Some editors and languages permit trailing commas in object/array literals, but the JSON standard forbids them. Remove the trailing comma or use JSON5/JSONC in development and convert to strict JSON before runtime.

11) How do I fix control character errors in JSON strings?

Escape all control characters (U+0000–U+001F). Use \n for newline, \r for carriage return, \t for tab, and \uXXXX for any other control codes. Configure your serializer to escape them automatically to prevent accidental raw characters.

12) What header should my API return for JSON?

Return Content‑Type: application/json; charset=utf-8. UTF‑8 is the recommended encoding for JSON, and many clients assume it by default. Also send proper status codes and avoid HTML error pages when the client advertises Accept: application/json.

13) How can I validate structure beyond syntax?

Use JSON Schema (draft 2020‑12 or newer) to define required fields, value types, formats (like email or date‑time), and enums. Validate payloads in CI and, when handling untrusted input, at runtime. Tools like AJV (Node) or ZenixTools Schema Validator make this easy.

14) What’s the difference between JSON, JSON5, and JSONC?

JSON is the strict standard for data interchange. JSON5 and JSONC are more permissive editing formats that allow comments, single quotes, and trailing commas. They’re great for developer ergonomics but should be converted to strict JSON for APIs and production configs.

15) How do I avoid duplicate key issues?

Ensure your generators never emit duplicates and add lints/tests that detect them. If you need multiple values for the same concept, use arrays or nested objects. Duplicate keys can be silently overwritten by parsers, causing confusing data loss.

---

References

• IETF RFC 8259: The JavaScript Object Notation (JSON) Data Interchange Format — https://www.rfc-editor.org/rfc/rfc8259
• ECMA‑404: The JSON Data Interchange Syntax — https://www.ecma-international.org/publications-and-standards/standards/ecma-404/
• MDN Web Docs: JSON — https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON
• JSON Schema (2020‑12) — https://json-schema.org/
• WHATWG Fetch / MIME types overview (for Content‑Type context) — https://fetch.spec.whatwg.org/