Zurück zum Blog

Supabase Push-Benachrichtigungen: eine Push-Nachricht aufs Handy für jede neue Registrierung oder Bestellung

Supabase Push-Benachrichtigungen: eine Push-Nachricht aufs Handy für jede neue Registrierung oder Bestellung

Deine App läuft auf Supabase, und die Momente, die dich interessieren, sind Zeilen: ein neuer Nutzer in auth.users, eine neue Bestellung in orders, ein Abo, das auf canceled springt. Du erfährst davon, wenn du den Table Editor öffnest, an einem guten Tag am Abend, an einem stressigen Tag erst nächste Woche.

Supabase kann dir früher Bescheid geben. Jede Tabelle kann eine URL aufrufen, wenn eine Zeile eingefügt, geändert oder gelöscht wird. Richte diesen Aufruf auf Pocket Alert, und jedes Ereignis wird zu einer Push-Benachrichtigung auf deinem Handy, mit E-Mail-Adresse oder Bestellsumme im Text.

Diese Anleitung ist dafür gedacht, dich als Gründer oder Admin zu benachrichtigen. Wenn du Push-Benachrichtigungen an die Nutzer deiner eigenen App senden willst, ist das Aufgabe für FCM, APNs oder Expo und ein anderer Artikel.

Was du brauchst

  • Ein Supabase-Projekt, das du im Dashboard öffnen kannst.
  • Ein Pocket-Alert-Konto und die App auf deinem iPhone oder Android-Handy. Für den Einstieg reicht der kostenlose Tarif.

Wenn du deine App mit Lovable gebaut und dein eigenes Supabase-Projekt verbunden hast, gilt alles Folgende. Bei Lovable Cloud (dem eingebauten Backend) gibt es kein Supabase-Dashboard, deshalb hat Stufe 1 dort keinen Ort. Der SQL-Editor dort (Database → Manage → SQL editor) unterstützt pg_net und Vault, daher sind die Trigger aus Stufe 2 dort der Weg, den du ausprobieren kannst.

Stufe 1: eine Database Webhook, ohne Code

Supabase Database Webhooks senden einen HTTP-Request, nachdem sich eine Zeile in einer Tabelle geändert hat. Pocket-Alert-Webhooks nehmen JSON entgegen und machen daraus eine Push-Benachrichtigung. Die beiden zu verbinden dauert ein paar Minuten und kommt ohne Code aus.

Den Pocket-Alert-Webhook anlegen

Öffne Webhooks in der Pocket-Alert-Konsole und lege einen an:

  • Name: Supabase. Der Push-Titel lautet immer Webhook <name>, dieser kommt also als „Webhook Supabase“ an. Nimm einen genaueren Namen, etwa Supabase signups, wenn du mehrere planst.
  • Nachricht: die Vorlage, dazu weiter unten mehr.

Kopiere die URL, die die Konsole anzeigt. Sie sieht etwa so aus: https://p4a.me/wh/abc123xyz. Der Slug am Ende ist das einzige Geheimnis, also behandle die gesamte URL wie ein Passwort.

Den Supabase-Webhook anlegen

Öffne im Supabase-Dashboard dein Projekt und geh zu Integrations → Database Webhooks (ältere Anleitungen nennen das Database → Webhooks). Falls die Integration noch nicht aktiviert ist, aktiviere sie zuerst; dabei wird die Trigger-Funktion erstellt, die die Webhooks nutzen. Lege dann einen neuen Webhook an:

  1. Gib ihm einen Namen, zum Beispiel notify_new_order.
  2. Wähle die Tabelle, zum Beispiel orders.
  3. Hake die Ereignisse an. Für Benachrichtigungen über neue Zeilen hakst du nur Insert an.
  4. Wähle HTTP Request als Typ, die Methode POST und füge die Pocket-Alert-URL ein.
  5. Lass den Header Content-Type: application/json unverändert. Pocket Alert akzeptiert nur JSON-Bodies.

Speichere. Ab jetzt sendet jedes Insert in orders einen Request, nachdem die Zeile geschrieben wurde. Supabase baut diese Requests mit der Erweiterung pg_net, die asynchron arbeitet, sodass ein langsamer Netzwerkaufruf das Insert selbst nie aufhält.

Was Supabase sendet

Der Body hat für jede Tabelle dieselbe Struktur:

{
  "type": "INSERT",
  "table": "orders",
  "schema": "public",
  "record": { "id": 1042, "email": "[email protected]", "total": 49, "status": "pending" },
  "old_record": null
}

record ist die neue Zeile mit allen Spalten. Bei UPDATE enthält old_record die Zeile so, wie sie vorher war; bei DELETE ist record null und nur old_record ist gefüllt.

Die Nachrichtenvorlage

Zurück im Pocket-Alert-Webhook schreibst du die Nachricht mit %path%-Platzhaltern, die auf dieses JSON zeigen:

New %table% row: #%record.id% · %record.email% · $%record.total%

Die nächste Bestellung kommt dann so an:

Webhook Supabase
New orders row: #1042 · [email protected] · $49

Nimm jede Spalte, die deine Tabelle hat: %record.plan%, %record.country%, %record.status%. Ein * statt einer Vorlage sendet das gesamte JSON, was hilft, solange du die Spaltennamen noch herausfindest.

Dasselbe Formular hat eine Standardstufe. Setze high auf einem Orders-Webhook, damit er den Fokus auf dem iPhone durchbricht, oder low auf einer stark frequentierten Tabelle, die du nur im Verlauf sehen willst. Die Supabase-Payload hat kein level-Feld, deshalb entscheidet der Standardwert des Webhooks.

Registrierungen aus auth.users

Supabase speichert Nutzer in auth.users, und der Tabellen-Auswahldialog der Database Webhooks kann diese Tabelle auswählen: Integrationen wie Loops dokumentieren genau diese Einrichtung. Wähle die Nutzertabelle im Schema auth, hake Insert an und verwende:

New signup: %record.email%

Falls die Auth-Tabellen in deiner Auswahl nicht auftauchen oder du die Logik lieber in SQL behalten willst, funktioniert der Trigger im nächsten Abschnitt auch auf auth.users.

Wo Stufe 1 an ihre Grenzen stößt

Eine Database Webhook hat keine Bedingung. Hakst du bei orders Update an, bekommst du jedes Mal eine Push-Benachrichtigung, wenn sich irgendeine Spalte ändert: der Status, die Lieferadresse, ein updated_at, das ein Hintergrundjob berührt. Die Vorlage kann keinen Request überspringen, sie formatiert ihn nur. Bei einer stark frequentierten Tabelle ist das bestenfalls Rauschen und schlimmstenfalls verbraucht es vor dem Mittagessen die 50 Nachrichten pro Tag des kostenlosen Tarifs.

Für „sag mir Bescheid, wenn eine Bestellung bezahlt ist“ oder „sag mir Bescheid, wenn ein Abo gekündigt wird“ brauchst du einen Filter, und Postgres hat bereits einen.

Stufe 2: ein Trigger mit pg_net und einer WHEN-Bedingung

Eine Database Webhook ist ein Trigger, der pg_net für dich aufruft. Wenn du den Trigger selbst schreibst, bekommst du zwei Dinge: eine WHEN-Klausel, sodass Postgres nur bei den Änderungen feuert, die dich interessieren, und volle Kontrolle über den Request, sodass du die Pocket-Alert-API direkt mit eigenem Titel, eigener Stufe und eigenen Buttons aufrufen kannst.

Den API-Schlüssel in Vault speichern

Hol dir einen API-Schlüssel unter API Keys und speichere ihn im SQL-Editor in Supabase Vault. Führe das einmal aus, außerhalb deiner Migrationen, damit der Schlüssel nie in einer Datei landet:

select vault.create_secret('YOUR_POCKETALERT_API_KEY', 'pocketalert_key');

Stell sicher, dass pg_net unter Database → Extensions aktiviert ist. Projekte mit Database Webhooks haben es bereits.

Die Funktion und der Trigger

Das sendet nur dann eine Push-Benachrichtigung, wenn der Status einer Bestellung auf paid wechselt:

create or replace function public.notify_order_paid()
returns trigger
language plpgsql
security definer
set search_path = ''
as $$
begin
  perform net.http_post(
    url := 'https://api.pocketalert.app/v1/messages',
    headers := jsonb_build_object(
      'Content-Type', 'application/json',
      'Token', (select decrypted_secret from vault.decrypted_secrets where name = 'pocketalert_key')
    ),
    body := jsonb_build_object(
      'title', 'Order paid: $' || new.total,
      'message', '#' || new.id || ' · ' || coalesce(new.email, 'no email'),
      'level', 'high',
      'actions', jsonb_build_array(jsonb_build_object(
        'type', 'view',
        'label', 'Open orders',
        'value', 'https://supabase.com/dashboard/project/YOUR_PROJECT_REF/editor'
      ))
    )
  );
  return new;
end;
$$;

create trigger on_order_paid
after update of status on public.orders
for each row
when (old.status is distinct from new.status and new.status = 'paid')
execute function public.notify_order_paid();

Was die einzelnen Teile tun:

  • when (...) ist der Filter, der in Stufe 1 fehlte. Postgres ruft die Funktion überhaupt nur auf, wenn sich der Status tatsächlich geändert hat und der neue Wert paid ist. Änderungen an anderen Spalten kosten nichts.
  • security definer erlaubt der Funktion, Vault zu lesen. Die Rollen, die aus deiner App Zeilen schreiben, etwa authenticated, dürfen das nicht, und ohne diese Angabe würden ihre Updates mit einem Berechtigungsfehler scheitern. Das ist das Muster aus der Supabase-Dokumentation.
  • net.http_post stellt den Request in die Warteschlange und kehrt sofort zurück; gesendet wird er, nachdem die Transaktion committet wurde. Wird das Update zurückgerollt, geht keine Push-Benachrichtigung raus.
  • level bestimmt, wie laut sie ankommt: default für Routineereignisse, high, um den Fokus zu durchbrechen, critical für die, die dich wecken sollen. Critical ist eine kostenpflichtige Funktion; im kostenlosen Tarif wird sie als high zugestellt.

Kopiere die Funktion für andere Ereignisse und ändere die Bedingung: new.status = 'canceled' bei subscriptions, new.total > 500 bei einem Insert-Trigger für große Bestellungen, new.role = 'admin' bei profiles.

Registrierungen über einen Trigger auf auth.users

Dasselbe Muster auf auth.users, mit dem Anmeldeanbieter im Text:

create or replace function public.notify_new_signup()
returns trigger
language plpgsql
security definer
set search_path = ''
as $$
begin
  perform net.http_post(
    url := 'https://api.pocketalert.app/v1/messages',
    headers := jsonb_build_object(
      'Content-Type', 'application/json',
      'Token', (select decrypted_secret from vault.decrypted_secrets where name = 'pocketalert_key')
    ),
    body := jsonb_build_object(
      'title', 'New signup',
      'message', coalesce(new.email, 'no email') || ' via ' || coalesce(new.raw_app_meta_data ->> 'provider', 'unknown')
    )
  );
  return new;
end;
$$;

create trigger on_auth_user_created_notify
after insert on auth.users
for each row execute function public.notify_new_signup();

Supabase warnt, dass ein fehlschlagender Trigger auf auth.users Registrierungen blockieren kann. Die coalesce-Aufrufe sorgen dafür, dass ein fehlender Wert die Zeichenkette nicht zerstört, und der Request selbst ist asynchron, sodass eine langsame oder fehlgeschlagene Push-Benachrichtigung die Registrierung nicht behindert. Teste es trotzdem einmal mit einem Wegwerfkonto, bevor du dich darauf verlässt.

Oder eine Edge Function

Wenn dir TypeScript lieber ist als PL/pgSQL, behalte die Database Webhook aus Stufe 1, setze ihren Typ auf Supabase Edge Functions und füge den Header für den geheimen Schlüssel hinzu, den das Formular anbietet. Die Funktion bekommt dieselbe Payload {type, table, record, old_record} und entscheidet selbst. Supabases Muster für Aufrufe mit dem geheimen Schlüssel ist der withSupabase-Wrapper mit auth: 'secret', plus verify_jwt = false für die Funktion in supabase/config.toml:

import { withSupabase } from "npm:@supabase/server@1";

export default {
  fetch: withSupabase({ auth: "secret" }, async (req) => {
    const { type, record, old_record } = await req.json();
    if (type !== "UPDATE" || record.status === old_record.status) {
      return new Response("skipped");
    }

    await fetch("https://api.pocketalert.app/v1/messages", {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        Token: Deno.env.get("POCKETALERT_API_KEY")!,
      },
      body: JSON.stringify({
        title: `Order #${record.id}: ${record.status}`,
        message: `${record.email} · $${record.total}`,
        level: record.status === "refunded" ? "high" : "default",
      }),
    });
    return new Response("ok");
  }),
};

Setze den Schlüssel mit supabase secrets set POCKETALERT_API_KEY=.... Der Nachteil: Der Webhook feuert trotzdem bei jedem Update, und die Funktion filtert erst danach, du zahlst also für jeden Aufruf. Der WHEN-Trigger filtert, bevor überhaupt etwas läuft.

Ehrliche Grenzen

  • Keine Signaturprüfung. Pocket Alert prüft nicht, woher ein Webhook-Request kommt; der URL-Slug ist das Geheimnis. Wenn dir das wichtig ist, nimm den Trigger aus Stufe 2, der sich mit deinem API-Schlüssel authentifiziert.
  • Der Schlüssel liegt kurz in einer Warteschlangentabelle. Supabase weist darauf hin, dass pg_net den entschlüsselten Header in net.http_request_queue behält, bis der Request rausgeht, und jede Rolle, die sich an der Datenbank anmelden kann, ihn dort lesen kann.
  • pg_net arbeitet nach bestem Bemühen. Requests liegen in ungeloggten Tabellen, ein Absturz im falschen Moment kann also einen verlieren. Gut für „sag mir Bescheid“, nicht für Abrechnung.
  • Volumen. Ein Trigger auf einer Tabelle mit Tausenden Schreibvorgängen pro Stunde verschickt Tausende Push-Benachrichtigungen, es sei denn, die Bedingung ist eng gefasst. Der kostenlose Tarif erlaubt 50 Nachrichten am Tag.

Wenn nichts ankommt

  • Prüfe den Verlauf des Pocket-Alert-Webhooks. Jeder Request an die Webhook-URL wird in der Konsole mit Headern, Body, der gerenderten Nachricht und dem Status protokolliert. Ist der Request dort, hat Supabase seinen Teil erledigt und das Problem liegt in der Vorlage. Ist er nicht dort, schau dir Supabase an.
  • Prüfe, was pg_net zurückbekommen hat. Antworten werden sechs Stunden lang aufbewahrt:
select status_code, content, error_msg, created
from net._http_response
order by created desc
limit 10;

Ein 401 bedeutet, dass der API-Schlüssel in Vault falsch ist; ein 400 heißt meist, dass der Body kein gültiges JSON ist oder ein Feld fehlt.

  • Prüfe die Trigger-Bedingung. Führe von Hand ein Update aus, das passen sollte, etwa update orders set status = 'paid' where id = 1042;, und schau dir danach erneut net._http_response an.
  • Prüfe das Ereignis. Ein Webhook, der nur auf Insert hört, feuert bei Updates nicht, und bei DELETE sind die %record.*%-Platzhalter leer, weil die Zeile in old_record liegt.

FAQ

Ist das dasselbe wie Push-Benachrichtigungen an die Nutzer meiner App zu senden?

Nein. Das sendet Push-Benachrichtigungen an dein eigenes Handy über die Pocket-Alert-App. Push-Benachrichtigungen an die Geräte deiner Nutzer laufen über FCM, APNs oder einen Dienst wie Expo, die deine App selbst einbinden muss.

Kann ich Supabase-Datenbank-Webhooks nur für eine Spalte nutzen?

Nicht mit dem Dashboard-Webhook; er feuert bei jeder Änderung an der Zeile. Ein Trigger mit after update of status und einer WHEN-Bedingung, wie in Stufe 2, feuert nur dann, wenn sich genau diese Spalte so ändert, wie du es beschreibst.

Funktioniert das im kostenlosen Supabase-Tarif?

Database Webhooks, Trigger, pg_net und Vault gehören alle zu einem normalen Supabase-Projekt, hier wird also kein kostenpflichtiger Supabase-Tarif benötigt.

Kann ich verschiedene Tabellen an verschiedene Ziele schicken?

Ja. Lege pro Tabelle einen Pocket-Alert-Webhook an, jeweils mit eigenem Namen, eigener Vorlage und eigener Stufe, oder leg sie in getrennte Anwendungen, damit Registrierungen und Bestellungen in der App in getrennten Kanälen landen. Weitere Ideen findest du bei Datenbank-Benachrichtigungen und Registrierungs-Benachrichtigungen.

Muss ich den Webhook von Supabase verwenden?

Nein. Alles, was JSON per POST senden kann, kann einen Pocket-Alert-Webhook nutzen, und alles, was einen HTTP-Aufruf machen kann, kann die API verwenden.

Erstelle ein kostenloses Konto, verbinde eine Tabelle damit, und die nächste Registrierung erscheint auf deinem Sperrbildschirm.

Artikel teilen