IoT & Sensoren

Erfahre, wann ein Messwert die Grenze überschreitet.

Ein Temperatur-, Luftfeuchtigkeits-, Wassermelder-, Bewegungs-, Tür-, Strom- oder Akku-Sensor überschreitet einen Schwellenwert, und der Messwert landet auf deinem Handy – von einem ESP32, einem Raspberry Pi, Home Assistant oder Node-RED. Kein Broker und keine MQTT-Bridge nötig.

Push in <1sPasst auf einen ESP32HTTP · Node-RED · Home AssistantAktualisiert am
Funktionen

Push-Benachrichtigungen von jedem Sensor

Den Sensor hast du selbst verkabelt. Ein HTTP-Aufruf genügt, und ein Schwellenwert erreicht dein Handy, ohne dass ein Monitoring-Stack dazwischenhängt.

Passt auf einen Mikrocontroller

Ein einfaches HTTP-POST passt auf einen ESP32 oder ESP8266 und lässt noch Platz. Kein Broker, keine Bridge.

Ein Kanal pro Sensor

Eine Anwendung pro Board sorgt dafür, dass ein Wasserschaden-Alarm laut auffällt, während eine Akkumeldung ruhig bleibt.

Kanäle pro Gerät

Eine Anwendung pro Raum oder Gerät hält Garage, Kühlschrank und Gewächshaus in getrennten Kanälen.

Deine eigene Payload abbilden

Das GJSON-Feldmapping zieht Sensorname und Messwert aus dem JSON, das deine Firmware bereits sendet.

Funktioniert mit deinem Setup

Arduino, MicroPython, ein curl vom Pi, eine Home-Assistant-Automation oder ein Node-RED-Flow erreichen alle denselben Endpunkt.

Zustellung in unter einer Sekunde

Ein Schwellenwert wird überschritten, und die Push-Benachrichtigung kommt in unter einer Sekunde an, bevor ein Leck sich ausbreitet oder ein Gefrierschrank auftaut.

Los geht's

Drei Schritte zu Sensor-Alarmen

1

Token oder URL holen

Erstelle einen API-Schlüssel oder kopiere die Webhook-URL einer Anwendung für einen Raum oder ein Gerät.

2

Bei Schwellenwert auslösen

Füge den POST in deinen Arduino-HTTPClient-Sketch, dein MicroPython-Skript, deinen Pi-Cronjob oder dein HA-rest_command ein.

3

Auf dem Handy lesen

Löse den Sensor aus, und dein Handy vibriert in unter einer Sekunde, in der Anwendung für dieses Board.

Sensor anbinden

1. API-Schlüssel erstellen

Erstelle einen Schlüssel auf der Seite API-Schlüssel. Dein Board sendet ihn bei jedem POST an die Messages-API im Token-Header.

2. POST senden, wenn ein Schwellenwert überschritten wird

curl -X POST "https://api.pocketalert.app/v1/messages" \
  -H "Token: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"title":"Freezer warm","message":"garage freezer at 4.2C","application_id":"qm47b9pzxzxg"}'

3. Auf einem ESP32 oder ESP8266 (Arduino)

#include <WiFiClientSecure.h>
#include <HTTPClient.h>

WiFiClientSecure client;
client.setInsecure(); // or client.setCACert(rootCA);

HTTPClient http;
http.begin(client, "https://api.pocketalert.app/v1/messages");
http.addHeader("Token", "YOUR_API_KEY");
http.addHeader("Content-Type", "application/json");
http.POST("{\"title\":\"Water leak\",\"level\":\"critical\",\"message\":\"basement sensor wet\"}");
http.end();

4. Oder aus Home Assistant

rest_command:
  pocketalert:
    url: "https://api.pocketalert.app/v1/messages"
    method: POST
    headers:
      Token: "YOUR_API_KEY"
    content_type: "application/json"
    payload: '{"title":"{{ title }}","message":"{{ message }}"}'

Rufe rest_command.pocketalert aus einer Automation auf oder richte in Node-RED einen MQTT-zu-REST-Flow ein. Die vollständige Messages-API findest du in der Dokumentation.

FAQ

Fragen und Antworten

Dein Board sendet bei Überschreiten eines Schwellenwerts ein einziges HTTP-POST an die Messages-API. Auf einem ESP32 oder ESP8266 sind das ein paar Zeilen Arduino mit HTTPClient oder MicroPython; auf einem Raspberry Pi ist es ein curl. Die Payload enthält einen Titel und eine Nachricht, der API-Schlüssel wird im Token-Header übergeben.

Ein einfacher HTTPS-Aufruf passt problemlos auf einen ESP32, mit Speicher zum Übrigbleiben. Kein MQTT-Broker und kein Bridge-Container, um den du dich kümmern musst. Home Assistant rest_command und Node-RED funktionieren weiterhin, falls du sie bereits einsetzt.

Gib jedem Board seine eigene Anwendung, damit Gefrierschrank, Gewächshaus und Wassermelder in getrennten Kanälen landen. Formuliere den Titel so, dass ein Wasserschaden auf einen Blick deutlich auffällt, während eine Meldung zu niedrigem Akkustand in ihrer eigenen Anwendung ruhig bleibt.

Lege pro Raum oder Gerät eine Anwendung an. Garage, Kühlschrank und Gewächshaus landen jeweils in eigenen Kanälen, sodass du den Alarm lesen kannst, ohne zu rätseln, welches Board ihn gesendet hat.

Richte das GJSON-Feldmapping auf die Schlüssel, die deine Firmware bereits sendet. Sensorname und Messwert werden direkt in Titel und Nachricht übernommen, ohne dass das JSON auf dem Board umgebaut werden muss.

Ja. Füge "level":"critical" zum POST hinzu, und Android liefert sie über einen eigenen Benachrichtigungskanal aus, der Nicht stören umgeht – den DND-Zugriff erteilst du einmalig. Auf dem iPhone werden high und critical als zeitkritische Benachrichtigungen zugestellt, die den Fokus-Modus durchbrechen. Eine Meldung zu niedrigem Akkustand schickst du stattdessen als level silent: ohne Ton und Vibration, sie landet einfach im Verlauf. Im kostenlosen Tarif wird critical als high zugestellt – weiterhin sofort, aber ohne die Nicht-stören-Umgehung.

Lass dich von deinen Sensoren benachrichtigen.

Ein paar Zeilen HTTP auf deinem ESP32, und der nächste Wasserschaden erreicht dein Handy, bevor der Boden nass wird.