JSON: Syntax, Datentypen und Prüfung

https://bildung.social/@oerinformatik/

https://oer-informatik.de/json

JSON, JavaScript Object Notation, RFC 8259, Syntaxdiagramm, Datentypen, ISO 8601, Escape-Sequenz, JSONPath, JSON Schema, Validierung, Datenaustausch

tl/dr; (ca. 11 min Lesezeit): JSON ist das Standardformat von Web-APIs, Konfigurationsdateien und Dokumentendatenbanken. Der Artikel erklärt die Bausteine Objekt und Array am Syntaxdiagramm, die sechs Datentypen und ihre Entsprechung im Programm, das Maskieren von Sonderzeichen, Datumsangaben nach ISO 8601 und die typischen Syntaxfehler. Er zeigt, wie Du Werte in verschachtelten Dokumenten über Pfade ansprichst und wie Du mit JSON Schema prüfst, ob ein Dokument die erwarteten Felder und Datentypen hat [AI-Assisted]. (Zuletzt geändert am 28.10.2026)

Dieser Artikel baut auf der Kann-Liste des Artikels Datenaustauschformate: CSV, XML und JSON vergleichen auf.

Schon fit in diesem Thema? Nutze die Kann-Liste und die Leitfragen unter dem Artikel als Checkliste, ob Du die relevanten Kompetenzen bereits hast.

Als JSON-Grundlagen kann ich nach Durchlesen des Artikels…

… die Bausteine Objekt, Array, Schlüssel-Wert-Paar und Wert benennen und das Syntaxdiagramm von JSON lesen.
… die sechs Datentypen von JSON bestimmen und ihnen einen passenden Datentyp im Programm zuordnen.
… ein JSON-Dokument nach einer Beschreibung fehlerfrei notieren, auch mit verschachtelten Objekten und Arrays.
… typische Syntaxfehler in JSON finden und korrigieren.
… Datum und Uhrzeit als Zeichenkette nach ISO 8601 notieren und begründen, warum ein einheitliches Format wichtig ist.

Darüber hinaus kann ich als JSON-Expertenwissen…

… Anführungszeichen, Backslashes und Zeilenumbrüche in Zeichenketten maskieren.
… Werte in verschachtelten Dokumenten über einen Pfad (Punktnotation, Index, JSONPath) ansprechen.
… erläutern, warum doppelte Schlüssel und Zahlen als Text zu Problemen führen, obwohl ein Parser sie einliest.
… ein einfaches JSON Schema lesen und ergänzen und prüfen, ob ein Dokument dazu gültig ist.

Ob eine App Termine vom Server lädt, ein Sensor seine Messwerte meldet oder eine Dokumentendatenbank einen Datensatz speichert: Sehr oft sind die Daten in der JavaScript Object Notation (JSON) geschrieben. Der Vergleich mit CSV und XML im Artikel Datenaustauschformate zeigt, wofür JSON gut geeignet ist. Dieser Artikel geht tiefer: Er erklärt die Syntax genau, zeigt die Stolperfallen und wie Du JSON-Dokumente automatisch prüfst.

Woher JSON kommt und wo es eingesetzt wird

JSON ist ein textbasiertes Format zum Speichern und Austauschen strukturierter Daten. Es stammt aus JavaScript, ist aber völlig unabhängig von einer Programmiersprache: Für nahezu jede Sprache gibt es Bibliotheken, die JSON einlesen (parsen) und erzeugen (serialisieren). Festgelegt ist JSON in RFC 8259 (IETF, Internetstandard STD 90) und gleichlautend in ECMA-404. Dateien haben die Endung .json, der Medientyp bei der Übertragung ist application/json, die Zeichenkodierung ist UTF-8.

Typische Einsatzgebiete sind:

Web-APIs (REST): Anfragen und Antworten zwischen App und Server,
Konfigurationsdateien, z. B. package.json in JavaScript-Projekten oder Einstellungen von Entwicklungsumgebungen,
Dokumentendatenbanken wie MongoDB, die jeden Datensatz als JSON-Dokument speichern (siehe NoSQL und Dokumentendatenbanken),
Nachrichten im Internet der Dinge, z. B. Messwerte, die Sensoren über MQTT senden.

Die Bausteine

JSON kennt genau zwei Strukturen:

Ein Objekt steht in geschweiften Klammern { } und enthält beliebig viele Schlüssel-Wert-Paare (name/value pairs), getrennt durch Kommas. Schlüssel und Wert werden durch einen Doppelpunkt getrennt. Der Schlüssel ist immer eine Zeichenkette in doppelten Anführungszeichen.
Ein Array steht in eckigen Klammern [ ] und enthält eine geordnete Liste von Werten, getrennt durch Kommas.

Ein Wert kann wieder ein Objekt oder ein Array sein. Dadurch lassen sich Daten beliebig tief verschachteln – JSON ist ein hierarchisches Format. Ein vollständiges JSON-Dokument besteht aus genau einem Wert; meist ist das ein Objekt oder ein Array, erlaubt sind aber auch ein leeres Array [] oder eine einzelne Zahl.

Das Syntaxdiagramm zeigt diese Regeln auf einen Blick: Ein Wert ist ein Objekt, ein Array, eine Zeichenkette, eine Zahl oder eines der Literale true, false und null; Objekte bestehen aus Paaren zeichenkette : wert, Arrays aus Werten, jeweils durch Kommas getrennt. Wie Du solche Diagramme liest, erklärt der Artikel EBNF und Syntaxdiagramme.

Syntaxdiagramm der JSON-Bausteine Wert, Objekt, Paar und Array (mit KI erstellt)

Zwei Regeln lassen sich am Diagramm direkt ablesen: Nach dem letzten Paar bzw. Wert folgt kein Komma mehr, und ein Objekt oder Array darf leer sein ({}, []). Leerzeichen, Tabulatoren und Zeilenumbrüche zwischen den Bausteinen sind beliebig; sie dienen nur der Lesbarkeit.

Die Reihenfolge ist unterschiedlich geregelt: Die Werte eines Arrays sind geordnet ([1, 2] ist etwas anderes als [2, 1]), die Paare eines Objekts dagegen nicht. Ein Programm darf sich also nicht darauf verlassen, dass "titel" vor "seiten" steht.

Die sechs Datentypen

Die Datentypen von JSON
JSON-Datentyp	Schreibweise	Beispiel	typischer Datentyp im Programm
Zeichenkette (string)	in doppelten Anführungszeichen, Sonderzeichen mit `\` maskiert	`"Bielefeld"`, `"Zeile 1\nZeile 2"`	`String`
Zahl (number)	ohne Anführungszeichen, Dezimalpunkt, optional Exponent	`42`, `-3.5`, `1.2e3`	`int`, `long`, `double`, `BigDecimal`
Wahrheitswert (boolean)	klein geschrieben, ohne Anführungszeichen	`true`, `false`	`boolean`
Nullwert	klein geschrieben	`null`	`null` / `None`
Objekt (object)	`{ "schluessel": wert, … }`	`{ "min": 3, "max": 4 }`	Objekt einer Klasse, `Map`, `dict`
Array (array)	`[ wert, wert, … ]`	`["Jugendbuch", "Umwelt"]`	Array, `List`

JSON unterscheidet bei Zahlen nicht zwischen Ganzzahl und Kommazahl. Welcher Datentyp im Programm passt, entscheidest Du anhand der Bedeutung: Eine Seitenzahl 192 wird ein int, ein Messwert wie 21.5 ein double, ein Array aus Kommazahlen ein double[] bzw. float[]. Geldbeträge liest man besser als exakte Dezimalzahl (BigDecimal) ein. Führende Nullen (007), NaN und Infinity sind in JSON nicht erlaubt.

Ein ganzes Beispiel mit allen Datentypen:

{
  "station": "Infoterminal Foyer",
  "id": 17,
  "aktiv": true,
  "temperaturen": [21.5, 22.0, 23.25],
  "standort": { "gebaeude": "A", "etage": 0 },
  "wartung": null
}

Zeichenketten und Sonderzeichen

Weil eine Zeichenkette in doppelten Anführungszeichen steht, darf ein Anführungszeichen in ihr nicht einfach so vorkommen. Solche Zeichen werden mit einem Backslash maskiert (Escape-Sequenz):

Escape-Sequenzen in JSON-Zeichenketten
Zeichen	Escape-Sequenz in JSON
doppeltes Anführungszeichen `"`	`\"`
Backslash `\`	`\\`
Zeilenumbruch	`\n`
Tabulator	`\t`
Wagenrücklauf	`\r`
beliebiges Unicode-Zeichen	`\u` und vier Hexadezimalziffern, z. B. `ä` für ä

Der Titel Quiz "OWL" am Abend mit einem Zeilenumbruch und dem Hinweis Treffpunkt: Eingang wird so zu:

{ "titel": "Quiz \"OWL\" am Abend\nTreffpunkt: Eingang" }

Umlaute und andere Unicode-Zeichen dürfen direkt im Text stehen, weil JSON-Dateien UTF-8-kodiert sind; ä ist nur nötig, wenn ein System ausschließlich ASCII verarbeiten kann. Einfache Anführungszeichen (Apostroph) müssen nicht maskiert werden: "Bielefeld gibt's" ist gültig. Die Escape-Sequenzen schreibt meist die JSON-Bibliothek beim Serialisieren selbst; von Hand musst Du nur aufpassen, wenn Du JSON direkt in einen Text tippst.

Datum und Uhrzeit

JSON hat keinen Datentyp für Datum und Uhrzeit. Üblich ist eine Zeichenkette im Format ISO 8601:

nur Datum: "2027-03-13",
Datum und Uhrzeit mit Zeitzonenabstand: "2027-03-13T10:00:00+01:00",
in koordinierter Weltzeit (UTC): "2027-03-13T09:00:00Z".

ISO 8601 ist eindeutig (kein Rätseln, ob 03.04. der 3. April oder der 4. März ist), lässt sich als Text richtig sortieren und wird von den Datumsbibliotheken aller gängigen Sprachen direkt eingelesen, z. B. in Java als OffsetDateTime. Mit dem Zeitzonenabstand bleibt die Uhrzeit auch dann richtig, wenn Server und App in verschiedenen Zeitzonen laufen oder zwischen Sommer- und Winterzeit gewechselt wird. Wer stattdessen "13.03.27" oder "01-APR-23 12.41.08 PM" schreibt, zwingt jedes empfangende Programm, genau dieses Format zu kennen.

Typische Fehler in JSON

JSON ist streng. Programme, die JSON einlesen (Parser), brechen bei jedem dieser Fehler ab:

Häufige Syntaxfehler in JSON
Fehler	falsch	richtig
Schlüssel ohne Anführungszeichen	`{ titel: "Momo" }`	`{ "titel": "Momo" }`
einfache Anführungszeichen	`{ 'titel': 'Momo' }`	`{ "titel": "Momo" }`
Komma nach dem letzten Element (trailing comma)	`[1, 2, 3,]`	`[1, 2, 3]`
Dezimalkomma statt Dezimalpunkt	`{ "preis": 12,99 }`	`{ "preis": 12.99 }`
Kommentar	`{ "id": 1 // Artikel }`	Kommentare sind nicht erlaubt – Erläuterungen ggf. als eigenes Feld
großgeschriebene Literale	`True`, `NULL`	`true`, `null`
fehlendes Komma zwischen Paaren	`{ "a": 1 "b": 2 }`	`{ "a": 1, "b": 2 }`
nicht maskiertes Anführungszeichen	`{ "titel": "Quiz "OWL"" }`	`{ "titel": "Quiz \"OWL\"" }`

Drei weitere Punkte führen nicht zu einem Syntaxfehler, aber zu Ärger:

Doppelte Schlüssel in einem Objekt ({ "id": 1, "id": 2 }) sind laut RFC 8259 nicht verboten, aber das Verhalten ist nicht festgelegt – manche Parser nehmen den ersten, manche den letzten Wert, manche melden einen Fehler. Schlüssel sollten deshalb eindeutig sein.
Zahlen und Wahrheitswerte als Text ("seiten": "192", "aktiv": "ja") sind gültiges JSON, aber der Wert ist eine Zeichenkette: Sortieren, Rechnen und Vergleichen funktionieren nicht wie erwartet ("192" < "50", weil Texte zeichenweise verglichen werden).
Uneinheitliche Datumsformate (siehe oben).

Manche Werkzeuge erlauben Erweiterungen wie Kommentare oder Kommas am Ende (JSON5, JSONC). Diese Dateien sind dann aber kein gültiges JSON mehr. Steht in einer Aufgabe oder Lösung eine Beschriftung wie // sensoren über einem Array, dient sie nur der Orientierung und gehört nicht zum JSON.

Auf verschachtelte Werte zugreifen

Um einen Wert in einem verschachtelten Dokument anzusprechen, gibt man seinen Pfad an: Die Schlüssel der Objekte werden mit Punkten aneinandergereiht, Array-Elemente über ihren Index in eckigen Klammern. Der Index beginnt bei 0. Für das Beispiel-Dokument oben gilt:

Pfade im Beispiel-Dokument
Pfad	Wert
`station`	`"Infoterminal Foyer"`
`standort.etage`	`0`
`temperaturen[0]`	`21.5`
`temperaturen[2]`	`23.25`
`wartung`	`null`

Je nach Werkzeug wird der Pfad etwas anders geschrieben:

Pfadangaben in verschiedenen Werkzeugen
Werkzeug	Schreibweise für `standort.etage`
JSONPath (z. B. in Testwerkzeugen für APIs)	`$.standort.etage` – `$` steht für das ganze Dokument
MariaDB/MySQL	`JSON_VALUE(daten, '$.standort.etage')`
MongoDB	`{ "standort.etage": 0 }` als Filter (Punktnotation)
JavaScript	`daten.standort.etage`
Python	`daten["standort"]["etage"]`

Ein Pfad, der ins Leere führt (z. B. standort.raum), liefert je nach Werkzeug null, undefined, gar kein Ergebnis oder einen Fehler. Programme sollten fehlende Felder deshalb immer abfangen.

JSON prüfen

Syntax prüfen

Ob ein Text gültiges JSON ist, prüfst Du mit jedem JSON-Parser, z. B. in der Kommandozeile mit python -m json.tool datei.json oder jq . datei.json, in der Entwicklungsumgebung oder mit einem Online-Validator (keine vertraulichen Daten hochladen!). Der Parser meldet die Zeile und Spalte des ersten Fehlers – Folgefehler zeigt er erst, wenn der erste behoben ist.

Inhalt prüfen mit JSON Schema

Syntaktisch gültiges JSON kann trotzdem unbrauchbar sein: Ein Feld fehlt, eine Zahl steht als Text da, ein Wert liegt außerhalb des erlaubten Bereichs. Welche Felder ein Dokument haben muss und welche Datentypen und Werte erlaubt sind, beschreibt man mit JSON Schema – vergleichbar mit einer XSD für XML. Ein Schema ist selbst ein JSON-Dokument. Für die Infoterminals könnte es so aussehen:

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "title": "Infoterminal",
  "type": "object",
  "properties": {
    "station": { "type": "string", "minLength": 1 },
    "id": { "type": "integer", "minimum": 1 },
    "aktiv": { "type": "boolean" },
    "temperaturen": { "type": "array", "items": { "type": "number" } },
    "standort": {
      "type": "object",
      "properties": {
        "gebaeude": { "type": "string", "enum": ["A", "B", "C"] },
        "etage": { "type": "integer" }
      },
      "required": ["gebaeude", "etage"]
    },
    "wartung": { "type": ["string", "null"] }
  },
  "required": ["station", "id", "aktiv"],
  "additionalProperties": false
}

Die wichtigsten Schlüsselwörter:

Wichtige Schlüsselwörter von JSON Schema
Schlüsselwort	Bedeutung
`type`	erlaubter Datentyp: `object`, `array`, `string`, `number`, `integer` (Zahl ohne Nachkommaanteil), `boolean`, `null`; als Array mehrere Typen
`properties`	Beschreibung der einzelnen Felder eines Objekts
`required`	Liste der Pflichtfelder
`additionalProperties`	`false` lehnt Felder ab, die nicht unter `properties` stehen
`items`	Schema, das jedes Element eines Arrays erfüllen muss
`minItems`, `maxItems`	kleinste und größte Anzahl von Array-Elementen
`minimum`, `maximum`, `exclusiveMinimum`	Wertebereich einer Zahl
`minLength`, `maxLength`, `pattern`	Länge einer Zeichenkette, regulärer Ausdruck
`enum`	Liste der erlaubten Werte

Das Beispiel-Dokument vom Anfang des Artikels ist zu diesem Schema gültig. Dieses Dokument dagegen nicht:

{
  "station": "Infoterminal Aula",
  "id": "18",
  "aktiv": true,
  "standort": { "gebaeude": "D", "etage": 1 },
  "farbe": "blau"
}

Ein Validator meldet drei Fehler: id ist eine Zeichenkette statt einer ganzen Zahl, "D" steht nicht in der enum-Liste von gebaeude, und farbe ist ein zusätzliches Feld, das additionalProperties: false verbietet. Dass temperaturen und wartung fehlen, ist dagegen in Ordnung – sie stehen nicht unter required.

JSON Schema wird an vielen Stellen eingesetzt: Backends prüfen damit eingehende Anfragen, API-Beschreibungen (OpenAPI) legen damit Anfrage- und Antwortformate fest, Entwicklungsumgebungen bieten damit Autovervollständigung in Konfigurationsdateien, und Dokumentendatenbanken wie MongoDB weisen per $jsonSchema ungültige Dokumente zurück. Ein Schema prüft allerdings nur Struktur, Datentypen und Wertebereiche. Ob die Werte inhaltlich stimmen (gibt es den Raum wirklich? passt die Temperatur zur Jahreszeit?), muss das Programm weiterhin selbst prüfen.

Typische Missverständnisse

„JSON ist JavaScript.“ – JSON stammt aus JavaScript, ist aber ein eigenständiges, sprachunabhängiges Datenformat. Nicht jedes JavaScript-Objekt ist gültiges JSON (z. B. Schlüssel ohne Anführungszeichen, Funktionen, undefined).
„JSON darf Kommentare enthalten.“ – Nein, Kommentare sind nicht Teil des Standards.
„Zahlen in Anführungszeichen sind auch Zahlen.“ – "192" ist eine Zeichenkette. Sortieren und Rechnen funktionieren dann nicht wie erwartet.
„Die Reihenfolge der Felder ist festgelegt.“ – Nur die Reihenfolge der Array-Elemente; die Paare eines Objekts sind ungeordnet.
„Gültiges JSON heißt: Die Daten stimmen.“ – Ein Parser prüft nur die Syntax, ein JSON Schema zusätzlich Struktur und Datentypen. Ob die Inhalte stimmen, prüft beides nicht.

Leitfragen

Welche zwei Strukturen kennt JSON, und woraus bestehen sie?

Ein Objekt steht in geschweiften Klammern und enthält durch Kommas getrennte Schlüssel-Wert-Paare; der Schlüssel ist eine Zeichenkette in doppelten Anführungszeichen. Ein Array steht in eckigen Klammern und enthält eine geordnete Liste von Werten. Werte können wieder Objekte oder Arrays sein; siehe Abschnitt „Die Bausteine“.

Welche sechs Datentypen kennt JSON, und welchen Datentyp wählst Du im Programm für eine Zahl?

Zeichenkette, Zahl, Wahrheitswert, Nullwert, Objekt und Array. JSON kennt nur einen Zahlentyp; im Programm entscheidest Du nach der Bedeutung, z. B. int für Stückzahlen, double für Messwerte und BigDecimal für Geldbeträge; siehe Abschnitt „Die sechs Datentypen“.

Welche Syntaxregeln werden am häufigsten verletzt?

Schlüssel und Zeichenketten müssen in doppelten Anführungszeichen stehen, nach dem letzten Element folgt kein Komma, Zahlen haben einen Dezimalpunkt, Kommentare sind verboten, true, false und null werden klein geschrieben, und Anführungszeichen in Zeichenketten werden mit \" maskiert; siehe Abschnitt „Typische Fehler in JSON“.

Wie notierst Du Datum und Uhrzeit in JSON, und warum?

Als Zeichenkette im Format ISO 8601, z. B. "2027-03-13T10:00:00+01:00", weil JSON keinen Datumstyp hat. Das Format ist eindeutig, als Text sortierbar und wird von allen gängigen Datumsbibliotheken eingelesen; der Zeitzonenabstand verhindert Fehler zwischen Zeitzonen und bei der Zeitumstellung; siehe Abschnitt „Datum und Uhrzeit“.

Wie sprichst Du in einem verschachtelten Dokument das dritte Element eines Arrays oder ein Feld in einem eingebetteten Objekt an?

Über einen Pfad: Schlüssel mit Punkten verbinden, Array-Elemente über den Index in eckigen Klammern ansprechen, der bei 0 beginnt – das dritte Element ist also [2], z. B. temperaturen[2] oder in JSONPath $.temperaturen[2]; ein Feld in einem eingebetteten Objekt z. B. standort.etage; siehe Abschnitt „Auf verschachtelte Werte zugreifen“.

Was prüft ein JSON-Parser, was ein JSON Schema, und was prüfen beide nicht?

Der Parser prüft nur die Syntax. Ein JSON Schema prüft zusätzlich Pflichtfelder (required), Datentypen (type), Wertebereiche (minimum, enum …) und unerlaubte Zusatzfelder (additionalProperties). Ob die Inhalte fachlich stimmen, prüfen beide nicht; das bleibt Aufgabe des Programms; siehe Abschnitt „Inhalt prüfen mit JSON Schema“.

Links und weitere Informationen

Voraussetzungen und verwandte Beiträge auf oer-informatik.de: Datenaustauschformate: CSV, XML und JSON vergleichen, EBNF und Syntaxdiagramme, Einstieg in XML, NoSQL und Dokumentendatenbanken (Document Stores), REST-Grundlagen
Übungen: Übungsaufgaben zu JSON
Standard: RFC 8259: The JavaScript Object Notation (JSON) Data Interchange Format und ECMA-404
für den Einstieg: json.org – Syntaxdiagramme auf Deutsch
zum Vertiefen: JSON Schema – Dokumentation und Einstieg und RFC 9535: JSONPath

Hinweis zur Nachnutzung als Open Educational Resource (OER)

Dieser Artikel und seine Texte, Bilder, Grafiken, Code und sonstiger Inhalt sind - sofern nicht anders angegeben - lizenziert unter CC BY 4.0. Nennung gemäß TULLU-Regel bitte wie folgt: “JSON: Syntax, Datentypen und Prüfung” von oer-informatik.de (H. Stein), Lizenz: CC BY 4.0. Der Artikel wurde unter https://oer-informatik.de/json veröffentlicht, die Quelltexte sind in weiterverarbeitbarer Form verfügbar im Repository unter https://gitlab.com/oer-informatik/datenformate/xml. Erstellt mit KI-Assistenz; von mir umfassend redaktionell überarbeitet, geprüft und freigegeben. Stand: 28.10.2026.

[Kommentare zum Artikel lesen, schreiben] / [Artikel teilen] / [gitlab-Issue zum Artikel schreiben]

JSON: Syntax, Datentypen und Prüfung