n8n nutzen, um Sensordaten in der Cloud zu speichern

Nachdem ich im letzten Beitrag gezeigt habe, was n8n ist und warum es sich auch im Smarthome-Bereich lohnt, wird es heute praktisch.
Ich zeige dir, wie du mit einem ESP32 und n8n Sensordaten ganz einfach in der Cloud speichern kannst – ohne eigene Authentifizierung am Mikrocontroller und ohne komplizierten Code.

n8n nutzen, um Sensordaten in der Cloud zu speichern

Dieses Video auf YouTube ansehen.

Inhaltsverzeichnis

• Idee und Ziel
• Aufbau des Beispiels
• Aufbau der Schaltung
• Programmcode für den ESP32
• ESP32 aus dem Internet erreichbar machen
  • Schritt 1: IP-Adresse des ESP32 ermitteln
  • Schritt 2: Portfreigabe in der FritzBox
    • Hinweis zur Sicherheit
  • Schritt 3: Öffentliche IP-Adresse der FritzBox ermitteln
• Aufbau des Workflows in n8n
  • Workflow im Detail
    • • Schedule Trigger – Der Zeitplaner
      • HTTP Request – Daten vom ESP32 abrufen
      • Date & Time – Zeitstempel erzeugen
  • Merge – Sensordaten und Zeitstempel zusammenführen
  • IF – Prüfung auf fehlerfreie Sensordaten
  • Google Sheets – Sensordaten speichern
• Ausblick: Telegram-Benachrichtigung bei Fehlern
• Fazit
• FAQ – Häufige Fragen zu diesem Projekt

Idee und Ziel

Der Vorteil liegt hier auf der Hand:
Ich brauche auf dem Mikrocontroller lediglich eine Schnittstelle, die mir die Sensordaten als JSON-Response anbietet – also z. B.:

{
  "temperature_c": 22.3,
  "humidity": 44.8
}

Alles Weitere übernimmt n8n.
Die Plattform holt die Daten per HTTP Request Node ab, verarbeitet sie und lädt sie anschließend z. B. in Google Sheets, Notion oder eine Datenbank in der Cloud.

Damit wird der meist umständliche Teil der Authentifizierung (z. B. OAuth2) vollständig ausgelagert.
Der Mikrocontroller muss sich nicht mehr mit API-Keys, Tokens oder HTTPS-Zertifikaten auseinandersetzen – das übernimmt n8n im Hintergrund.

Das spart enorm viel Zeit und reduziert Fehlerquellen.

Aufbau des Beispiels

Für das Beispiel verwende ich folgende Komponenten:

Komponente	Beschreibung
ESP32-S3 Zero (Waveshare)	Liest Sensordaten vom DHT11 aus und stellt sie per HTTP als JSON bereit
DHT11-Sensor	Misst Temperatur und Luftfeuchtigkeit
n8n Cloud (14-Tage-Trial)	Ruft die Daten regelmäßig ab und speichert sie in Google Sheets
Google Sheets Node	Schreibt die Messwerte zeilenweise in eine Tabelle

Der DHT11 ist direkt mit dem ESP32 verbunden.
In n8n wird anschließend ein Workflow eingerichtet, der die JSON-Daten des ESP32 alle fünf Minuten abruft und speichert.

Aufbau der Schaltung

Die Schaltung für dieses kleine Beispiel ist dank des fertigen DHT11-Bausteins sehr übersichtlich und in wenigen Minuten aufgebaut.
Du benötigst folgende Komponenten:

• ESP32-S3 Zero*
  oder ein vergleichbares ESP32-Board
• USB-C-Datenkabel*
  zum Programmieren und zur Stromversorgung
• DHT11- oder DHT22-Sensor*
  (je nach gewünschter Messgenauigkeit)
• drei Breadboardkabel*
  (männlich-männlich, 10cm)
• Breadboard mit 400 Pins*

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!

Den DHT11 & DHT22 Sensor gibt es fertig auf einer kleinen Platine oder als Baustein wo du noch zusätzlich ein 10 kOhm Widerstand benötigst. Je nach Ausführung musst du deine Schaltung anpassen.

Damit ist die Hardware bereits vollständig vorbereitet.
Der DHT11-Sensor misst nun Temperatur und Luftfeuchtigkeit und überträgt die Daten an den ESP32, der sie später als JSON ausgibt.

Programmcode für den ESP32

Nachdem die Schaltung steht, kümmern wir uns um den Code für den ESP32-S3 Zero.
Der Mikrocontroller soll die Temperatur vom DHT11-Sensor auslesen, eine WLAN-Verbindung herstellen und die Messwerte als JSON-Antwort über einen kleinen Webserver bereitstellen.

So kann n8n später diese Daten über eine einfache HTTP-Anfrage abrufen und weiterverarbeiten.

Der komplette Code sieht so aus:

/***********************************************************************************
 * Projekt: n8n nutzen, um Sensordaten in der Cloud zu speichern
 * Beschreibung:
 * Dieses Beispiel zeigt, wie der ESP32-S3 Zero Sensordaten (Temperatur & Luftfeuchtigkeit)
 * über einen DHT11-Sensor erfasst und als JSON über eine HTTP-Schnittstelle bereitstellt.
 * n8n ruft diese Daten anschließend ab und speichert sie automatisch in Google Sheets.
 *
 * Autor: Stefan Draeger
 * Webseite: https://draeger-it.blog
 * Blogbeitrag: https://draeger-it.blog/n8n-nutzen-um-sensordaten-in-der-cloud-zu-speichern/
 *
 * Hardware:
 * - ESP32-S3 Zero oder vergleichbares Board
 * - DHT11 / DHT22 Sensor
 * - Breadboard + 3 Jumperkabel
 * 
 * Bibliotheken:
 * - WiFi.h
 * - WebServer.h
 * - DHT11.h
 *
 * Stand: Oktober 2025
 ***********************************************************************************/

#include <WiFi.h>
#include <WebServer.h>
#include <DHT11.h>

// === WiFi-Zugangsdaten ===
const char* ssid = "abc";
const char* password = "12345678";

// === DHT11 an GPIO1 ===
DHT11 dht11(1);

// === Webserver auf Port 80 ===
WebServer server(80);

// === Hilfsfunktion: Temperatur auslesen ===
float readTemperatureC() {
  int temp = dht11.readTemperature();
  if (temp == DHT11::ERROR_CHECKSUM || temp == DHT11::ERROR_TIMEOUT) {
    Serial.println(DHT11::getErrorString(temp));
    return NAN;
  }
  return (float)temp;
}

// === Hilfsfunktion: Luftfeuchtigkeit auslesen ===
float readHumidity() {
  int humidity = dht11.readHumidity();
  if (humidity == DHT11::ERROR_CHECKSUM || humidity == DHT11::ERROR_TIMEOUT) {
    Serial.println(DHT11::getErrorString(humidity));
    return NAN;
  }
  return (float)humidity;
}

// === Handler für Webserver ===
void handleRoot() {
  float tempC = readTemperatureC();
  float humidity = readHumidity();

  if (isnan(tempC) || isnan(humidity)) {
    server.send(500, "application/json", "{\"error\": \"Fehler beim Lesen des DHT11 Sensors\"}");
    return;
  }

  // JSON-Antwort erstellen
  String json = "{\n";
  json += "  \"temperature_c\": " + String(tempC, 1) + ",\n";
  json += "  \"humidity\": " + String(humidity, 1) + "\n";
  json += "}";

  Serial.println(json);

  // HTTP-Antwort senden
  server.send(200, "application/json", json);
}

void setup() {
  Serial.begin(115200);
  delay(1000);
  Serial.println("\nStarte ESP32-S3 DHT11 Webserver...");

  // WLAN verbinden
  WiFi.begin(ssid, password);
  Serial.print("Verbinde mit WLAN: ");
  Serial.println(ssid);

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }

  Serial.println("\nWLAN verbunden!");
  Serial.print("IP-Adresse: ");
  Serial.println(WiFi.localIP());

  // Webserver-Routen definieren
  server.on("/get", handleRoot);
  server.begin();
  Serial.println("Webserver gestartet. Rufe im Browser die IP-Adresse + /get auf (z. B. http://192.168.x.x/get)");
}

void loop() {
  server.handleClient();
}

Ausgabe auf der Konsole:

Starte ESP32-S3 DHT11 Webserver...
Verbinde mit WLAN: FRITZBox7590GI24
...........
WLAN verbunden!
IP-Adresse: 192.168.178.131
Webserver gestartet. Rufe im Browser die IP-Adresse + /get auf (z. B. http://192.168.x.x/get)

Wenn die Daten via HTTP-Request über die Adresse abgerufen werden dann wird zusätzlich das JSON auch im seriellen Monitor der Arduino IDE ausgegeben.

ESP32 aus dem Internet erreichbar machen

Damit n8n in der Cloud die JSON-Daten vom ESP32 abrufen kann, muss der Mikrocontroller von außen erreichbar sein.
Standardmäßig ist dein ESP32 nur im lokalen Heimnetz sichtbar – deshalb muss der Zugriff über den Router (in meinem Fall eine FritzBox) freigegeben werden.

Schritt 1: IP-Adresse des ESP32 ermitteln

Nach dem Start zeigt der ESP32 im Serial Monitor die zugewiesene IP-Adresse an, zum Beispiel:

IP-Adresse: 192.168.178.42

Diese Adresse ist innerhalb deines Heimnetzwerks gültig und wird später im Router benötigt.

Schritt 2: Portfreigabe in der FritzBox

Damit der ESP32 auch aus dem Internet erreichbar ist, musst du in deiner FritzBox eine Portfreigabe einrichten:

1. Öffne die FritzBox-Oberfläche unter http://fritz.box.
2. Wechsle zu Internet → Freigaben → Portfreigaben.
3. Klicke auf Gerät für Freigaben hinzufügen.
4. Wähle dein ESP32-Gerät aus (z. B. „ESP32-S3-Zero“) oder gib die lokale IP manuell ein.
5. Erstelle eine Freigabe für Port 80 (Verwendung: HTTP-Server, Protokoll: TCP).
6. Übernehmen und speichern.

Damit ist dein ESP32 nun unter deiner öffentlichen IP-Adresse erreichbar.
Diese findest du unter Internet → Online-Monitor im Bereich DSL-Verbindung (siehe Grafik).

Hinweis zur Sicherheit

Die Portfreigabe macht den ESP32 aus dem Internet erreichbar – das bedeutet aber auch, dass theoretisch jeder die Daten abrufen könnte, wenn er die Adresse kennt.
Für Testzwecke ist das völlig in Ordnung, aber für den Dauerbetrieb solltest du:

• den Port nach den Tests wieder schließen,
• oder künftig eine authentifizierte API über n8n Webhooks verwenden.

Schritt 3: Öffentliche IP-Adresse der FritzBox ermitteln

Damit du den ESP32 später über das Internet erreichen kannst, benötigst du die öffentliche IP-Adresse deiner FritzBox.
Diese Adresse ist von außen sichtbar und leitet Anfragen über die eingerichtete Portfreigabe an deinen ESP32 weiter.

So findest du sie:

1. Melde dich in deiner FritzBox unter http://fritz.box an.
2. Wechsle zu Internet → Online-Monitor.
3. Im Bereich „DSL-Verbindung“ findest du unter „IPv4-Adresse“ deine aktuelle öffentliche IP-Adresse.

Mit dieser Adresse und der eingerichteten Portfreigabe ist dein ESP32 nun aus dem Internet erreichbar – z. B. unter:

http://80.128.78.173/get

Aufbau des Workflows in n8n

Der Workflow in n8n übernimmt alle Aufgaben automatisch: Er ruft regelmäßig die Sensordaten vom ESP32 ab, prüft sie auf Fehler und speichert sie anschließend in Google Sheets. Zusätzlich wird über Telegram eine Nachricht mit den aktuellen Messwerten versendet.

Wie immer gilt: Es gibt in der IT-Welt viele Wege, um ein Ziel zu erreichen.
Ich habe mir den Aufbau durch viel Lesen und Experimentieren selbst beigebracht – also sieh es mir nach, wenn der Workflow an der einen oder anderen Stelle noch Optimierungspotenzial hat.
Wichtig ist: Er funktioniert zu 100 % zuverlässig.

Workflow im Detail

Ausblick: Telegram-Benachrichtigung bei Fehlern

Damit haben wir den eigentlichen Use Case – das Speichern der Sensordaten des ESP32 in einem Google Sheet mit n8n – erfolgreich umgesetzt.
Die Daten werden zuverlässig erfasst, verarbeitet und automatisch protokolliert.

Ich werde diesen Teil deshalb in einem separaten Beitrag ausführlich behandeln und dort zeigen, wie du Fehler automatisch erkennen und dich direkt auf dein Smartphone benachrichtigen lassen kannst.

Fazit

Mit diesem kleinen Praxisprojekt hast du gesehen, wie einfach sich n8n mit einem ESP32 kombinieren lässt, um Sensordaten automatisch in der Cloud zu speichern – ganz ohne komplizierte Authentifizierung oder externe Skripte.
Der Mikrocontroller liefert die Messwerte, n8n übernimmt die komplette Verarbeitung, Speicherung und später sogar Benachrichtigungen.

Gerade für Maker, Entwickler und Smarthome-Fans bietet n8n eine spannende Möglichkeit, Automatisierungen umzusetzen, die sonst nur mit viel Programmieraufwand realisierbar wären.
Durch die grafische Oberfläche lassen sich Workflows schnell anpassen, erweitern und auch mit anderen Diensten verknüpfen – von Google Sheets bis Telegram oder Home Assistant.

Im nächsten Beitrag zeige ich dir, wie du mit Telegram eine Push-Benachrichtigung erhältst, sobald beim Auslesen ein Fehler auftritt – damit du jederzeit den Status deiner Sensoren im Blick behältst.
So wächst aus diesem kleinen Beispiel Schritt für Schritt eine komplette IoT-Automatisierung mit n8n.

FAQ – Häufige Fragen zu diesem Projekt

Funktioniert das Beispiel auch mit anderen Sensoren?

Ja, du kannst anstelle des DHT11 auch Sensoren wie den DHT22, BME280 oder DS18B20 verwenden.
Achte nur darauf, die verwendete Bibliothek im Code anzupassen und die JSON-Struktur entsprechend zu erweitern.

Muss ich n8n lokal installieren oder kann ich die Cloud nutzen?

Für den Einstieg reicht die n8n Cloud (14-Tage-Trial) völlig aus.
Während der Testphase kannst du bis zu 1.000 Workflow-Ausführungen kostenlos nutzen – ideal, um erste Automatisierungen auszuprobieren und eigene Szenarien zu testen.

Später kannst du n8n problemlos auf deinem Raspberry Pi 4B oder einem kleinen Server installieren, um die volle Kontrolle über deine Daten zu behalten und unbegrenzt viele Workflows auszuführen.

Ist es sicher, den ESP32 über Portfreigabe erreichbar zu machen?

Für Testzwecke ja, für den Dauerbetrieb eher nicht.
Besser ist es, später Webhooks oder MQTT zu verwenden, um Daten sicher an n8n zu übertragen.
Damit entfällt die offene Portfreigabe im Router.

Kann ich die Daten auch anderswo speichern?

Ja, n8n unterstützt über 400 Integrationen.
Du kannst die Daten z. B. in Notion, Airtable, einer MySQL-Datenbank oder sogar auf Nextcloud speichern – alles ohne zusätzlichen Code.

Letzte Aktualisierung am: 01. November 2025