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

> Erhalte eine Push-Benachrichtigung aufs Handy, sobald eine Zeile in deiner Supabase-Datenbank landet. Eine Database Webhook ganz ohne Code für neue Registrierungen und Bestellungen, dann ein Postgres-Trigger mit pg_net für Statusänderungen, Prioritätsstufen und einen Button, der die Tabelle öffnet.

*24.10.2026*

<!-- source: https://pocketalert.app/de/blog/supabase-push-notifications -->

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](/get-app)-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](/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:

```json
{
  "type": "INSERT",
  "table": "orders",
  "schema": "public",
  "record": { "id": 1042, "email": "ana@example.com", "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:

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

Die nächste Bestellung kommt dann so an:

> **Webhook Supabase**
> New orders row: #1042 · ana@example.com · $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:

```text
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](/account/apikeys) 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:

```sql
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:

```sql
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:

```sql
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`:

```ts
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:

```sql
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](/use-cases/database-alerts) und [Registrierungs-Benachrichtigungen](/use-cases/signup-alerts).

### Muss ich den Webhook von Supabase verwenden?

Nein. Alles, was JSON per POST senden kann, kann einen [Pocket-Alert-Webhook](/tools/webhook) nutzen, und alles, was einen HTTP-Aufruf machen kann, kann die API verwenden.

[Erstelle ein kostenloses Konto](/signup), verbinde eine Tabelle damit, und die nächste Registrierung erscheint auf deinem Sperrbildschirm.
