JSON vs. Token: Was ist besser für IoT?

Wenn wir im Internet über Smart-Home oder IoT sprechen, denken viele zuerst an WLAN, Sensoren, ESP32-Boards oder an schicke Apps. Was jedoch fast niemand bedenkt: Wie die Daten übertragen werden, entscheidet am Ende darüber, wie stabil, sparsam und zuverlässig ein Projekt wirklich läuft.

Und genau hier liegt eine der größten Überraschungen für Einsteiger:

👉 Je kleiner das Datenpaket, desto länger hält die Batterie
und desto stabiler läuft dein Mikrocontroller.

Das klingt banal – doch es ist einer der wichtigsten Grundsätze in der IoT-Welt. Besonders bei kleinen Mikrocontrollern wie dem Arduino UNO, ESP8266 oder sogar energieoptimierten ESP32-C3 Modellen zählt jedes Byte. Größere Datenstrukturen bedeuten:

• mehr Rechenzeit
• mehr Energieverbrauch
• höheres Risiko für Abstürze
• längere Übertragungszeiten (z. B. bei ESP-NOW, LoRa, BLE)

Viele Maker verwenden ganz selbstverständlich JSON, weil es überall bekannt ist – vom Web über REST-APIs bis hin zu MQTT-Brokern. JSON ist lesbar, flexibel und beliebt – aber:
Für kleine Mikrocontroller ist JSON oft viel zu schwer.

JSON erzeugt unnötig große Datenpakete, beansprucht wertvollen RAM und führt bei Ultraspar- oder Batteriegeräten schnell zu Problemen. In meinem Fall zeigten viele Tests auf Arduino- und ESP32-Geräten:
JSON ist bequem – aber ineffizient.

TOON – Token-Oriented Object Notation

Ein extrem leichtgewichtiges Datenformat, das komplett ohne Strings oder Klammern auskommt. Stattdessen werden Informationen als kompakte Token übertragen – perfekt für IoT, Sensoren und energiearme Systeme.

TOON erzeugt ultrakleine Datenpakete, die:

• weniger Speicher brauchen
• schneller übertragen werden
• stabiler laufen
• ideale Batterielaufzeiten ermöglichen

In diesem Beitrag zeige ich dir, wie extrem groß der Unterschied zwischen JSON und TOON ist – und warum ein simples 10-Byte-Tokenformat deine IoT-Projekte spürbar verbessert.

JSON vs. TOON – ein konkretes Beispiel

Damit wir besser verstehen, wie TOON funktioniert, schauen wir uns ein einfaches JSON-Beispiel an, das viele aus dem IoT-Umfeld kennen:

{"temp":24.4, "humidity":45}

Dieses JSON enthält zwei Werte:

• Temperatur: 24.4 °C
• Relative Luftfeuchtigkeit: 45 %

JSON ist leicht lesbar – aber es ist groß, benötigt Strings, benötigt Parser und erzeugt unerwartet viel Overhead.
TOON geht einen ganz anderen Weg: Token statt Text, und Integer statt Float.

1. Werte für TOON komprimieren

Um ein ultrakompaktes, maschinenfreundliches Format zu erhalten, werden die Messwerte in einfache Integer umgerechnet:

24.4 °C → 244  (INT16, 0.1°C Schritte)
45 %    → 450  (UINT16, 0.1% Schritte)

Damit bleiben sie präzise, aber deutlich leichter zu übertragen und zu verarbeiten.

2. Tokens für die Werte definieren

Jeder Wert bekommt einen Token, also ein einzelnes Byte, das aussagt, welcher Datentyp folgt:

Token	Bedeutung
0x01	Temperatur (0.1 °C)
0x02	Luftfeuchtigkeit (0.1 % rF)

Zusätzlich erhält der gesamte Datenblock einen Frame-Typ:

Byte	Bedeutung
0x10	Frame-Typ „Environmental Data“

3. TOON-Frame aufbauen

Ein TOON-Frame hat eine kompakte feste Struktur:

Byte	Bedeutung
0	STX (Start, hier 0xAA)
1	Länge des Inhalts
2	Frame-Typ (0x10)
3	Token Temperatur
4–5	Temperaturwert (INT16, Big Endian)
6	Token Luftfeuchte
7–8	Feuchtewert (UINT16)
9	XOR-Checksumme

4. Finaler TOON-Frame

Wir setzen alles zusammen:

• Temperatur 244 → 00 F4
• Luftfeuchte 450 → 01 C2
• Checksumme berechnet sich über alle Bytes 0–8 → 0x89

TOON-Frame:

AA 07 10 01 00 F4 02 01 C2 89

JSON vs. TOON im Klartext

Format	Länge	Beispiel
JSON	~30 Bytes	{"temp":24.4,"humidity":45}
TOON	10 Bytes	AA 07 10 01 00 F4 02 01 C2 89

• TOON ist über 3× kleiner
• Keine Strings, keine Parser, kein Overhead
• Perfekt für IoT, Batteriegeräte und kleine Mikrocontroller

ESP-NOW: JSON vs. TOON im Geschwindigkeitstest

Nachdem wir uns angesehen haben, wie unterschiedlich JSON und TOON aufgebaut sind, wird es Zeit für einen praktischen Vergleich.
Dazu habe ich zwei ESP32 miteinander kommunizieren lassen und die Daten eines DHT11-Sensors übertragen:

• einmal als JSON
• einmal als TOON-Tokenformat

Ziel war es herauszufinden:

• Wie groß sind die Datenpakete?
• Wie lange dauert das Erstellen des Pakets?
• Wie lange dauert der Sendebefehl über ESP-NOW?

Um faire Werte zu erhalten, wurde jede Variante mehrfach gemessen und anschließend gemittelt.

Der Output auf im seriellen Monitor der Arduino IDE sieht nach der Messung wiefolgt aus:

Neue Messreihe:
  Temperatur: 20.0 °C, Luftfeuchte: 49.0 % rF
--------------------------------------------------
Encoder: JSON
  Iterationen: 10
  Payload-Größe: 29 Bytes
  Build-Zeit (Ø): 225 µs
  Send-Zeit (Ø): 268 µs
--------------------------------------------------
Encoder: TOON
  Iterationen: 10
  Payload-Größe: 10 Bytes
  Build-Zeit (Ø): 6 µs
  Send-Zeit (Ø): 109 µs

Quellcode für die Mikrocontroller

Auf dem GitHub Repository https://github.com/StefanDraeger/esp_toon_sample findest du den Code für den Empfänger / Sender und für das Benchmark.

Aufbau der Schaltung

Für die Schaltung verwende ich einen ESP32-C3 Super Mini* als Sender und einen ESP32-S3 Zero* von Waveshare. Zusätzlich noch einen DHT11 Sensor* und eine blaue 5mm LED* mit 220 Ohm Vorwiderstand*.

Hinweis von mir: Die mit einem Sternchen (*) markierten Links sind Affiliate-Links. Wenn du über diese Links einkaufst, erhalte ich eine kleine Provision, die dazu beiträgt, diesen Blog zu unterstützen. Der Preis für dich bleibt dabei unverändert. Vielen Dank für deine Unterstützung!

Fazit

Der direkte Vergleich zeigt sehr deutlich:
JSON ist komfortabel – aber für IoT nicht effizient genug.

Gerade bei kleinen Mikrocontrollern, batteriebetriebenen Sensoren und schnellen Funktechnologien wie ESP-NOW zählt jedes einzelne Byte. Und genau hier spielt TOON seine größten Stärken aus. Das Token-Format erzeugt ultrakleine Datenpakete, benötigt kaum Rechenzeit und reduziert die gesamte Airtime spürbar.

Im praktischen Test war TOON:

• 3× kleiner als JSON
• über 37× schneller beim Erzeugen des Datenpakets
• 2,5× schneller beim Verschicken über ESP-NOW

Diese Werte machen in realen Projekten einen messbaren Unterschied.
Weniger CPU-Zeit bedeutet weniger Energieverbrauch.
Kleinere Pakete bedeuten stabilere Übertragung.
Und ein einfaches Binärformat macht den Mikrocontroller insgesamt robuster.

Mein Fazit:
Wer Sensorwerte effizient, stabil und energiesparend übertragen möchte, kommt an TOON nicht vorbei. JSON bleibt sinnvoll für APIs, Serverkommunikation oder Debugging – aber im Low-Power-IoT-Bereich ist TOON klar die bessere Wahl.

Mit nur 10 Byte pro Nachricht zeigt dieses Mini-Format eindrucksvoll, wie viel Potenzial in optimierten Datenstrukturen steckt – und wie stark davon gerade kleine Mikrocontroller profitieren.

Ausblick: TOON im echten Einsatz – Daten auf einem ePaper-Display

In diesem Beitrag haben wir uns vor allem auf die Theorie und die Benchmarks konzentriert. Doch TOON zeigt sein wahres Potenzial erst dann, wenn man es in einem realen IoT-Projekt einsetzt. Genau das steht als Nächstes auf meiner Liste.

Ich plane ein kleines, aber spannendes Folgeprojekt, bei dem:

• zwei ESP32 miteinander kommunizieren
• Sensorwerte im TOON-Format übertragen werden
• die empfangenen Daten anschließend auf einem ePaper-Display visualisiert werden

Warum ePaper?
Weil es – genau wie TOON – extrem energieeffizient ist und sich perfekt für batteriebetriebene Anwendungen eignet. Ein Display, das nur beim Aktualisieren Strom verbraucht, passt ideal zu einem Datenformat, das Mikrocontroller und Funkverbindungen maximal entlastet.

Das Ziel des Projekts wird sein:

• ultrakleine TOON-Frames senden
• echte Sensordaten live darstellen
• Akkulaufzeit optimieren
• eine Grundlage schaffen, um später komplette TOON-basierte Sensor-Netzwerke aufzubauen

Im nächsten Beitrag zeige ich dir den Aufbau, den Schaltplan, den vollständigen Code für Sender und Empfänger – und natürlich das fertige Ergebnis auf dem ePaper-Display.

Bleib dran – es wird richtig spannend!

Letzte Aktualisierung am: 19. November 2025