SyntaxError: Unexpected non-whitespace character after JSON data

The exact error string

JSON.parse('{"a":1}{"b":2}');
// V8 / Chrome / Node:
//   SyntaxError: Unexpected non-whitespace character after JSON data
//   at JSON.parse (<anonymous>)

// Firefox:
//   SyntaxError: unexpected non-whitespace character after JSON data
// Safari:
//   SyntaxError: Unexpected token '{'

The wording differs by engine, but the meaning is identical: a valid JSON value was parsed, and then something non-whitespace appeared after it. JSON.parse parses a single value — one object, one array, one string, one number — and nothing more.

Why JSON.parse rejects a second value

The JSON grammar defines a document as exactly one value, optionally surrounded by whitespace. JSON.parse reads that one value greedily, then verifies the rest of the string is only whitespace. The instant it meets a non-whitespace character — the { of a second object, a comma, a stray byte — it throws.

This is the mirror of Python's json.decoder.JSONDecodeError: Extra data: same root cause (more than one value), different runtime. If you also work in Python, that page covers the identical problem with json.loads.

Cause 1: NDJSON / JSON Lines (the most common)

NDJSON (newline-delimited JSON, also called JSON Lines or .jsonl) stores one JSON object per line. Log pipelines, LLM streaming responses, BigQuery exports, and many APIs use it. The whole file is many values, so a single JSON.parse fails on the second line:

const ndjson = `{"id":1,"name":"Ada"}
{"id":2,"name":"Bob"}
{"id":3,"name":"Cay"}`;

JSON.parse(ndjson);   // ❌ Unexpected non-whitespace character after JSON data

// ✅ Parse each line on its own:
const rows = ndjson
  .split('\n')
  .filter(line => line.trim() !== '')
  .map(line => JSON.parse(line));
// rows = [{id:1,...}, {id:2,...}, {id:3,...}]

If the data arrives as a stream (fetch with a chunked body, an LLM token stream), buffer the text and split on newlines, parsing only complete lines — the last chunk may be a partial line you should hold until the next chunk arrives.

Parsing an NDJSON stream from fetch

When NDJSON arrives over the network — a log tail, an LLM token stream, a large export — chunks do not align to line boundaries. A naive split on each chunk will eventually try to parse a partial line and fail. Buffer the text, emit only complete lines, and parse the remainder at the end:

const res = await fetch('/api/events');         // NDJSON stream
const reader = res.body.getReader();
const decoder = new TextDecoder();
let buffer = '';

for (;;) {
  const { value, done } = await reader.read();
  if (done) break;
  buffer += decoder.decode(value, { stream: true });

  let nl;
  while ((nl = buffer.indexOf('\n')) !== -1) {
    const line = buffer.slice(0, nl).trim();
    buffer = buffer.slice(nl + 1);              // keep the partial remainder
    if (line) handle(JSON.parse(line));         // one complete value
  }
}
if (buffer.trim()) handle(JSON.parse(buffer.trim()));  // last line, no trailing \n

The key detail is buffer = buffer.slice(nl + 1): whatever follows the last newline is an incomplete line and must wait for the next chunk. Parsing the whole buffer per chunk is exactly what produces Unexpected non-whitespace character after JSON data on streamed data.

Cause 2: a doubled or double-encoded body

Two complete values concatenated usually means the producer emitted the body twice, or a value was JSON.stringify-ed and then wrapped and stringified again. The fix is at the source, but you confirm it by inspecting the raw text:

const res = await fetch('/api/data');
const raw = await res.text();        // read raw FIRST, don't call .json() yet
console.log(JSON.stringify(raw));    // e.g. "{\"ok\":true}{\"ok\":true}"

// If you see two objects back to back, the server is writing the body twice
// (e.g. res.json(x) called twice, or res.write + res.json). Fix the handler.

// Only call .json() once you know the body is a single value:
const data = JSON.parse(raw);

Reading the body with .text() first is the key debugging move — but remember a response body can only be read once, so read it as text and then JSON.parse the text, rather than calling .json() afterwards. (See body stream already read.)

Cause 3: a stray trailing character

Sometimes only one or two extra characters follow a perfectly good value: a trailing comma, a duplicated closing brace, a stray semicolon copied from code, an extra quote, or a byte-order mark (BOM) at the end of a concatenation. The reported position points right at it:

JSON.parse('{"ok":true},');   // ❌ trailing comma after the object
JSON.parse('{"ok":true}}');   // ❌ extra closing brace
JSON.parse('{"ok":true};');   // ❌ stray semicolon (copied from JS source)

// Fix at the source. If you must defend against trailing junk you control,
// trim known characters — never blindly slice, which can corrupt valid data:
const cleaned = raw.trim().replace(/;+$/, '');
JSON.parse(cleaned);

Debugging checklist

• ✓ Log the raw string (and its .length) before parsing — never parse blind
• ✓ One JSON object per line? It is NDJSON — split on \n and parse each line
• ✓ Two values back to back? The source is producing a doubled body — fix the producer
• ✓ Only a character or two extra? Remove the trailing comma / brace / semicolon / BOM
• ✓ Using fetch? Read response.text() once, then JSON.parse it
• ✓ Getting the opposite (empty/cut-off)? That is Unexpected end of JSON input, not this