← Alle Artikel
Aktualisiert am May 29, 20269 min read

„[object Object] is Not Valid JSON" und andere JSON-Syntaxfehler beheben

Bekommst du „[object Object] is not valid JSON" oder „expected a JSON object, array or literal"? Lerne, warum diese Fehler passieren, wie du JSON-Syntax korrigierst, nachgestellte Kommas fixt und kaputtes JSON automatisch reparierst.

Sie führen Ihren Code aus, schauen in den Network-Tab, und da steht es: "[object Object]" is not valid JSON. Oder Ihr JSON-Validator sagt Expected a JSON object, array or literal, oder Ihr Parser verschluckt sich an einem Komma nach dem letzten Element. Diese Fehler gehören zu den häufigsten — und verwirrendsten — JSON-Fehlern, die Entwickler:innen erleben. Dieser Leitfaden erklärt genau, was jeder Fehler bedeutet, warum er auftritt und wie Sie die JSON-Syntax korrigieren, damit Ihr Parser sie akzeptiert.

Was bedeutet „[object Object] is not valid JSON"?

Wenn JavaScript ein Objekt ohne JSON.stringify() in einen String umwandelt, ist das Ergebnis der Text [object Object] — die Standardausgabe der .toString()-Methode jedes Objekts. Wird dieser String dann an JSON.parse() übergeben oder als Request-Body gesendet, erhalten Sie den Fehler:

SyntaxError: "[object Object]" is not valid JSON

Der Parser versucht, den Literaltext [object Object] zu parsen. Er sieht [, erwartet ein JSON-Array, findet das unquotierte Wort object und scheitert. Die Klammer ist echt — sie ist das erste Zeichen des Strings [object Object] — aber was folgt, ist keine gültige JSON-Array-Syntax.

Warum erscheint [object Object] im JSON?

Die Wurzel ist immer dieselbe: Ein JavaScript-Objekt wurde irgendwo im Code in einen String gezwungen, bevor es geparst oder übertragen wurde. Die vier häufigsten Wege:

String-Konkatenation

Wenn Sie ein Objekt mit einem String konkatenieren, ruft JavaScript .toString() auf dem Objekt auf, das [object Object] zurückgibt:

const user = { name: "Alice", age: 30 };

// ❌ String-Konkatenation erzwingt die Konvertierung des Objekts
const body = "data=" + user;
console.log(body); // "data=[object Object]"

// ✅ Mit JSON.stringify
const body = "data=" + JSON.stringify(user);

fetch / XMLHttpRequest-Body ohne JSON.stringify

Ein einfaches Objekt als body eines fetch-Aufrufs zu übergeben, wandelt es automatisch in einen String um:

const payload = { action: "login", user: "alice" };

// ❌ fetch zwingt das Objekt zu "[object Object]"
fetch('/api/login', {
  method: 'POST',
  body: payload,
});

// ✅ Erst serialisieren, Content-Type setzen
fetch('/api/login', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify(payload),
});

Template-Literale

Ein Objekt direkt in ein Template-Literal einzubetten ruft .toString() auf:

const config = { theme: "dark", lang: "en" };

// ❌ Template-Literal-Erzwingung
const json = `{"config": ${config}}`;
// '{"config": [object Object]}'  ← ungültiges JSON

// ✅ Nur das Objekt stringifizieren
const json = `{"config": ${JSON.stringify(config)}}`;
// '{"config": {"theme":"dark","lang":"en"}}'

Verschachteltes stringify

JSON.stringify() auf einem Objekt aufzurufen, das bereits einen vorserialisierten JSON-String als Wert enthält, erzeugt doppelt kodierte Ausgabe — im JSON erscheint das String-Literal statt des Objekts, das es darstellt:

const inner = JSON.stringify({ id: 1 }); // '{"id":1}'
const outer = JSON.stringify({ data: inner });
// '{"data":"{\"id\":1}"}' — das data-Feld ist ein String, kein Objekt

// Wenn der äußere String anschließend JSON.parse()'d wird und data wieder als JSON
// genutzt wird, muss man result.data ein zweites Mal JSON.parse().

Wie behebt man den [object Object]-JSON-Fehler

Der Fix lautet immer: sicherstellen, dass das Objekt mit JSON.stringify() serialisiert wird, bevor es als String verwendet oder übers Netz gesendet wird. Eine schnelle Diagnose: Suchen Sie im Code jede Stelle, an der die betroffene Variable als String benutzt wird, und fügen Sie dort JSON.stringify() hinzu.

// Systematisches Fix-Muster
function toJsonBody(obj) {
  if (typeof obj === 'string') {
    // Schon ein String — vor der Nutzung validieren, dass es gültiges JSON ist
    JSON.parse(obj); // wirft, wenn ungültig
    return obj;
  }
  return JSON.stringify(obj);
}

„Expected a JSON Object, Array or Literal" — was das bedeutet

Dieser Fehler stammt aus dem eingebauten JSON-Viewer von Firefox (und einigen JSON-Validatoren) und bedeutet, dass der Top-Level-Wert in Ihrem JSON keiner der sechs gültigen JSON-Typen ist. Häufige Ursachen:

  • Die Eingabe ist ein leerer String.JSON.parse("") wirft diesen Fehler, weil ein leerer String kein gültiger JSON-Wert ist.
  • Die Eingabe ist undefined. JSON.stringify(undefined) liefert undefined (nicht den String "undefined"), und JSON.parse(undefined) wirft.
  • Die Antwort ist HTML, kein JSON. Eine Server-Fehlerseite liefert oft HTML. Das erste Zeichen < ist kein gültiges JSON. Prüfen Sie den Content-Type-Header und den rohen Response-Body im Network-Tab, bevor Sie annehmen, das JSON selbst sei kaputt.
  • Am Dateianfang steht ein BOM. Ein UTF-8-BOM (Bytes 0xEF 0xBB 0xBF) vor einer JSON-Datei verursacht in strikten Parsern diesen Fehler. RFC 8259 verbietet BOMs in JSON ausdrücklich.
// Vor dem Parsen gegen leer / undefined absichern
function safeParse(text) {
  if (!text || typeof text !== 'string') {
    throw new TypeError(`Cannot parse ${typeof text} as JSON`);
  }
  return JSON.parse(text.trimStart()); // trimStart entfernt versehentliches BOM/Whitespace
}

JSON-Komma nach dem letzten Element: der Trailing-Comma-Fehler

Ein weiterer extrem häufiger JSON-Syntaxfehler ist ein nachgestelltes Komma — ein Komma nach dem letzten Eintrag eines Objekts oder Arrays:

// ❌ Nachgestelltes Komma im Objekt
{
  "name": "Alice",
  "age": 30,
}

// ❌ Nachgestelltes Komma im Array
["red", "green", "blue",]

Die Grammatik von JSON verlangt, dass ein Komma zwei Elemente trennt — auf beiden Seiten muss ein Wert stehen. Ein Komma ohne nachfolgenden Wert verletzt die Grammatik. JavaScript selbst erlaubt nachgestellte Kommas (seit ES5), weshalb Entwickler:innen sie oft gedankenlos hinschreiben.

Nachgestellte Kommas programmatisch finden und beheben:

// ⚠️ Regex-Fix — funktioniert in einfachen Fällen, kann Strings beschädigen
const fixed = raw.replace(/,\s*([}\]])/g, '$1');

// ✅ Besser: einen Reparatur-Parser nutzen, der die Grammatik versteht
// z. B. die Bibliothek json-repair auf npm

Für eine tiefergehende Betrachtung dieses spezifischen Fehlers siehe Nachgestelltes Komma in JSON: Warum es wirft und wie man es behebt.

JSON-Syntax korrigieren: eine vollständige Checkliste

Bevor Sie zu einem JSON-Korrektur-Tool greifen, gehen Sie diese Checkliste durch, um die Fehlerkategorie zu identifizieren:

Struktur

  • Jede { hat ein passendes } und jedes [ hat ein passendes ]. Nicht geschlossene Klammern gehören zu den häufigsten Trunkierungsfehlern.
  • Keine nachgestellten Kommas — kein Komma nach dem letzten Key-Value-Paar in einem Objekt oder dem letzten Eintrag in einem Array.
  • Keine fehlenden Kommas — jeder Eintrag in einem Objekt oder Array (außer dem letzten) muss von einem Komma gefolgt werden.

Strings

  • Alle Strings nutzen doppelte Anführungszeichen. Einfach-quotierte Strings ('Alice') sind JavaScript-Syntax, kein JSON.
  • Alle Objektschlüssel sind doppelt-quotierte Strings. Nackte Schlüssel ({ name: "Alice" }) sind JavaScript-Objektliteral-Syntax, kein JSON.
  • Steuerzeichen in Strings müssen escaped werden. Rohe Zeilenumbrüche, Tabs und Null-Bytes in einem JSON-String sind illegal — nutzen Sie stattdessen \n, \t, \u0000.

Werte

  • Booleans sind kleingeschrieben:true / false, nicht True / False / TRUE.
  • Null ist kleingeschrieben:null, nicht None, nil oder NULL.
  • Kein undefined. JSON kennt keinen undefined-Typ; nutzen Sie null oder lassen Sie den Schlüssel ganz weg.
  • Kein NaN oder Infinity. Diese JavaScript-Werte haben keine JSON-Repräsentation. JSON.stringify({x: Infinity}) erzeugt still {"x":null}.

Zusätzlicher Inhalt

  • Keine Kommentare.// Zeilenkommentare und /* Blockkommentare */ sind nicht Teil der JSON-Spezifikation.
  • Kein nachgestellter Inhalt. Ein gültiger JSON-Text ist genau ein Wert — davor (außer optionalem Whitespace) und danach nichts.

Einen JSON-Korrektor nutzen: wann automatisieren

Für einmaliges Debugging ist Handarbeit am JSON schnell. Für Produktions-Pipelines, die JSON aus externen Quellen erhalten — APIs, KI-Modell-Ausgaben, Nutzereingaben —, brauchen Sie einen JSON-Korrektor: Code oder ein Tool, das gängige Syntaxfehler programmatisch repariert, ohne gültige Inhalte zu beschädigen.

Ein guter JSON-Korrektor handhabt:

  • Nachgestellte Kommas in Objekten und Arrays
  • Einfach-quotierte Strings → doppelt-quotierte Strings
  • Unquotierte Schlüssel → doppelt-quotierte Schlüssel
  • Python-Literale (True, False, None) → JSON-Äquivalente
  • JavaScript-Kommentare // Zeile und /* Block */ → entfernt
  • Markdown-Code-Fences (```json ... ```) → abgestreift
  • Nicht geschlossene Klammern → automatisch geschlossen

Die Schlüsselforderung: Korrekturen müssen grammatikbewusst sein — das Tool weiß, welche Tokens strukturelle Trenner sind und welche innerhalb von String-Werten stehen, sodass String-Inhalte, die zufällig ,} oder True enthalten, nie beschädigt werden.

Eine Anleitung zur Implementierung von JSON-Reparatur in JavaScript-Code finden Sie in Umgang mit kaputtem JSON in JavaScript.

Fallstricke von JSON.stringify vermeiden (einschließlich Zirkelreferenzen)

Sobald man konsequent mit JSON.stringify serialisiert, gibt es noch zwei Situationen, die Leute stolpern lassen:

  • Zirkelreferenzen werfen. Ein Wert wie const a = {}; a.self = a; ergibt TypeError: Converting circular structure to JSON. Drei gute Alternativen: die Rückreferenz mit einem eigenen replacer loswerden, der gesehene Objekte verfolgt; für In-Memory-Tiefkopien zu structuredClone(value) wechseln; oder eine Bibliothek wie flatted nutzen, wenn man wirklich einen zyklischen Graphen serialisieren und später rekonstruieren muss.
  • Verlustbehaftete Typen.JSON.stringify verwirft stillschweigend undefined, Funktionen und Symbol-Werte und wandelt NaN / Infinity in null um. Wandeln Sie diese vor stringify in etwas Darstellbares um, nicht nach dem Parsen.

Kurzreferenz: häufige JSON-Fehler und Fixes

// 1. [object Object] — Objekt zu String gezwungen
❌ fetch(url, { body: myObject })
✅ fetch(url, { body: JSON.stringify(myObject) })

// 2. Nachgestelltes Komma
❌ { "a": 1, "b": 2, }
✅ { "a": 1, "b": 2 }

// 3. Einfache Anführungszeichen
❌ { 'name': 'Alice' }
✅ { "name": "Alice" }

// 4. Unquotierter Schlüssel
❌ { name: "Alice" }
✅ { "name": "Alice" }

// 5. Python-Boolean
❌ { "active": True }
✅ { "active": true }

// 6. Kommentar im JSON
❌ { "debug": true // log everything }
✅ { "debug": true }

// 7. Leerer String
❌ JSON.parse("")
✅ JSON.parse(text || "null")

// 8. HTML-Fehlerseite als „JSON"
❌ JSON.parse("<!DOCTYPE html>...")
✅ Vor response.json() response.ok und Content-Type prüfen

Häufig gestellte Fragen

Was bedeutet „[object Object] is not valid JSON"?

Ein JavaScript-Objekt wurde mit seinem Standard-.toString() in einen String konvertiert, was den Literaltext [object Object] erzeugt, und dieser Text wurde dann als JSON geparst oder gesendet. Der Fix: vor der Nutzung als String mit JSON.stringify() serialisieren.

Wie behebt man den [object Object]-Fehler in einem fetch-Request?

Setzen Sie body: JSON.stringify(payload) und fügen Sie einen Content-Type: application/json-Header hinzu. Ein rohes Objekt als Body zu übergeben, zwingt es zu [object Object].

Was ist „Expected a JSON object, array or literal"?

Firefox und einige Validatoren geben das aus, wenn der Top-Level-Wert keiner der sechs JSON-Typen ist — meistens, weil die Eingabe leer ist, undefined ist, HTML statt JSON enthält oder mit einem Byte-Order-Mark beginnt. Prüfen Sie zuerst response.ok und den Content-Type-Header.

Was sind die häufigsten JSON-Syntaxfehler?

Nachgestellte Kommas, einfache Anführungszeichen, unquotierte Schlüssel, Python-Literale (True/None), Kommentare und NaN/Infinity. Jeder hat einen eigenen Leitfaden: siehe nachgestellte Kommas, unexpected-token-Fehler, unexpected end of input und fehlerhafte Steuerzeichen.

JSON-Syntax online beheben — keine Installation nötig

Wenn Sie einen kaputten JSON-String haben, den Sie jetzt korrigieren müssen, JSON Fix repariert alle oben genannten Fehler automatisch. Fügen Sie Ihr JSON ein — egal wie kaputt —, klicken Sie Repair & Format, und Sie erhalten syntaktisch korrektes, formatiertes JSON zurück. Das Tool läuft komplett im Browser: Keine Daten werden an einen Server gesendet, was es auch für sensible Payloads sicher macht.