# Notifications push Supabase : une notification sur votre téléphone pour chaque nouvelle inscription ou commande

> Recevez une notification push sur votre téléphone dès qu'une ligne est ajoutée à votre base Supabase. Un Database Webhook sans code pour les nouvelles inscriptions et commandes, puis un trigger Postgres avec pg_net pour les changements de statut, des niveaux de priorité et un bouton qui ouvre la table.

*24.10.2026*

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

Votre application tourne sur Supabase, et les événements qui comptent sont des lignes : un nouvel utilisateur dans `auth.users`, une nouvelle commande dans `orders`, un abonnement qui passe à `canceled`. Vous les découvrez en ouvrant le Table Editor, ce qui, un bon jour, arrive le soir et, un jour chargé, la semaine suivante.

Supabase peut vous prévenir plus tôt. Chaque table peut appeler une URL lorsqu'une ligne est insérée, mise à jour ou supprimée. Dirigez cet appel vers Pocket Alert et chaque événement devient une notification push sur votre téléphone, avec l'e-mail ou le montant de la commande dans le texte.

Ce guide vous explique comment être prévenu, **vous**, le fondateur ou l'administrateur. Si vous voulez envoyer des notifications push aux utilisateurs de votre application, c'est un travail pour FCM, APNs ou Expo, et il fait l'objet d'un autre article.

## Ce dont vous avez besoin

- Un projet Supabase que vous pouvez ouvrir dans le tableau de bord.
- Un compte Pocket Alert et l'application sur votre téléphone [iPhone ou Android](/get-app). L'offre gratuite suffit pour commencer.

Si vous avez créé votre application avec Lovable et connecté votre propre projet Supabase, tout ce qui suit s'applique. Sur Lovable Cloud (le backend intégré), il n'y a pas de tableau de bord Supabase, donc le niveau 1 n'est pas accessible. Son éditeur SQL (**Database → Manage → SQL editor**) prend en charge `pg_net` et Vault : les triggers du niveau 2 sont la voie à essayer dans ce cas.

## Niveau 1 : un Database Webhook, sans code

Les Database Webhooks de Supabase envoient une requête HTTP après la modification d'une ligne dans une table. Les webhooks Pocket Alert reçoivent du JSON et le transforment en notification push. Relier les deux prend quelques minutes et ne demande aucun code.

### Créer le webhook Pocket Alert

Ouvrez [Webhooks](/webhooks) dans la console Pocket Alert et créez-en un :

- **Nom :** `Supabase`. Le titre de la notification est toujours `Webhook <name>`, donc celle-ci arrivera sous le titre « Webhook Supabase ». Utilisez un nom plus précis, comme `Supabase signups`, si vous prévoyez plusieurs webhooks.
- **Message :** le modèle, expliqué plus bas.

Copiez l'URL affichée par la console. Elle ressemble à `https://p4a.me/wh/abc123xyz`. Le segment final est le seul secret : traitez l'URL entière comme un mot de passe.

### Créer le webhook Supabase

Dans le tableau de bord Supabase, ouvrez votre projet et allez dans **Integrations → Database Webhooks** (les anciens guides parlent de Database → Webhooks). Si l'intégration n'est pas encore activée, activez-la d'abord : elle crée la fonction de trigger qu'utilisent les webhooks. Créez ensuite un nouveau webhook :

1. Donnez-lui un nom, par exemple `notify_new_order`.
2. Choisissez la table, par exemple `orders`.
3. Cochez les événements. Pour les alertes « nouvelle ligne », cochez uniquement **Insert**.
4. Choisissez **HTTP Request** comme type, la méthode `POST`, puis collez l'URL Pocket Alert.
5. Laissez l'en-tête `Content-Type: application/json` tel quel. Pocket Alert n'accepte que les corps JSON.

Enregistrez. Désormais, chaque insertion dans `orders` envoie une requête après l'écriture de la ligne. Supabase construit ces requêtes avec l'extension `pg_net`, qui est asynchrone : un appel réseau lent ne bloque jamais l'insertion elle-même.

### Ce que Supabase envoie

Le corps a la même structure pour chaque table :

```json
{
  "type": "INSERT",
  "table": "orders",
  "schema": "public",
  "record": { "id": 1042, "email": "ana@example.com", "total": 49, "status": "pending" },
  "old_record": null
}
```

`record` est la nouvelle ligne avec toutes ses colonnes. Pour `UPDATE`, `old_record` contient la ligne telle qu'elle était avant ; pour `DELETE`, `record` vaut `null` et seul `old_record` est renseigné.

### Le modèle de message

De retour dans le webhook Pocket Alert, rédigez le message avec des espaces réservés `%path%` qui pointent vers ce JSON :

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

La commande suivante arrive ainsi :

> **Webhook Supabase**
> Nouvelle ligne orders : #1042 · ana@example.com · $49

Utilisez n'importe quelle colonne de votre table : `%record.plan%`, `%record.country%`, `%record.status%`. Un `*` à la place d'un modèle envoie le JSON complet, utile le temps de retrouver les noms de colonnes.

Le même formulaire dispose d'un **niveau par défaut**. Réglez `high` sur un webhook de commandes pour qu'il passe la Concentration sur iPhone, ou `low` sur une table très active que vous voulez seulement consulter dans l'historique. La charge utile de Supabase n'a pas de champ `level` : c'est donc la valeur par défaut du webhook qui décide.

### Inscriptions depuis auth.users

Supabase stocke les utilisateurs dans `auth.users`, et le sélecteur de tables des Database Webhooks permet de la choisir : des intégrations comme Loops documentent exactement cette configuration. Choisissez la table des utilisateurs dans le schéma `auth`, cochez **Insert**, et utilisez :

```text
New signup: %record.email%
```

Si les tables d'authentification n'apparaissent pas dans le sélecteur, ou si vous préférez garder la logique en SQL, le trigger de la section suivante fonctionne aussi sur `auth.users`.

## Là où le niveau 1 atteint ses limites

Un Database Webhook n'a pas de condition. Cochez **Update** sur `orders` et vous recevez une notification à chaque modification de n'importe quelle colonne : le statut, l'adresse de livraison, un `updated_at` touché par une tâche de fond. Le modèle ne peut pas ignorer une requête ; il se contente de la formater. Sur une table très active, c'est au mieux du bruit, au pire cela consomme les 50 messages quotidiens de l'offre gratuite avant midi.

Pour « prévenez-moi quand une commande passe en payée » ou « prévenez-moi quand un abonnement est annulé », il vous faut un filtre, et Postgres en propose déjà un.

## Niveau 2 : un trigger avec pg_net et une condition WHEN

Un Database Webhook est un trigger qui appelle `pg_net` à votre place. Écrire le trigger vous-même vous apporte deux choses : une clause `WHEN`, pour que Postgres ne se déclenche que sur les changements qui vous intéressent, et un contrôle total sur la requête, pour appeler directement l'API Pocket Alert avec votre propre titre, votre niveau et vos boutons.

### Stocker la clé API dans Vault

Obtenez une clé API dans [Clés API](/account/apikeys) et stockez-la dans Supabase Vault depuis le SQL Editor. Exécutez cette commande une seule fois, en dehors de vos migrations, pour que la clé ne se retrouve jamais dans un fichier :

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

Vérifiez que `pg_net` est activé dans **Database → Extensions**. Les projets qui utilisent les Database Webhooks l'ont déjà.

### La fonction et le trigger

Ce code n'envoie une notification que lorsque le statut d'une commande passe à `paid` :

```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();
```

Ce que fait chaque partie :

- **`when (...)`** est le filtre qui manquait au niveau 1. Postgres n'appelle même pas la fonction à moins que le statut ait réellement changé et que la nouvelle valeur soit `paid`. Les modifications des autres colonnes ne coûtent rien.
- **`security definer`** permet à la fonction de lire Vault. Les rôles qui écrivent des lignes depuis votre application, comme `authenticated`, ne le peuvent pas ; sans cette option, leurs mises à jour échoueraient avec une erreur de permission. C'est le modèle décrit dans la documentation Supabase.
- **`net.http_post`** met la requête en file d'attente et rend la main immédiatement ; elle part une fois la transaction validée. Si la mise à jour est annulée, aucune notification ne part.
- **`level`** détermine l'intensité de l'alerte : `default` pour les événements courants, `high` pour passer la Concentration, `critical` pour ceux qui doivent vous réveiller. Critical est une fonctionnalité payante ; sur l'offre gratuite, elle est livrée comme `high`.

Copiez la fonction pour d'autres événements en changeant la condition : `new.status = 'canceled'` sur `subscriptions`, `new.total > 500` sur un trigger d'insertion pour les grosses commandes, `new.role = 'admin'` sur `profiles`.

### Inscriptions via un trigger sur auth.users

Le même modèle sur `auth.users`, avec le fournisseur de connexion dans le texte :

```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 prévient qu'un trigger en échec sur `auth.users` peut bloquer les inscriptions. Les appels `coalesce` évitent qu'une valeur manquante casse la chaîne, et la requête elle-même est asynchrone : une notification lente ou en échec ne gêne donc pas l'inscription. Testez tout de même une fois avec un compte jetable avant de vous y fier.

### Ou une Edge Function

Si vous préférez TypeScript à PL/pgSQL, conservez le Database Webhook du niveau 1, réglez son type sur **Supabase Edge Functions**, et ajoutez l'en-tête de clé secrète proposé par le formulaire. La fonction reçoit la même charge utile `{type, table, record, old_record}` et décide elle-même. Le modèle de Supabase pour les appels avec la clé secrète est le wrapper `withSupabase` avec `auth: 'secret'`, plus `verify_jwt = false` pour la fonction dans `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");
  }),
};
```

Définissez la clé avec `supabase secrets set POCKETALERT_API_KEY=...`. Le compromis : le webhook se déclenche toujours à chaque mise à jour, et la fonction filtre ensuite, si bien que vous payez une invocation par modification. Le trigger `WHEN`, lui, filtre avant toute exécution.

## Limites à connaître

- **Pas de vérification de signature.** Pocket Alert ne vérifie pas d'où vient une requête webhook ; le segment de l'URL est le secret. Si cela compte pour vous, utilisez le trigger du niveau 2, qui s'authentifie avec votre clé API.
- **La clé transite brièvement dans une table de file d'attente.** Supabase indique que `pg_net` conserve l'en-tête déchiffré dans `net.http_request_queue` jusqu'à l'envoi de la requête, et que tout rôle capable de se connecter à la base peut le lire à cet endroit.
- **pg_net fonctionne au mieux.** Les requêtes sont stockées dans des tables non journalisées ; un crash au mauvais moment peut en faire perdre une. Cela convient pour « prévenez-moi », pas pour la facturation.
- **Volume.** Un trigger sur une table qui reçoit des milliers d'écritures par heure enverra des milliers de notifications, sauf si la condition est très précise. L'offre gratuite autorise 50 messages par jour.

## Si rien n'arrive

- **Consultez l'historique du webhook Pocket Alert.** Chaque requête reçue par l'URL du webhook est journalisée dans la console, avec ses en-têtes, son corps, le message généré et le statut. Si la requête est là, Supabase a fait son travail et le problème vient du modèle. Sinon, regardez du côté de Supabase.
- **Vérifiez ce que pg_net a reçu en retour.** Les réponses sont conservées pendant six heures :

```sql
select status_code, content, error_msg, created
from net._http_response
order by created desc
limit 10;
```

Un `401` signifie que la clé API dans Vault est incorrecte ; un `400` indique généralement que le corps n'est pas du JSON valide ou qu'un champ manque.

- **Vérifiez la condition du trigger.** Lancez à la main une mise à jour qui devrait correspondre, par exemple `update orders set status = 'paid' where id = 1042;`, puis consultez à nouveau `net._http_response`.
- **Vérifiez l'événement.** Un webhook qui n'écoute que Insert ne se déclenchera pas sur les mises à jour, et sur `DELETE` les espaces réservés `%record.*%` sont vides, car la ligne se trouve dans `old_record`.

## FAQ

### Est-ce la même chose que d'envoyer des notifications push aux utilisateurs de mon application ?

Non. Ceci envoie des notifications push sur votre propre téléphone, via l'application Pocket Alert. Les notifications vers les appareils de vos utilisateurs passent par FCM, APNs ou un service comme Expo, que votre application doit intégrer elle-même.

### Puis-je obtenir des webhooks de base de données Supabase pour une seule colonne ?

Pas avec le webhook du tableau de bord : il se déclenche à toute modification de la ligne. Un trigger avec `after update of status` et une condition `WHEN`, comme dans le niveau 2, ne se déclenche que lorsque cette colonne change de la façon que vous décrivez.

### Est-ce que cela fonctionne avec l'offre gratuite de Supabase ?

Les Database Webhooks, les triggers, `pg_net` et Vault font tous partie d'un projet Supabase standard : rien ici n'exige une offre payante de Supabase.

### Puis-je envoyer des tables différentes vers des destinations différentes ?

Oui. Créez un webhook Pocket Alert par table, chacun avec son propre nom, son modèle et son niveau, ou placez-les dans des applications distinctes pour que les inscriptions et les commandes arrivent dans des canaux séparés de l'application. Plus d'idées sur les [alertes de base de données](/use-cases/database-alerts) et les [alertes d'inscription](/use-cases/signup-alerts).

### Dois-je utiliser le webhook de Supabase ?

Non. Tout ce qui peut envoyer une requête POST en JSON peut utiliser un [webhook Pocket Alert](/tools/webhook), et tout ce qui peut effectuer un appel HTTP peut utiliser l'API.

[Créez un compte gratuit](/signup), reliez-y une table, et la prochaine inscription apparaîtra sur votre écran verrouillé.
