{"id":29713,"date":"2026-03-19T13:38:00","date_gmt":"2026-03-19T12:38:00","guid":{"rendered":"https:\/\/contabo.com\/blog\/json-ein-vollstaendiger-guide-zu-syntax-und-datenformat-2026\/"},"modified":"2026-04-07T09:34:18","modified_gmt":"2026-04-07T07:34:18","slug":"json-ein-vollstaendiger-guide-zu-syntax-und-datenformat-2026","status":"publish","type":"post","link":"https:\/\/contabo.com\/blog\/de\/json-ein-vollstaendiger-guide-zu-syntax-und-datenformat-2026\/","title":{"rendered":"JSON \u2013 Der komplette Leitfaden zu Syntax und Datenformat 2026"},"content":{"rendered":"\n
\"JSON<\/figure>\n\n\n\n

Was du \u00fcber JSON wissen musst:<\/strong><\/h2>\n\n\n\n
    \n
  • JSON steht f\u00fcr JavaScript Object Notation – ein Klartextformat zum Speichern und Austauschen strukturierter Daten<\/li>\n\n\n\n
  • Es gibt sechs Datentypen: Zeichenfolgen, Zahlen, Booleans, null, Arrays und Objekte<\/li>\n\n\n\n
  • Die Syntaxregeln sind streng: Schl\u00fcssel m\u00fcssen Strings in doppelten Anf\u00fchrungszeichen sein, nachgestellte Kommas machen sie ung\u00fcltig, und Kommentare gibt es nicht<\/li>\n\n\n\n
  • Daten werden mit Objekten (Schl\u00fcssel\/Wert-Paaren in geschweiften Klammern) und Arrays (geordneten Listen in eckigen Klammern) strukturiert – beide k\u00f6nnen verschachtelt werden<\/li>\n\n\n\n
  • In JavaScript wandelt es JSON.parse()<\/code> einen JSON-String in ein Objekt um; JSON.stringify()<\/code> macht das Gegenteil<\/li>\n\n\n\n
  • JSON ist das Standardformat f\u00fcr REST-APIs, vor allem weil jede Sprache und jeder Browser es nativ verarbeiten kann<\/li>\n\n\n\n
  • Mit JSON Schema kannst du die erwartete Struktur eines Dokuments definieren und validieren, bevor deine Anwendung es verarbeitet<\/li>\n\n\n\n
  • JSONP ist ein veralteter Workaround f\u00fcr Cross-Origin-Probleme – in moderneren Anwendungen wurde es gr\u00f6\u00dftenteils durch CORS ersetzt<\/li>\n<\/ul>\n\n\n\n
    \n\n\n\n

    Was JSON ist und warum es wichtig ist<\/h2>\n\n\n\n

    JSON (JavaScript Object Notation) ist ein leichtgewichtiges Datenformat zum Speichern und Austauschen strukturierter Daten. Es ist ein Klartextformat, das jede gro\u00dfe Sprache nativ lesen und schreiben kann – und genau deshalb wird es fast \u00fcberall verwendet. Die Vorteile von JSON sind einfach: keine speziellen Bibliotheken, keine Konvertierungsschichten und eine Struktur, die direkt zu den Objekten passt, mit denen Entwickler ohnehin arbeiten. Douglas Crockford hat es Anfang der 2000er definiert, und heute ist es in RFC 8259 und ECMA-404 standardisiert.<\/p>\n\n\n\n

    JSON vs. XML: Die wichtigsten Unterschiede<\/h3>\n\n\n\n

    Im Vergleich zwischen JSON und XML geht es vor allem um die Wortf\u00fclle. XML umschlie\u00dft jeden Wert in \u00f6ffnenden und schlie\u00dfenden Tags; JSON verwendet Schl\u00fcssel\/Wert-Paare mit minimaler Interpunktion, und das JSON-Format passt unmittelbar zu den Datenstrukturen, mit denen du bereits in deinem Code arbeitest.<\/p>\n\n\n\n

    Hier sind die gleichen Daten in beiden Formaten:<\/p>\n\n\n\n

    XML:<\/strong><\/p>\n\n\n\n

    <user>
      <name>Alice<\/name>
      <age>30<\/age>
    <\/user><\/code><\/pre>\n\n\n\n
    JSON:<\/strong><\/p>\n\n\n\n
    {
      \"name\": \"Alice\",
      \"age\": 30
    }<\/code><\/pre>\n\n\n\n
    XML ist nach wie vor sinnvoll f\u00fcr Dokument-Markup und Unternehmenssysteme mit strengen Schemaanforderungen. Bei APIs und Konfigurationsdateien wirst du in der Praxis meist JSON begegnen.<\/p>\n\n\n\n
    JSON vs CSV und YAML<\/h3>\n\n\n\n
    Vergleicht man JSON und CSV, so kann CSV flache Tabellendaten noch gut abbilden, st\u00f6\u00dft aber bereits an seine Grenzen, wenn deine Daten irgendeine Hierarchie aufweisen. Der Vergleich zwischen JSON und YAML ist enger – YAML unterst\u00fctzt dieselben Strukturen wie JSON und erlaubt Kommentare, was f\u00fcr Konfigurationsdateien wirklich n\u00fctzlich ist, aber ein einziges falsch gesetztes Leerzeichen kann die ganze Datei unbrauchbar machen. JSON ist weniger flexibel als YAML, daf\u00fcr aber universeller unterst\u00fctzt, nachsichtiger mit Fehlern und robuster.<\/p>\n\n\n\n
    Feature<\/th>JSON<\/th>CSV<\/th>YAML<\/th><\/tr><\/thead>
    F\u00fcr Menschen lesbar<\/td>Ja<\/td>Ja<\/td>Ja<\/td><\/tr>
    Unterst\u00fctzt Datentypen<\/td>Ja<\/td>Nein<\/td>Ja<\/td><\/tr>
    Verschachtelte Daten<\/td>Ja<\/td>Nein<\/td>Ja<\/td><\/tr>
    Kommentare<\/td>Nein<\/td>Nein<\/td>Ja<\/td><\/tr>
    Native Browser-Datenanalyse<\/td>Ja<\/td>Nein<\/td>Nein<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
    Vorteile von JSON<\/h3>\n\n\n\n
    Was zeichnet JSON im Vergleich zu den Alternativen aus? Die Vorteile von JSON sind haupts\u00e4chlich praktischer Natur. Das JSON-Format wird universell unterst\u00fctzt: Browser parsen es nativ, jede Sprache bringt einen eingebauten Parser mit, und beide Seiten eines API-Aufrufs k\u00f6nnen es ohne Zwischenschritt lesen.<\/p>\n\n\n\n
    Die einzige echte Einschr\u00e4nkung: keine Kommentarsyntax. F\u00fcr Konfigurationsdateien in der Versionskontrolle ist das \u00e4rgerlich. Bei API-Payloads vermisst sie niemand.<\/p>\n\n\n\n
    \n\n\n\n
    JSON-Syntax verstehen<\/h2>\n\n\n\n
    Die JSON-Syntax hat zwei Strukturen: Objekte (Schl\u00fcssel\/Wert-Paare in geschweiften Klammern) und Arrays (geordnete Listen in eckigen Klammern). Alles andere ist ein Wert innerhalb einer dieser beiden Strukturen.<\/p>\n\n\n\n
    Die Regeln sind streng und unnachgiebig:<\/p>\n\n\n\n
      \n
    • Schl\u00fcssel m\u00fcssen Strings in doppelten Anf\u00fchrungszeichen sein<\/li>\n\n\n\n
    • Keine abschlie\u00dfenden Kommata – der Parser lehnt die gesamte Datei ab<\/li>\n\n\n\n
    • Keine Kommentare, Punkt.<\/li>\n\n\n\n
    • Paare sind durch Kommata getrennt<\/li>\n\n\n\n
    • Werte m\u00fcssen einer der sechs unterst\u00fctzten Datentypen sein<\/li>\n<\/ul>\n\n\n\n
      JSON-Schl\u00fcssel\/Wert-Paare erkl\u00e4rt<\/h3>\n\n\n\n
      Ein JSON-Objekt ist eine Sammlung von Schl\u00fcssel\/Wert-Paaren. Hier ist ein JSON-Beispiel mit typischen Server-Konfigurationsdaten:<\/p>\n\n\n\n
      {
        \"hostname\": \"server01\",
        \"port\": 8080,
        \"active\": true
      }<\/code><\/pre>\n\n\n\n
      Die JSON-Syntax bleibt immer gleich, unabh\u00e4ngig davon, was die Daten darstellen. Eine Serverkonfiguration und ein Benutzerprofil sind strukturell identisch – nur unterschiedliche Schl\u00fcssel und Werte.<\/p>\n\n\n\n
      \u00dcberblick \u00fcber die JSON-Datentypen<\/h3>\n\n\n\n
      JSON unterst\u00fctzt genau sechs Datentypen. Hier siehst du, wie jeder davon aussieht – und wo typischerweise Fehler passieren. Jedes JSON-Beispiel unten ist absichtlich minimal gehalten; in der Praxis werden diese einfach innerhalb von Objekten und Arrays verschachtelt.<\/p>\n\n\n\n
      String<\/h4>\n\n\n\n
      Ein JSON-String ist jede Folge von Unicode-Zeichen in doppelten Anf\u00fchrungszeichen. Er ist der am h\u00e4ufigsten verwendete JSON-Datentyp – und der h\u00e4ufigste Fehler besteht darin, einfache Anf\u00fchrungszeichen zu verwenden, die nicht zul\u00e4ssig sind.<\/p>\n\n\n\n
      { \"city\": \"Munich\" }<\/code><\/pre>\n\n\n\n
      Zahl<\/h4>\n\n\n\n
      JSON unterscheidet nicht zwischen Ganzzahlen und Gleitkommazahlen – beide sind nach den JSON-Datentypen-Spezifikationen einfach Zahlen. Dieses JSON-Beispiel umfasst beides:<\/p>\n\n\n\n
      { \"cores\": 8, \"price\": 6.99 }<\/code><\/pre>\n\n\n\n
      Boolean<\/h4>\n\n\n\n
      Ein JSON-Boolean ist true<\/code> oder false<\/code>. Kleinbuchstaben, keine Anf\u00fchrungszeichen – das sind die einzigen g\u00fcltigen Optionen, und das gilt konsistent f\u00fcr alle JSON-Datentypen, die Wahrheitswerte darstellen.<\/p>\n\n\n\n
      { \"enabled\": true, \"debug\": false }<\/code><\/pre>\n\n\n\n
      Null<\/h4>\n\n\n\n
      JSON null steht f\u00fcr das Fehlen eines Werts und ist ein eigener Datentyp – kein Synonym f\u00fcr einen leeren String oder die Zahl Null.<\/p>\n\n\n\n
      { \"middleName\": null }<\/code><\/pre>\n\n\n\n
      Ein Feld, das auf null<\/code> gesetzt ist, und ein Feld, das nicht existiert, sind technisch unterschiedliche Dinge. Behalte das im Hinterkopf, wenn du Parser schreibst.<\/p>\n\n\n\n
      Array<\/h4>\n\n\n\n
      Ein JSON-Array ist eine geordnete Liste von Werten in eckigen Klammern – einer der vielseitigsten JSON-Datentypen, da es Strings, Zahlen, Objekte oder andere Arrays enthalten kann.<\/p>\n\n\n\n
      { \"ports\": [80, 443] }<\/code><\/pre>\n\n\n\n
      Objekt<\/h4>\n\n\n\n
      Indem du ein JSON-Objekt in ein anderes verschachtelst, modellierst du echte hierarchische Strukturen. Es ist der ausdrucksst\u00e4rkste JSON-Datentyp und das Muster, auf dem die meisten echten API-Antworten basieren.<\/p>\n\n\n\n
      {
        \"server\": {
          \"hostname\": \"server01\",
          \"port\": 8080
        }
      }<\/code><\/pre>\n\n\n\n
      \n\n\n\n
      Wie man JSON-Daten speichert<\/h2>\n\n\n\n
      Die Wahl zwischen einem JSON-Objekt und einem JSON-Array h\u00e4ngt davon ab, ob deine Daten benannte Eigenschaften oder eine geordnete Sammlung sind. Die meisten Antworten im echten JSON-Format verwenden beide zusammen.<\/p>\n\n\n\n
      JSON-Objekte verwenden<\/h3>\n\n\n\n
      Ein JSON-Objekt eignet sich am besten f\u00fcr Daten mit benannten Eigenschaften – einen Benutzerdatensatz oder eine einzelne API-Ressource. Die JSON-Syntax ist durchweg die gleiche, und jedes JSON-Beispiel folgt demselben Schl\u00fcssel\/Wert-Muster.<\/p>\n\n\n\n
      { \"id\": 1, \"name\": \"Alice\", \"active\": true }<\/code><\/pre>\n\n\n\n
      JSON-Arrays verwenden<\/h3>\n\n\n\n
      Ein JSON-Array ist f\u00fcr geordnete Sammlungen gedacht – also \u00fcberall dort, wo du mit mehreren Instanzen derselben Struktur arbeitest. Dieses JSON-Beispiel zeigt auch, wie sich Objekte ganz nat\u00fcrlich in Arrays verschachteln lassen. Genau dieses Muster findest du in den meisten API-Antworten.<\/p>\n\n\n\n
      [
        { \"id\": 1, \"name\": \"Alice\" },
        { \"id\": 2, \"name\": \"Bob\" }
      ]<\/code><\/pre>\n\n\n\n
      Verschachtelte Objekte und Arrays in JSON<\/h3>\n\n\n\n
      JSON in der Praxis enth\u00e4lt fast immer Verschachtelungen. Ein JSON-Objekt enth\u00e4lt ein JSON-Array, dieses Array enth\u00e4lt weitere Objekte, diese Objekte enthalten weitere Werte. Die Spezifikation kennt keine Tiefenbegrenzung, auch wenn Produktions-APIs oft \u00fcberraschend tief verschachtelt sind, bevor jemand auf die Idee kommt, sie zu vereinfachen. Hier ist ein klares JSON-Beispiel:<\/p>\n\n\n\n
      {
        \"cluster\": \"eu-west\",
        \"nodes\": [
          { \"id\": \"node1\", \"status\": \"active\" },
          { \"id\": \"node2\", \"status\": \"standby\" }
        ]
      }<\/code><\/pre>\n\n\n\n
      \n\n\n\n
      Mit JSON im Code arbeiten<\/h2>\n\n\n\n
      Die beiden Funktionen, die du st\u00e4ndig brauchst, sind JSON.parse und JSON.stringify. JSON-Schema-Validierung wird wichtig, sobald du externe oder nicht vertrauensw\u00fcrdige Daten verarbeitest. Zusammen decken sie die meisten echten JSON-Szenarien in JavaScript ab.<\/p>\n\n\n\n
      JSON mit JSON.parse parsen<\/h3>\n\n\n\n
      Beim JSON.parse-Vorgang wird ein JSON-String eingelesen und als JavaScript-Objekt zur\u00fcckgegeben. Das ist der Standard-Einstiegspunkt zum Verarbeiten von API-Antworten, und jedes gute JSON-Tutorial wird dir sagen, dass du ihn in die Fehlerbehandlung einbetten solltest.<\/p>\n\n\n\n
      const data = JSON.parse('{\"name\":\"Alice\",\"age\":30}');
      console.log(data.name); \/\/ \"Alice\"<\/em><\/code><\/pre>\n\n\n\n
      Gib ein ung\u00fcltiges JSON ein, und es gibt <wpml_ignored_tag wpml_name=“code“ wpml_value=“U3ludGF4RXJyb3I=“ wpml_attrs=““\/> zur\u00fcck. Packe nicht vertrauensw\u00fcrdige Eingaben immer in einen try\/catch-Block – genau dieser Fehler taucht in Produktionslogs am h\u00e4ufigsten auf.<\/p>\n\n\n\n
      try {
        const data = JSON.parse(input);
      } catch (e) {
        console.error(\"Invalid JSON:\", e.message);
      }<\/code><\/pre>\n\n\n\n
      JSON.stringify() Methode<\/h3>\n\n\n\n
      Jedes JSON-Tutorial behandelt JSON.stringify zusammen mit JSON.parse, weil du beim Arbeiten mit APIs beide brauchst. JSON.stringify()<\/code> geht in die andere Richtung – Objekt rein, String raus.<\/p>\n\n\n\n
      const str = JSON.stringify({ name: \"Alice\", age: 30 });
      \/\/ '{\"name\":\"Alice\",\"age\":30}'<\/em><\/code><\/pre>\n\n\n\n
      Gib ein drittes Argument f\u00fcr einzur\u00fcckende Ausgaben an. Genau danach suchen die meisten, wenn sie JSON h\u00fcbsch gestalten wollen. Die JSON.stringify-Methode ist wahrscheinlich die am h\u00e4ufigsten verwendete JSON-Funktion in JavaScript.<\/p>\n\n\n\n
      JSON.stringify(obj, null, 2);<\/code><\/pre>\n\n\n\n
      JSON-Schema-Validierung<\/h3>\n\n\n\n
      JSON-Schema ist ein Vokabular zur Beschreibung der erwarteten Struktur eines JSON-Dokuments. Du definierst Pflichtfelder und die zul\u00e4ssigen JSON-Datentypen und schickst eingehende Daten dann durch einen Validator, bevor deine Anwendung sie verarbeitet.<\/p>\n\n\n\n
      {
        \"$schema\": \"http:\/\/json-schema.org\/draft-07\/schema#\",
        \"type\": \"object\",
        \"properties\": {
          \"name\": { \"type\": \"string\" },
          \"age\":  { \"type\": \"integer\", \"minimum\": 0 }
        },
        \"required\": [\"name\"]
      }<\/code><\/pre>\n\n\n\n
      Fehlerhafte Daten direkt am Einstiegspunkt abzufangen ist besser, als sie erst drei Funktionen sp\u00e4ter zu debuggen. Gerade bei API-Eingaben ist JSON-Schema-Validierung eines der am st\u00e4rksten untersch\u00e4tzten Werkzeuge im Stack.<\/p>\n\n\n\n
      \n\n\n\n
      JSON in APIs und Webanwendungen<\/h2>\n\n\n\n
      Das Standard-JSON-Format eignet sich am besten f\u00fcr REST-APIs. Wenn du einen JSON-API-Aufruf machst, kommt die Antwort fast immer als JSON-Objekt oder -Array zur\u00fcck, mit Content-Type: application\/json<\/code> im Header. Abgesehen von JSONP wickelt das Web den Austausch strukturierter Daten schon seit weit \u00fcber einem Jahrzehnt so ab.<\/p>\n\n\n\n
      Wie JSONP funktioniert<\/h3>\n\n\n\n
      JSONP (JSON with Padding) ist ein Workaround aus der Zeit vor CORS f\u00fcr Cross-Origin-Einschr\u00e4nkungen. Statt rohe JSON-API-Daten zur\u00fcckzugeben, verpackt der Server die Antwort in einen Funktionsaufruf:<\/p>\n\n\n\n
      callback({ \"name\": \"Alice\" });<\/code><\/pre>\n\n\n\n
      Der Browser l\u00e4dt es als Skript-Tag und f\u00fchrt es aus. Heute begegnet dir JSONP meist nur noch in \u00e4lteren Codebasen – zu wissen, was es ist, spart dir zwanzig Minuten Verwirrung, wenn du dar\u00fcber stolperst.<\/p>\n\n\n\n
      JSON-API-Format<\/h3>\n\n\n\n
      JSON:API ist eine formale Spezifikation zur Strukturierung der API-Antworten im JSON-Format. Es standardisiert, wie Ressourcen und Fehler im Response-Body erscheinen, sodass jeder daf\u00fcr gebaute Client jeden kompatiblen JSON-API-Endpunkt ohne eigene Parsing-Logik nutzen kann. Gut zu wissen, wenn du eine \u00f6ffentliche API baust oder mit einer gro\u00dfen API integrierst.<\/p>\n\n\n\n
      \n\n\n\n
      JSON-Merkblatt<\/h2>\n\n\n\n
      Eine Kurzreferenz zu JSON-Syntax, JSON-Datentypen und typischen JSON-Beispielmustern:<\/p>\n\n\n\n
      Element<\/th>Syntax<\/th>Beispiel<\/th><\/tr><\/thead>
      Objekt<\/td>{ \"key\": value }<\/code><\/td>{ \"name\": \"Alice\" }<\/code><\/td><\/tr>
      Array<\/td>[ value, value ]<\/code><\/td>[ 80, 443 ]<\/code><\/td><\/tr>
      String<\/td>\"text\"<\/code><\/td>\"hello\"<\/code><\/td><\/tr>
      Zahl<\/td>123<\/code> oder 1.5<\/code><\/td>8080<\/code><\/td><\/tr>
      Boolean<\/td>true<\/code> \/ false<\/code><\/td>true<\/code><\/td><\/tr>
      Null<\/td>null<\/code><\/td>null<\/code><\/td><\/tr>
      Verschachteltes Objekt<\/td>{ \"key\": { } }<\/code><\/td>{ \"server\": { \"port\": 80 } }<\/code><\/td><\/tr>
      Verschachteltes Array<\/td>{ \"key\": [ ] }<\/code><\/td>{ \"ports\": [80, 443] }<\/code><\/td><\/tr>
      Parsen (JS)<\/td>JSON.parse(str)<\/code><\/td>JSON.parse('{\"a\":1}')<\/code><\/td><\/tr>
      Stringify (JS)<\/td>JSON.stringify(obj)<\/code><\/td>JSON.stringify({ a: 1 })<\/code><\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
      \n\n\n\n
      JSON FAQ<\/h2>\n\n\n\n
      Wof\u00fcr wird JSON verwendet?<\/strong><\/strong> 
      Wozu ist JSON in der Praxis gut? Datenaustausch. Die meisten Webanwendungen verlassen sich standardm\u00e4\u00dfig auf JSON-API-Antworten, und das JSON-Format taucht in Konfigurationsdateien \u00fcberall auf, von Docker bis VS Code. Es wurde zum Standard, weil beide Enden einer Anfrage es ohne zus\u00e4tzliche Bibliotheken oder Umwandlungsschritte lesen k\u00f6nnen.<\/p> <\/div> 
      Was ist JSON-Schema?<\/strong><\/strong> 
      JSON-Schema ist ein Vokabular zur Validierung der Dokumentstruktur. Schreib ein JSON-Schema, das Pflichtfelder und erlaubte JSON-Datentypen definiert, lass eingehende Daten durch einen Validator laufen und fange fehlerhafte Payloads ab, bevor sie deine Anwendungslogik erreichen.<\/p> <\/div> 
      Was ist ein JSON-Array?<\/strong><\/strong> 
      Ein JSON-Array ist eine geordnete Liste von Werten in eckigen Klammern:  oder . Im Gegensatz zu Objekten bleibt die Reihenfolge erhalten, und ein JSON-Array kann jeden JSON-Datentyp enthalten, einschlie\u00dflich anderer Arrays und Objekte.<\/p> <\/div> 
      Wie parst man JSON?<\/strong><\/strong> 
      Das JSON-Parse-Muster ist in allen Sprachen gleich – String rein, Datenstruktur raus. In JavaScript: . Python: . PHP: . Jedes JSON-Tutorial behandelt auch die Fehlerbehandlung, da ung\u00fcltige Eingaben Fehler ausl\u00f6sen, anstatt null zur\u00fcckzugeben.<\/p> <\/div> 
      Was ist der Unterschied zwischen JSON und XML?<\/strong><\/strong> 
      Im Vergleich zwischen JSON und XML liegt der Hauptunterschied in der Wortf\u00fclle. XML umschlie\u00dft jeden Wert in benannten Tags; JSON verwendet Schl\u00fcssel\/Wert-Paare und Browser parsen es nativ. Das JSON-Format ist k\u00fcrzer und passt direkter zu den Objekten, mit denen du im Code arbeitest. XML hat bei Dokument-Markup und komplexen Namespace-Szenarien immer noch echte Vorteile, aber f\u00fcr die meisten API-Anwendungsf\u00e4lle ist JSON der Standard.<\/p> <\/div> <\/div>\n","protected":false},"excerpt":{"rendered":"
      JSON ist das Datenformat, auf dem das Web basiert. Dieser Guide deckt alles ab, von grundlegenden Syntaxregeln und Datentypen bis hin zu Parsing, JSON-Schema-Validierung und REST-APIs – durchgehend mit Codebeispielen.<\/p>\n","protected":false},"author":63,"featured_media":29205,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"inline_featured_image":false,"_uag_custom_page_level_css":"","site-sidebar-layout":"default","site-content-layout":"","ast-site-content-layout":"default","site-content-style":"default","site-sidebar-style":"default","ast-global-header-display":"","ast-banner-title-visibility":"","ast-main-header-display":"","ast-hfb-above-header-display":"","ast-hfb-below-header-display":"","ast-hfb-mobile-header-display":"","site-post-title":"","ast-breadcrumbs-content":"","ast-featured-img":"","footer-sml-layout":"","theme-transparent-header-meta":"","adv-header-id-meta":"","stick-header-meta":"","header-above-stick-meta":"","header-main-stick-meta":"","header-below-stick-meta":"","astra-migrate-meta-layouts":"set","ast-page-background-enabled":"default","ast-page-background-meta":{"desktop":{"background-color":"var(--ast-global-color-4)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"tablet":{"background-color":"","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"mobile":{"background-color":"","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""}},"ast-content-background-meta":{"desktop":{"background-color":"var(--ast-global-color-5)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"tablet":{"background-color":"var(--ast-global-color-5)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"mobile":{"background-color":"var(--ast-global-color-5)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""}},"footnotes":""},"categories":[1399],"tags":[4153,4154,4152,4149,4151,4155,4150,4156,1634],"ppma_author":[1492],"class_list":["post-29713","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-tutorials","tag-apis","tag-entwicklerhandbuch","tag-javascript","tag-json","tag-json-datentypen","tag-json-schema","tag-json-tutorial","tag-rest-api","tag-web-entwicklung"],"uagb_featured_image_src":{"full":["https:\/\/contabo.com\/blog\/wp-content\/uploads\/2026\/03\/blog-head_json-a-complete-guide-2026_DE.webp",1200,630,false],"thumbnail":["https:\/\/contabo.com\/blog\/wp-content\/uploads\/2026\/03\/blog-head_json-a-complete-guide-2026_DE-150x150.webp",150,150,true],"medium":["https:\/\/contabo.com\/blog\/wp-content\/uploads\/2026\/03\/blog-head_json-a-complete-guide-2026_DE-600x315.webp",600,315,true],"medium_large":["https:\/\/contabo.com\/blog\/wp-content\/uploads\/2026\/03\/blog-head_json-a-complete-guide-2026_DE-768x403.webp",768,403,true],"large":["https:\/\/contabo.com\/blog\/wp-content\/uploads\/2026\/03\/blog-head_json-a-complete-guide-2026_DE.webp",1200,630,false],"1536x1536":["https:\/\/contabo.com\/blog\/wp-content\/uploads\/2026\/03\/blog-head_json-a-complete-guide-2026_DE.webp",1200,630,false],"2048x2048":["https:\/\/contabo.com\/blog\/wp-content\/uploads\/2026\/03\/blog-head_json-a-complete-guide-2026_DE.webp",1200,630,false]},"uagb_author_info":{"display_name":"Christopher Carter","author_link":"https:\/\/contabo.com\/blog\/de\/author\/christophercarter\/"},"uagb_comment_info":0,"uagb_excerpt":"JSON ist das Datenformat, auf dem das Web basiert. Dieser Guide deckt alles ab, von grundlegenden Syntaxregeln und Datentypen bis hin zu Parsing, JSON-Schema-Validierung und REST-APIs - durchgehend mit Codebeispielen.","authors":[{"term_id":1492,"user_id":63,"is_guest":0,"slug":"christophercarter","display_name":"Christopher Carter","avatar_url":"https:\/\/secure.gravatar.com\/avatar\/63db81672a5ce4c1e8ee39753d00251d561b5b3a9967febf1c4f662024cef00f?s=96&d=mm&r=g","0":null,"1":"","2":"","3":"","4":"","5":"","6":"","7":"","8":""}],"_links":{"self":[{"href":"https:\/\/contabo.com\/blog\/de\/wp-json\/wp\/v2\/posts\/29713","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/contabo.com\/blog\/de\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/contabo.com\/blog\/de\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/contabo.com\/blog\/de\/wp-json\/wp\/v2\/users\/63"}],"replies":[{"embeddable":true,"href":"https:\/\/contabo.com\/blog\/de\/wp-json\/wp\/v2\/comments?post=29713"}],"version-history":[{"count":7,"href":"https:\/\/contabo.com\/blog\/de\/wp-json\/wp\/v2\/posts\/29713\/revisions"}],"predecessor-version":[{"id":29733,"href":"https:\/\/contabo.com\/blog\/de\/wp-json\/wp\/v2\/posts\/29713\/revisions\/29733"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/contabo.com\/blog\/de\/wp-json\/wp\/v2\/media\/29205"}],"wp:attachment":[{"href":"https:\/\/contabo.com\/blog\/de\/wp-json\/wp\/v2\/media?parent=29713"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/contabo.com\/blog\/de\/wp-json\/wp\/v2\/categories?post=29713"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/contabo.com\/blog\/de\/wp-json\/wp\/v2\/tags?post=29713"},{"taxonomy":"author","embeddable":true,"href":"https:\/\/contabo.com\/blog\/de\/wp-json\/wp\/v2\/ppma_author?post=29713"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}