← Alle Artikel
Aktualisiert am May 29, 20265 min read

Unexpected End of JSON Input: Warum es passiert und wie man es behebt

Der Parser hat das Ende des Strings erreicht, bevor die Struktur fertig war. Ursachen reichen von abgeschnittenen API-Antworten über nicht geschlossene Klammern bis zu leeren Strings. Fünf Patterns, fünf Fixes.

SyntaxError: Unexpected end of JSON input bedeutet, dass der Parser das Ende des Strings erreicht hat, bevor die JSON-Struktur vollständig war. Die Daten wurden abgeschnitten. Dieser Artikel zeigt jede häufige Art, wie das passiert, und genau, wie man jede behebt.

Was der Fehler bedeutet

JSON.parse() ist eine Zustandsmaschine. Sie liest Zeichen für Zeichen und verfolgt offene Klammern, Geschweifte und String-Trenner. Wenn sie das Eingabeende erreicht, während sie noch „in“ etwas ist —— einem Objekt, Array oder String —— wirft sie:

SyntaxError: Unexpected end of JSON input

Der Fehler nennt keine Zeile und keine Position, weil das Problem das Fehlen von Inhalt ist —— es gibt nichts, worauf man zeigen könnte.

Ursache 1 —— Abgeschnittene API-Antwort

Die häufigste Ursache in der Praxis. Der Server hat einen großen JSON-Body geschickt, und entweder hat das Netzwerk die Verbindung früh getrennt, die Antwort wurde gelesen, bevor sie fertig war, oder ein Buffering-Limit eines Proxys oder CDN wurde getroffen.

// Was angekommen ist (Verbindung mitten in der Antwort abgebrochen):
'{"users":[{"id":1,"name":"Ada"},{"id":2,"na'

JSON.parse('{"users":[{"id":1,...') // SyntaxError: Unexpected end of JSON input

Fix: Prüfen Sie HTTP-Statuscode und Content-Length-Header. Loggen Sie die Länge des Roh-Bodys vor dem Parsen. Wenn Sie fetch verwenden, awaiten Sie immer response.json(), statt response.text() zu lesen und von Hand zu parsen —— der eingebaute JSON-Parser des Browsers gibt bei Abschneiden einen klareren Fehler.

// Korrekt
const data = await response.json();

// Brüchig —— versteckt Abschneidungsfehler
const text = await response.text();
const data = JSON.parse(text);

Ursache 2 —— Nicht geschlossenes Objekt oder Array

Das JSON wurde von Hand geschrieben oder von Code generiert, der eine schließende Klammer vergaß.

JSON.parse('{"name":"Ada","plan":"pro"')
// fehlendes schließendes }
// SyntaxError: Unexpected end of JSON input

JSON.parse('[1, 2, 3')
// fehlendes schließendes ]
// SyntaxError: Unexpected end of JSON input

Fix: Verwenden Sie einen JSON-Linter oder fügen Sie den String in JSON Fix ein —— er identifiziert den nicht geschlossenen Delimiter und kann im toleranten Modus die fehlende Klammer automatisch ergänzen.

Ursache 3 —— Nicht geschlossener String

Ein String-Wert, der nie mit einem schließenden doppelten Anführungszeichen beendet wurde —— oft weil der Wert selbst ein nicht escaptes doppeltes Anführungszeichen enthielt:

JSON.parse('{"title":"He said "hello" to her"}')
//                              ^ unescaptes Anführungszeichen schließt den String zu früh
// SyntaxError: Unexpected end of JSON input

// Korrekt —— innere Anführungszeichen mit Backslash escapen:
JSON.parse('{"title":"He said \"hello\" to her"}')

Fix: Escapen Sie innere doppelte Anführungszeichen als \", oder bauen Sie das JSON von Anfang an mit JSON.stringify(), statt Strings von Hand zusammenzusetzen.

Ursache 4 —— Leerer String

Einen leeren String oder einen reinen Whitespace-String an JSON.parse() zu übergeben wirft denselben Fehler —— es gibt nichts zu parsen.

JSON.parse('')   // SyntaxError: Unexpected end of JSON input
JSON.parse('  ') // SyntaxError: Unexpected end of JSON input
JSON.parse()     // SyntaxError: Unexpected token u… (undefined zu String gecastet)

Das passiert oft, wenn ein Formularfeld, ein localStorage-Schlüssel oder eine Umgebungsvariable leer ist.

// Vor dem Parsen absichern
const raw = localStorage.getItem('session');
if (!raw) return null;
return JSON.parse(raw);

Ursache 5 —— Streaming-Antwort zu früh gelesen

Beim Konsumieren einer Streaming-API oder eines WebSockets ist es leicht, einen Chunk zu parsen, bevor die ganze Nachricht angekommen ist.

// ❌ Versuch, einen unvollständigen Chunk zu parsen
ws.onmessage = (event) => {
  const data = JSON.parse(event.data); // möglicherweise teilweise
};

// ✓ Bis zur Nachrichtengrenze puffern (Framing auf Anwendungsebene)
let buffer = '';
ws.onmessage = (event) => {
  buffer += event.data;
  if (buffer.endsWith('\n')) {        // oder bekannten Trenner prüfen
    const data = JSON.parse(buffer.trim());
    buffer = '';
  }
};

Abschneiden diagnostizieren: Content-Length und der Streaming-Reader

Zwei konkrete Techniken, um zu bestätigen, ob die Antwort tatsächlich kurz abbrach:

  • Mit Content-Length vergleichen. Wenn der Server ihn setzt, können Sie ein kurzes Lesen direkt erkennen:
    const res = await fetch(url);
const expected = Number(res.headers.get('Content-Length') ?? NaN);
const text = await res.text();
if (Number.isFinite(expected) && text.length !== expected) {
  throw new Error(`truncated: got ${text.length} of ${expected} bytes`);
}

    Hinweis: Content-Length kann bei chunked/komprimierten Antworten fehlen.

  • Mit dem Streaming-Body-Reader lesen. Mit res.body.getReader() können Sie das chunkweise Eintreffen beobachten und bemerken, wenn der Stream mitten im Payload schließt —— das Symptom einer abgebrochenen Verbindung oder eines Proxy-Timeouts. Der Browser bringt den zugrundeliegenden Netzwerkausfall als fetch-Rejection zutage, wenn der Stream abbricht; kombinieren Sie das mit dem Parser-Fehler, um sicherzugehen.

Schnelle Diagnose-Checkliste

  • Loggen Sie typeof input und input.length direkt vor dem Parse-Aufruf.
  • Wenn die Länge zu kurz aussieht, wurde die Antwort abgeschnitten —— prüfen Sie die Netzwerk-Logs.
  • Wenn die Länge 0 ist, lieferte die Quelle (API, Storage, Env-Variable) nichts —— eine Guard hinzufügen.
  • Wenn die Länge richtig aussieht, fügen Sie den String in JSON Fix ein, um das strukturelle Problem zu finden.

In Produktion sauber recovern

function safeParse(text, fallback = null) {
  if (!text || !text.trim()) return fallback;
  try {
    return JSON.parse(text);
  } catch {
    console.error('JSON parse failed, input length:', text.length);
    return fallback;
  }
}

Häufig gestellte Fragen

Was verursacht „Unexpected end of JSON input“?

Der Parser erreichte das Ende des Strings, während er noch in einem Objekt, Array oder String war —— die Daten waren unvollständig. Die häufigste Ursache in der Praxis ist eine abgeschnittene API-Antwort; andere sind eine nicht geschlossene Klammer, ein nicht beendeter String oder ein leerer String.

Warum gibt es keine Zeilennummer oder Position?

Weil das Problem fehlender Inhalt ist, nicht ein falsches Zeichen. Es gibt nichts, worauf der Parser zeigen könnte —— er ist einfach mit der Eingabe ausgegangen, bevor die Struktur schloss.

Wie behebe ich es für einen leeren String?

Sicher Sie vor dem Parsen ab: if (!raw || !raw.trim()) return fallback;. Leere Formularfelder, fehlende localStorage-Schlüssel und nicht gesetzte Umgebungsvariablen sind die typischen Quellen.

Wie behandle ich es sauber in Produktion?

Wickeln Sie JSON.parse() in einen safeParse-Helper, der bei Fehlschlag einen Fallback zurückgibt (siehe das Snippet oben), und loggen Sie die Eingabelänge, damit Sie Abschneiden von fehlerhafter Struktur unterscheiden können. Für das vollständige Muster siehe Kaputtes JSON in JavaScript behandeln.

Abgeschnittenes JSON im Browser reparieren

Haben Sie einen kaputten JSON-String, den Sie inspizieren oder reparieren müssen? JSON Fix auf fixjson.org parst, validiert und repariert häufige strukturelle Fehler automatisch —— inklusive fehlender Klammern —— direkt im Browser, ohne Daten an einen Server zu senden.