# Notifiche push Supabase: una notifica sul telefono per ogni nuova registrazione o ordine

> Ricevi una notifica push sul telefono quando una riga arriva nel tuo database Supabase. Un Database Webhook senza codice per nuove registrazioni e ordini, poi un trigger Postgres con pg_net per i cambi di stato, livelli di priorità e un pulsante che apre la tabella.

*24.10.2026*

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

La tua app gira su Supabase, e i momenti che ti interessano sono righe: un nuovo utente in `auth.users`, un nuovo ordine in `orders`, un abbonamento che passa a `canceled`. Li scopri quando apri il Table Editor, che in una bella giornata è la sera e in una giornata piena è la settimana dopo.

Supabase può avvisarti prima. Ogni tabella può chiamare un URL quando una riga viene inserita, aggiornata o eliminata. Punta quella chiamata verso Pocket Alert e ogni evento diventa una notifica push sul tuo telefono, con l'email o il totale dell'ordine nel testo.

Questa guida riguarda l'invio di notifiche **a te**, il fondatore o l'amministratore. Se vuoi inviare notifiche push agli utenti della tua app, serve FCM, APNs o Expo, e un articolo diverso.

## Cosa ti serve

- Un progetto Supabase che puoi aprire nella dashboard.
- Un account Pocket Alert e l'app sul tuo [iPhone o Android](/get-app). Il piano gratuito basta per iniziare.

Se hai costruito la tua app con Lovable e collegato un tuo progetto Supabase, tutto quello che segue vale. Su Lovable Cloud (il backend integrato) non c'è la dashboard di Supabase, quindi il Livello 1 non ha dove andare. Il suo SQL editor (**Database → Manage → SQL editor**) supporta `pg_net` e Vault, quindi i trigger del Livello 2 sono la strada da provare lì.

## Livello 1: un Database Webhook, senza codice

I Database Webhook di Supabase inviano una richiesta HTTP dopo che una riga cambia in una tabella. I webhook di Pocket Alert ricevono JSON e lo trasformano in una notifica push. Collegare i due richiede pochi minuti e nessun codice.

### Crea il webhook di Pocket Alert

Apri [Webhooks](/webhooks) nella console di Pocket Alert e creane uno:

- **Nome:** `Supabase`. Il titolo della notifica è sempre `Webhook <name>`, quindi questo arriverà come "Webhook Supabase". Usa un nome più specifico, come `Supabase signups`, se prevedi di averne più d'uno.
- **Messaggio:** il template, spiegato più sotto.

Copia l'URL che mostra la console. Ha questa forma: `https://p4a.me/wh/abc123xyz`. Lo slug finale è l'unico segreto, quindi tratta l'intero URL come una password.

### Crea il webhook di Supabase

Nella dashboard di Supabase, apri il tuo progetto e vai su **Integrations → Database Webhooks** (le guide più vecchie lo chiamano Database → Webhooks). Se l'integrazione non è ancora attiva, attivala prima: crea la funzione trigger che usano i webhook. Poi crea un nuovo webhook:

1. Dagli un nome, per esempio `notify_new_order`.
2. Scegli la tabella, per esempio `orders`.
3. Seleziona gli eventi. Per gli avvisi di "nuova riga", seleziona solo **Insert**.
4. Scegli **HTTP Request** come tipo, metodo `POST`, e incolla l'URL di Pocket Alert.
5. Lascia l'header `Content-Type: application/json` così com'è. Pocket Alert accetta solo body JSON.

Salva. Da adesso, ogni inserimento in `orders` invia una richiesta dopo che la riga è stata scritta. Supabase costruisce queste richieste con l'estensione `pg_net`, che è asincrona, quindi una chiamata di rete lenta non blocca mai l'inserimento stesso.

### Cosa invia Supabase

Il body ha la stessa struttura per ogni tabella:

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

`record` è la nuova riga con tutte le sue colonne. Per `UPDATE`, `old_record` contiene la riga com'era prima; per `DELETE`, `record` è `null` e viene compilato solo `old_record`.

### Il template del messaggio

Torna nel webhook di Pocket Alert e scrivi il messaggio con i segnaposto `%path%` che puntano dentro quel JSON:

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

Il prossimo ordine arriva così:

> **Webhook Supabase**
> Nuova riga in orders: #1042 · ana@example.com · $49

Usa qualsiasi colonna presente nella tua tabella: `%record.plan%`, `%record.country%`, `%record.status%`. Un `*` al posto del template invia l'intero JSON, utile mentre capisci i nomi delle colonne.

Lo stesso modulo ha un **livello predefinito**. Imposta `high` su un webhook degli ordini per farlo passare da Full immersion su iPhone, oppure `low` su una tabella molto attiva che vuoi solo nella cronologia. Il payload di Supabase non ha un campo `level`, quindi decide il valore predefinito del webhook.

### Registrazioni da auth.users

Supabase salva gli utenti in `auth.users`, e il selettore di tabelle dei Database Webhook può selezionarla: integrazioni come Loops documentano esattamente questa configurazione. Scegli la tabella degli utenti nello schema `auth`, seleziona **Insert** e usa:

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

Se le tabelle di auth non compaiono nel selettore, o preferisci tenere la logica in SQL, il trigger della sezione successiva funziona anche su `auth.users`.

## Dove si ferma il Livello 1

Un Database Webhook non ha condizioni. Seleziona **Update** su `orders` e ricevi una notifica ogni volta che cambia una colonna qualsiasi: lo stato, l'indirizzo di spedizione, un `updated_at` toccato da un job in background. Il template non può saltare una richiesta; può solo formattarla. Su una tabella molto attiva è al massimo rumore, e nel peggiore dei casi consuma i 50 messaggi giornalieri del piano gratuito prima di pranzo.

Per "avvisami quando un ordine viene pagato" o "avvisami quando un abbonamento viene annullato" ti serve un filtro, e Postgres ne ha già uno.

## Livello 2: un trigger con pg_net e una condizione WHEN

Un Database Webhook è un trigger che chiama `pg_net` per te. Scrivere il trigger da solo ti dà due cose: una clausola `WHEN`, così Postgres si attiva solo sulle modifiche che ti interessano, e il controllo completo della richiesta, così puoi chiamare direttamente l'API di Pocket Alert con il tuo titolo, livello e pulsanti.

### Salva la chiave API in Vault

Ottieni una chiave API da [API Keys](/account/apikeys) e salvala in Supabase Vault dal SQL Editor. Eseguilo una sola volta, fuori dalle tue migrazioni, così la chiave non finisce mai in un file:

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

Assicurati che `pg_net` sia attivo in **Database → Extensions**. I progetti con Database Webhook lo hanno già.

### La funzione e il trigger

Questo invia una notifica solo quando lo stato di un ordine passa a `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();
```

Cosa fa ogni parte:

- **`when (...)`** è il filtro che mancava nel Livello 1. Postgres non chiama nemmeno la funzione a meno che lo stato non sia davvero cambiato e il nuovo valore sia `paid`. Le modifiche ad altre colonne non costano nulla.
- **`security definer`** permette alla funzione di leggere Vault. I ruoli che scrivono righe dalla tua app, come `authenticated`, non possono farlo, e senza questa impostazione i loro aggiornamenti fallirebbero con un errore di permessi. È il pattern indicato nella documentazione di Supabase.
- **`net.http_post`** mette in coda la richiesta e ritorna subito; viene inviata dopo il commit della transazione. Se l'aggiornamento viene annullato, nessuna notifica parte.
- **`level`** decide quanto forte arriva: `default` per gli eventi di routine, `high` per superare Full immersion, `critical` per quelli che devono svegliarti. Critical è una funzione a pagamento; con il piano gratuito viene consegnato come `high`.

Copia la funzione per altri eventi e cambia la condizione: `new.status = 'canceled'` su `subscriptions`, `new.total > 500` in un trigger di inserimento per gli ordini grandi, `new.role = 'admin'` su `profiles`.

### Registrazioni tramite trigger su auth.users

Lo stesso schema su `auth.users`, con il provider di accesso nel testo:

```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 avverte che un trigger che fallisce su `auth.users` può bloccare le registrazioni. Le chiamate `coalesce` evitano che un valore mancante rompa la stringa, e la richiesta è asincrona, quindi una notifica lenta o fallita non interferisce con la registrazione. Comunque, testalo una volta con un account usa e getta prima di farci affidamento.

### Oppure una Edge Function

Se preferisci TypeScript a PL/pgSQL, mantieni il Database Webhook del Livello 1, imposta il suo tipo su **Supabase Edge Functions** e aggiungi l'header con la chiave segreta che il form propone. La funzione riceve lo stesso payload `{type, table, record, old_record}` e decide da sola. Il pattern di Supabase per le chiamate con la chiave segreta è il wrapper `withSupabase` con `auth: 'secret'`, più `verify_jwt = false` per la funzione 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");
  }),
};
```

Imposta la chiave con `supabase secrets set POCKETALERT_API_KEY=...`. Il compromesso: il webhook si attiva comunque a ogni aggiornamento, e la funzione filtra dopo, quindi paghi un'invocazione per ogni modifica. Il trigger `WHEN` filtra prima che parta qualsiasi cosa.

## Limiti onesti

- **Nessuna verifica della firma.** Pocket Alert non verifica da dove arriva una richiesta al webhook; lo slug dell'URL è il segreto. Se conta, usa il trigger del Livello 2, che si autentica con la tua chiave API.
- **La chiave resta brevemente in una tabella di coda.** Supabase segnala che `pg_net` mantiene l'header decifrato in `net.http_request_queue` finché la richiesta non parte, e qualsiasi ruolo che può accedere al database può leggerlo lì.
- **pg_net è best effort.** Le richieste vivono in tabelle non loggate, quindi un crash nel momento sbagliato può perderne una. Va bene per "avvisami", non per la fatturazione.
- **Volume.** Un trigger su una tabella che riceve migliaia di scritture all'ora invierà migliaia di notifiche, a meno che la condizione non sia molto stretta. Il piano gratuito consente 50 messaggi al giorno.

## Se non arriva nulla

- **Controlla la cronologia del webhook di Pocket Alert.** Ogni richiesta all'URL del webhook viene registrata nella console con header, body, messaggio generato e stato. Se la richiesta c'è, Supabase ha fatto la sua parte e il problema è nel template. Se non c'è, guarda Supabase.
- **Controlla cosa ha restituito pg_net.** Le risposte vengono conservate per sei ore:

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

Un `401` significa che la chiave API in Vault è sbagliata; un `400` di solito vuol dire che il body non è JSON valido o che manca un campo.

- **Controlla la condizione del trigger.** Esegui a mano un aggiornamento che dovrebbe corrispondere, come `update orders set status = 'paid' where id = 1042;`, e ricontrolla `net._http_response`.
- **Controlla l'evento.** Un webhook che ascolta solo Insert non si attiva sugli aggiornamenti, e su `DELETE` i segnaposto `%record.*%` sono vuoti perché la riga si trova in `old_record`.

## FAQ

### È la stessa cosa dell'invio di notifiche push agli utenti della mia app?

No. Questo invia notifiche push al tuo telefono tramite l'app Pocket Alert. Le notifiche ai dispositivi dei tuoi utenti passano per FCM, APNs o un servizio come Expo, che la tua app deve integrare da sola.

### Posso ottenere webhook del database Supabase solo per una colonna?

Non con il webhook della dashboard; si attiva su qualsiasi modifica della riga. Un trigger con `after update of status` e una condizione `WHEN`, come nel Livello 2, si attiva solo quando quella colonna cambia nel modo che descrivi.

### Funziona con il piano gratuito di Supabase?

Database Webhook, trigger, `pg_net` e Vault fanno tutti parte di un normale progetto Supabase, quindi qui non serve un piano Supabase a pagamento.

### Posso inviare tabelle diverse a destinazioni diverse?

Sì. Crea un webhook di Pocket Alert per tabella, ciascuno con il proprio nome, template e livello, oppure mettili in applicazioni separate, così registrazioni e ordini arrivano in canali distinti dentro l'app. Altre idee su [avvisi dal database](/use-cases/database-alerts) e [avvisi di registrazione](/use-cases/signup-alerts).

### Devo usare il webhook di Supabase?

No. Qualsiasi cosa che può inviare JSON con POST può usare un [webhook di Pocket Alert](/tools/webhook), e qualsiasi cosa che può fare una chiamata HTTP può usare l'API.

[Crea un account gratuito](/signup), collega una tabella e la prossima registrazione comparirà sulla tua schermata di blocco.
