# Notificaciones push de Supabase: una push en tu teléfono por cada nuevo registro o pedido

> Recibe una notificación push en el teléfono cuando se inserte una fila en tu base de datos de Supabase. Un Database Webhook sin código para nuevos registros y pedidos, y después un trigger de Postgres con pg_net para cambios de estado, niveles de prioridad y un botón que abre la tabla.

*24.10.2026*

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

Tu aplicación funciona con Supabase, y los momentos que te importan son filas: un usuario nuevo en `auth.users`, un pedido nuevo en `orders`, una suscripción que pasa a `canceled`. Te enteras de ellos cuando abres el Table Editor, que un buen día es por la tarde y un día de mucho trabajo es la semana que viene.

Supabase puede avisarte antes. Cada tabla puede llamar a una URL cuando se inserta, actualiza o elimina una fila. Apunta esa llamada a Pocket Alert y cada evento se convierte en una notificación push en tu teléfono, con el correo o el total del pedido en el texto.

Esta guía trata de avisar a **ti**, el fundador o administrador. Si quieres enviar notificaciones push a los usuarios de tu propia aplicación, eso es trabajo para FCM, APNs o Expo, y es otro artículo.

## Qué necesitas

- Un proyecto de Supabase al que puedas acceder desde el panel.
- Una cuenta de Pocket Alert y la aplicación en tu [iPhone o Android](/get-app). El plan gratuito basta para empezar.

Si creaste tu aplicación con Lovable y conectaste tu propio proyecto de Supabase, todo lo que sigue se aplica. En Lovable Cloud (el backend integrado) no hay panel de Supabase, así que el Nivel 1 no tiene dónde aplicarse. Su editor SQL (**Database → Manage → SQL editor**) sí admite `pg_net` y Vault, así que los triggers del Nivel 2 son la ruta a probar ahí.

## Nivel 1: un Database Webhook, sin código

Los Database Webhooks de Supabase envían una petición HTTP después de que cambia una fila en una tabla. Los webhooks de Pocket Alert reciben JSON y lo convierten en una notificación push. Conectar ambos lleva unos minutos y no requiere código.

### Crea el webhook de Pocket Alert

Abre [Webhooks](/webhooks) en la consola de Pocket Alert y crea uno:

- **Nombre:** `Supabase`. El título de la notificación siempre es `Webhook <name>`, así que este llegará como «Webhook Supabase». Usa un nombre más específico, como `Supabase signups`, si vas a tener varios.
- **Mensaje:** la plantilla, que se explica más abajo.

Copia la URL que muestra la consola. Tiene este aspecto: `https://p4a.me/wh/abc123xyz`. El identificador del final es el único secreto, así que trata la URL completa como una contraseña.

### Crea el webhook de Supabase

En el panel de Supabase, abre tu proyecto y ve a **Integrations → Database Webhooks** (las guías antiguas lo llaman Database → Webhooks). Si la integración aún no está activada, actívala primero; crea la función de trigger que usan los webhooks. Después crea un webhook nuevo:

1. Ponle un nombre, por ejemplo `notify_new_order`.
2. Elige la tabla, por ejemplo `orders`.
3. Marca los eventos. Para alertas de «fila nueva», marca solo **Insert**.
4. Elige **HTTP Request** como tipo, método `POST` y pega la URL de Pocket Alert.
5. Deja el encabezado `Content-Type: application/json` tal como está. Pocket Alert solo acepta cuerpos JSON.

Guarda. A partir de ahora, cada inserción en `orders` envía una petición después de escribirse la fila. Supabase construye estas peticiones con la extensión `pg_net`, que es asíncrona, así que una llamada de red lenta nunca bloquea la inserción en sí.

### Qué envía Supabase

El cuerpo tiene la misma forma para todas las tablas:

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

`record` es la fila nueva con todas sus columnas. En `UPDATE`, `old_record` contiene la fila tal como era antes; en `DELETE`, `record` es `null` y solo se rellena `old_record`.

### La plantilla del mensaje

De vuelta en el webhook de Pocket Alert, escribe el mensaje con marcadores `%path%` que apunten a ese JSON:

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

El siguiente pedido llegará así:

> **Webhook Supabase**
> Nueva fila en orders: #1042 · ana@example.com · $49

Usa cualquier columna que tenga tu tabla: `%record.plan%`, `%record.country%`, `%record.status%`. Un `*` en lugar de una plantilla envía el JSON completo, lo que ayuda mientras averiguas los nombres de las columnas.

El mismo formulario tiene un **nivel predeterminado**. Configura `high` en un webhook de pedidos para que atraviese Concentración en el iPhone, o `low` en una tabla muy activa que solo quieres ver en el historial. El payload de Supabase no tiene un campo `level`, así que manda el predeterminado del webhook.

### Registros desde auth.users

Supabase guarda los usuarios en `auth.users`, y el selector de tablas de Database Webhooks permite elegirla: integraciones como Loops documentan exactamente esa configuración. Elige la tabla de usuarios del esquema `auth`, marca **Insert** y usa:

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

Si las tablas de auth no aparecen en tu selector, o prefieres mantener la lógica en SQL, el trigger de la siguiente sección también funciona sobre `auth.users`.

## Hasta dónde llega el Nivel 1

Un Database Webhook no tiene condiciones. Marca **Update** en `orders` y recibirás una notificación cada vez que cambie cualquier columna: el estado, la dirección de envío, un `updated_at` tocado por una tarea en segundo plano. La plantilla no puede omitir una petición; solo le da formato. En una tabla muy activa es ruido en el mejor de los casos, y en el peor se come los 50 mensajes diarios del plan gratuito antes de la hora de comer.

Para «avísame cuando un pedido se pague» o «avísame cuando se cancele una suscripción», necesitas un filtro, y Postgres ya lo tiene.

## Nivel 2: un trigger con pg_net y una condición WHEN

Un Database Webhook es un trigger que llama a `pg_net` por ti. Escribir el trigger tú mismo te da dos cosas: una cláusula `WHEN`, para que Postgres solo se dispare con los cambios que te importan, y control total sobre la petición, para llamar directamente a la API de Pocket Alert con tu propio título, nivel y botones.

### Guarda la clave de API en Vault

Obtén una clave de API en [API Keys](/account/apikeys) y guárdala en Supabase Vault desde el SQL Editor. Ejecuta esto una sola vez, fuera de tus migraciones, para que la clave nunca acabe en un archivo:

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

Asegúrate de que `pg_net` esté habilitado en **Database → Extensions**. Los proyectos con Database Webhooks ya lo tienen.

### La función y el trigger

Esto envía una notificación solo cuando el estado de un pedido cambia 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();
```

Qué hace cada parte:

- **`when (...)`** es el filtro que faltaba en el Nivel 1. Postgres ni siquiera llama a la función a menos que el estado haya cambiado realmente y el nuevo valor sea `paid`. Las ediciones en otras columnas no cuestan nada.
- **`security definer`** permite que la función lea Vault. Los roles que escriben filas desde tu aplicación, como `authenticated`, no pueden hacerlo, y sin esta opción sus actualizaciones fallarían con un error de permisos. Es el patrón de la documentación de Supabase.
- **`net.http_post`** encola la petición y devuelve el control de inmediato; se envía después de que la transacción se confirme. Si la actualización se revierte, no sale ninguna notificación.
- **`level`** decide con qué intensidad llega: `default` para eventos rutinarios, `high` para atravesar Concentración, `critical` para los que deben despertarte. La alerta crítica es una función de pago; en el plan gratuito se entrega como `high`.

Copia la función para otros eventos y cambia la condición: `new.status = 'canceled'` en `subscriptions`, `new.total > 500` en un trigger de inserción para pedidos grandes, `new.role = 'admin'` en `profiles`.

### Registros mediante un trigger en auth.users

El mismo patrón sobre `auth.users`, con el proveedor de inicio de sesión en el texto:

```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 advierte de que un trigger que falle en `auth.users` puede bloquear los registros. Las llamadas a `coalesce` evitan que un valor ausente rompa la cadena, y la petición en sí es asíncrona, así que una notificación lenta o fallida no interfiere con el registro. Aun así, pruébalo una vez con una cuenta desechable antes de depender de ello.

### O una Edge Function

Si prefieres TypeScript a PL/pgSQL, conserva el Database Webhook del Nivel 1, cambia su tipo a **Supabase Edge Functions** y añade el encabezado de clave secreta que ofrece el formulario. La función recibe el mismo payload `{type, table, record, old_record}` y decide por sí misma. El patrón de Supabase para llamadas con la clave secreta es el wrapper `withSupabase` con `auth: 'secret'`, más `verify_jwt = false` para la función en `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");
  }),
};
```

Configura la clave con `supabase secrets set POCKETALERT_API_KEY=...`. El inconveniente: el webhook sigue disparándose en cada actualización y la función filtra después, así que pagas una invocación por cada cambio. El trigger con `WHEN` filtra antes de que se ejecute nada.

## Límites reales

- **Sin verificación de firma.** Pocket Alert no comprueba de dónde viene una petición de webhook; el identificador de la URL es el secreto. Si eso importa, usa el trigger del Nivel 2, que se autentica con tu clave de API.
- **La clave queda un momento en una tabla de cola.** Supabase indica que `pg_net` mantiene el encabezado descifrado en `net.http_request_queue` hasta que sale la petición, y cualquier rol que pueda iniciar sesión en la base de datos puede leerlo ahí.
- **pg_net funciona con el mejor esfuerzo.** Las peticiones viven en tablas no registradas, así que un fallo en el momento equivocado puede perder una. Vale para «avísame de esto», no para facturación.
- **Volumen.** Un trigger sobre una tabla que recibe miles de escrituras por hora enviará miles de notificaciones, salvo que la condición sea muy precisa. El plan gratuito permite 50 mensajes al día.

## Si no llega nada

- **Revisa el historial del webhook de Pocket Alert.** Cada petición a la URL del webhook queda registrada en la consola con sus encabezados, cuerpo, el mensaje renderizado y el estado. Si la petición está ahí, Supabase hizo su parte y el problema está en la plantilla. Si no está, revisa Supabase.
- **Comprueba qué respondió pg_net.** Las respuestas se guardan durante seis horas:

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

Un `401` significa que la clave de API en Vault es incorrecta; un `400` suele indicar que el cuerpo no es JSON válido o que falta un campo.

- **Revisa la condición del trigger.** Ejecuta a mano una actualización que debería cumplirla, como `update orders set status = 'paid' where id = 1042;`, y vuelve a mirar `net._http_response`.
- **Revisa el evento.** Un webhook que solo escucha Insert no se disparará con actualizaciones, y en `DELETE` los marcadores `%record.*%` están vacíos porque la fila está en `old_record`.

## Preguntas frecuentes

### ¿Es lo mismo que enviar notificaciones push a los usuarios de mi aplicación?

No. Esto envía notificaciones push a tu propio teléfono a través de la aplicación de Pocket Alert. Las notificaciones a los dispositivos de tus usuarios pasan por FCM, APNs o un servicio como Expo, que tu aplicación tiene que integrar por su cuenta.

### ¿Puedo recibir webhooks de base de datos de Supabase solo para una columna?

No con el webhook del panel; se dispara con cualquier cambio en la fila. Un trigger con `after update of status` y una condición `WHEN`, como en el Nivel 2, se dispara solo cuando esa columna cambia de la forma que describes.

### ¿Funciona en el plan gratuito de Supabase?

Los Database Webhooks, los triggers, `pg_net` y Vault forman parte de un proyecto normal de Supabase, así que nada de lo aquí descrito requiere un plan de pago de Supabase.

### ¿Puedo enviar tablas distintas a sitios distintos?

Sí. Crea un webhook de Pocket Alert por tabla, cada uno con su nombre, plantilla y nivel, o ponlos en aplicaciones separadas para que registros y pedidos lleguen a canales distintos en la app. Más ideas en [alertas de bases de datos](/use-cases/database-alerts) y [alertas de registros](/use-cases/signup-alerts).

### ¿Tengo que usar el webhook de Supabase?

No. Cualquier cosa que pueda enviar JSON por POST puede usar un [webhook de Pocket Alert](/tools/webhook), y cualquier cosa que pueda hacer una llamada HTTP puede usar la API.

[Crea una cuenta gratuita](/signup), apunta una tabla hacia ella y el próximo registro aparecerá en tu pantalla de bloqueo.
