---
title: "Conector de Supabase"
description: "Guía completa de integración con Supabase para sincronizar registros de base de datos, autenticación de usuarios, almacenamiento de archivos y eventos en tiempo real con tu plataforma de engagement."
url: https://tajo.io/es/docs/connectors/custom/supabase/
markdown: https://tajo.io/es/docs/connectors/custom/supabase.md
lang: es-ES
robots: noindex
---

Solicita acceso anticipado

Escribe tu nombre y dirección de correo de trabajo. Te enviaremos un enlace para confirmar tu solicitud de acceso a Tajo.

# Conector de Supabase

Estado del conector: Planificado Aún no está construido. Tajo no ejecuta este conector hoy.

| Campo de origen | Campo de destino | Valor de ejemplo |
| --- | --- | --- |
| `record.id` | `source_id` | `record_1042` |
| `record.updated_at` | `updated_at` | `2026-10-18T08:00:00Z` |
| `record.value` | `value` | `sample_value` |

Conecta tu proyecto de Supabase para sincronizar registros de base de datos, datos de autenticación de usuarios, eventos de almacenamiento de archivos y cambios en tiempo real para automatizar la interacción con los clientes.

## Resumen

| Propiedad | Valor |
| --- | --- |
| **Plataforma** | Supabase |
| **Categoría** | Base de datos y backend |
| **Complejidad de configuración** | Fácil |
| **Integración oficial** | No |
| **Datos sincronizados** | Usuarios, Tablas, Storage, Eventos |
| **Skills disponibles** | 11 |
| **Tipo de API** | REST (PostgREST) + WebSocket en tiempo real |
| **Documentación oficial** | [supabase.com/docs](https://supabase.com/docs) |

## Funcionalidades

- **REST API autogenerada**, Operaciones CRUD en cualquier tabla de Postgres vía PostgREST, sin necesidad de código
- **Sincronización de usuarios de Auth**, Sincroniza los usuarios de Supabase Auth (email, teléfono, logins sociales) con tu plataforma de engagement
- **Suscripciones en tiempo real**, Escucha eventos INSERT, UPDATE y DELETE en cualquier tabla en tiempo real
- **Row Level Security**, Todo el acceso a la API respeta las políticas RLS de Postgres para datos multitenant seguros
- **Integración con Storage**, Rastrea subidas de archivos y gestiona activos en varios buckets de Storage
- **Edge Functions**, Invoca funciones serverless en Deno para lógica personalizada y webhooks
- **Búsqueda a texto completo**, Aprovecha las capacidades de full-text search de Postgres a través de la API

## Requisitos previos

Antes de empezar, asegúrate de tener:

1. Un proyecto de Supabase ([app.supabase.com](https://app.supabase.com/))
2. La **URL de la API** y las **API keys** de tu proyecto (en Settings → API)
3. Una cuenta de Tajo con acceso a la API

API Keys

Supabase proporciona dos claves: `anon` (pública, respeta RLS) y `service_role` (ignora RLS, acceso de administrador). Usa `service_role` para integraciones del lado del servidor y `anon` para el lado del cliente.

## Autenticación

Supabase usa autenticación por API key. Cada petición requiere la cabecera `apikey` y, opcionalmente, un bearer token en `Authorization` para acceso con alcance de usuario.

```bash
# Using anon key (respects RLS)
curl 'https://<project_ref>.supabase.co/rest/v1/customers' \
  -H "apikey: <SUPABASE_ANON_KEY>" \
  -H "Authorization: Bearer <SUPABASE_ANON_KEY>"

# Using service_role key (bypasses RLS)
curl 'https://<project_ref>.supabase.co/rest/v1/customers' \
  -H "apikey: <SUPABASE_SERVICE_ROLE_KEY>" \
  -H "Authorization: Bearer <SUPABASE_SERVICE_ROLE_KEY>"
```

## Configuración

### Configuración básica

```yaml
connectors:
  supabase:
    enabled: true
    project_url: "https://xyzcompany.supabase.co"
    api_key: "${SUPABASE_SERVICE_ROLE_KEY}"

    # Data sync options
    sync:
      users: true
      tables:
        - customers
        - orders
        - products
      storage: true
      realtime: true

    # Map Supabase Auth users to contacts
    user_mapping:
      email: email
      phone: SMS
      user_metadata.full_name: FIRSTNAME
      created_at: SIGNUP_DATE
```

### Asignación de campos

Asocia columnas de las tablas de Supabase con atributos de la plataforma de engagement:

#### Default User Mappings

| Parameter | Type | Description |
| --- | --- | --- |
| `email` required | string | Email del usuario desde Supabase Auth (identificador único) |
| `phone` optional | string | Número de teléfono para engagement por SMS/WhatsApp |
| `user_metadata.full_name` optional | string | Nombre mostrado del user metadata de Auth |
| `user_metadata.avatar_url` optional | string | URL de la imagen de perfil |
| `created_at` optional | timestamp | Marca de tiempo de creación de la cuenta |
| `last_sign_in_at` optional | timestamp | Último inicio de sesión para puntuar el engagement |
| `app_metadata.provider` optional | string | Proveedor de Auth (email, google, github, etc.) |
| `confirmed_at` optional | timestamp | Marca de tiempo de confirmación del email |

#### Asignación personalizada de tablas

```yaml
table_mapping:
  customers:
    # Column → Attribute mapping
    email: email
    full_name: FIRSTNAME
    company: COMPANY
    plan: SUBSCRIPTION_PLAN
    mrr: MONTHLY_REVENUE
    created_at: SIGNUP_DATE

  orders:
    # Track as events
    sync_as: events
    event_name: "order_placed"
    properties:
      total: amount
      status: order_status
      items: line_items
```

## Endpoints de la API

La REST API de Supabase se autogenera a partir del esquema de tu base de datos en `https://<ref>.supabase.co/rest/v1/`.

| Endpoint | Método | Descripción |
| --- | --- | --- |
| `/rest/v1/{table}` | `GET` | Consultar filas con filtrado, ordenación y paginación |
| `/rest/v1/{table}` | `POST` | Insertar filas (admite bulk y upsert) |
| `/rest/v1/{table}` | `PATCH` | Actualizar filas según los filtros |
| `/rest/v1/{table}` | `DELETE` | Eliminar filas según los filtros |
| `/rest/v1/rpc/{function}` | `POST` | Llamar a una función de Postgres |
| `/auth/v1/signup` | `POST` | Crear un usuario nuevo |
| `/auth/v1/token?grant_type=password` | `POST` | Iniciar sesión con contraseña |
| `/auth/v1/user` | `GET` | Obtener el usuario actual |
| `/auth/v1/admin/users` | `GET` | Listar todos los usuarios (service\_role) |
| `/storage/v1/object/{bucket}/{path}` | `POST` | Subir archivo |
| `/storage/v1/object/list/{bucket}` | `POST` | Listar archivos en un bucket |
| `/functions/v1/{function_name}` | `POST` | Invocar una Edge Function |

### Operadores de filtrado

| Operador | Descripción | Ejemplo |
| --- | --- | --- |
| `eq` | Igual | `?status=eq.active` |
| `neq` | Distinto | `?status=neq.deleted` |
| `gt`, `gte` | Mayor que | `?amount=gt.100` |
| `lt`, `lte` | Menor que | `?created_at=lt.2024-01-01` |
| `like`, `ilike` | Coincidencia de patrón | `?name=ilike.%john%` |
| `in` | Dentro de un array | `?status=in.(active,trial)` |
| `is` | Comprobación de null | `?deleted_at=is.null` |

## Eventos

### Eventos de Auth

| Evento | Desencadenante | Caso de uso |
| --- | --- | --- |
| `user.signed_up` | Registro de un nuevo usuario | Serie de bienvenida |
| `user.signed_in` | Inicio de sesión del usuario | Seguimiento de actividad |
| `user.updated` | Cambios en el perfil | Sincronización de datos |
| `user.deleted` | Eliminación de cuenta | Flujos de limpieza |

### Eventos de base de datos (Realtime)

| Evento | Desencadenante | Caso de uso |
| --- | --- | --- |
| `INSERT` | Fila nueva añadida | Notificaciones de nuevo pedido/cliente |
| `UPDATE` | Fila modificada | Flujos de cambio de estado |
| `DELETE` | Fila eliminada | Detección de churn |

### Eventos de webhook

| Evento | Desencadenante | Caso de uso |
| --- | --- | --- |
| `auth.user.created` | Registro de usuario vía webhook | Disparar onboarding |
| `storage.object.created` | Archivo subido | Procesamiento de activos |

## Ejemplos de código

### Inicializar el conector

```javascript
import { TajoClient } from '@tajo/sdk';
import { createClient } from '@supabase/supabase-js';

const tajo = new TajoClient({
  apiKey: process.env.TAJO_API_KEY,
});

// Connect Supabase project
await tajo.connectors.connect('supabase', {
  projectUrl: process.env.SUPABASE_URL,
  serviceRoleKey: process.env.SUPABASE_SERVICE_ROLE_KEY,
});
```

### Sincronizar usuarios como contactos

```javascript
// Sync all Supabase Auth users as contacts
await tajo.connectors.sync('supabase', {
  type: 'full',
  resources: ['users'],
});

// Incremental sync (new/changed users only)
await tajo.connectors.sync('supabase', {
  type: 'incremental',
  resources: ['users'],
  since: '2024-01-01T00:00:00Z',
});
```

### Escuchar cambios en tiempo real

```javascript
// Subscribe to new orders for engagement triggers
const supabase = createClient(
  process.env.SUPABASE_URL,
  process.env.SUPABASE_SERVICE_ROLE_KEY
);

supabase
  .channel('orders')
  .on('postgres_changes',
    { event: 'INSERT', schema: 'public', table: 'orders' },
    async (payload) => {
      // Forward to Tajo as an event
      await tajo.events.track({
        email: payload.new.customer_email,
        event: 'order_placed',
        properties: {
          order_id: payload.new.id,
          total: payload.new.total,
          items: payload.new.line_items,
        },
      });
    }
  )
  .subscribe();
```

### Consultar y segmentar

```javascript
// Query customers by plan for targeted campaigns
const { data: proUsers } = await supabase
  .from('customers')
  .select('email, full_name, plan, mrr')
  .eq('plan', 'pro')
  .gt('mrr', 100)
  .order('mrr', { ascending: false });

// Sync to a Brevo list for campaign targeting
await tajo.lists.addContacts(PRO_LIST_ID, proUsers);
```

## Límites de velocidad

Límites de velocidad de la API

Los límites de velocidad de Supabase dependen de tu plan. Free: 500 peticiones/minuto. Pro: 1.000 peticiones/segundo. Contacta con Supabase para los límites Enterprise.

| Plan | Límite de velocidad | Conexiones en tiempo real |
| --- | --- | --- |
| Free | 500 req/min | 200 concurrentes |
| Pro | 1.000 req/s | 500 concurrentes |
| Team | 2.000 req/s | 1.000 concurrentes |
| Enterprise | Personalizado | Personalizado |

## Resolución de problemas

### Problemas habituales

| Problema | Causa | Solución |
| --- | --- | --- |
| 401 Unauthorized | API key no válida o expirada | Revisa las API keys en Supabase Dashboard → Settings → API |
| 403 Forbidden | Política RLS bloqueando el acceso | Usa la clave `service_role` para operaciones de administración, o revisa las políticas RLS |
| Sin eventos en tiempo real | Realtime no habilitado para la tabla | Habilítalo en Database → Replication → añade la tabla a la publicación |
| Resultados de consulta vacíos | RLS filtrando todas las filas | Verifica que las políticas RLS permitan leer al rol autenticado |
| Error al subir a Storage | Políticas del bucket | Comprueba que el bucket de Storage sea público o tenga las políticas RLS correctas |

### Modo depuración

```yaml
connectors:
  supabase:
    debug: true
    log_level: verbose
    log_queries: true
    log_realtime: true
```

### Probar la conexión

```bash
tajo connectors test supabase
# ✓ API connection successful
# ✓ Auth endpoint accessible
# ✓ Tables readable (12 tables found)
# ✓ Storage accessible (3 buckets)
# ✓ Realtime connection established
# ✓ Edge Functions available (4 functions)
```

## Buenas prácticas

1. **Usa la clave service\_role solo en el servidor**, Nunca la expongas en código del cliente
2. **Habilita RLS en todas las tablas**, Incluso con service\_role, diseña con RLS como defensa en profundidad
3. **Usa Realtime para sincronización dirigida por eventos**, Más eficiente que hacer polling de los cambios
4. **Agrupa operaciones**, Usa inserciones en bulk y el filtro `in` para operaciones de alto volumen
5. **Asigna user metadata**, Almacena campos relevantes para el engagement en `user_metadata` durante el alta
6. **Usa Edge Functions para los webhooks**, Procesa los webhooks entrantes con Edge Functions de Supabase para una gestión de baja latencia

## Seguridad

- **Autenticación por API Key**, Todas las peticiones requieren API keys válidas
- **Row Level Security (RLS)**, Control de acceso por fila nativo de Postgres
- **Verificación JWT**, Los tokens de Auth son JWT firmados que se verifican en cada petición
- **SSL/TLS**, Todas las conexiones se cifran en tránsito
- **SOC 2 Type II**, Supabase cumple SOC 2
- **Restricciones de red**, IP allowlisting opcional en planes de pago

## Recursos relacionados

- [Conector de Shopify](https://tajo.io/es/docs/connectors/ecommerce/shopify)
- [Conector de Stripe](https://tajo.io/es/docs/connectors/ecommerce/stripe)
- [Conector de Auth0](https://tajo.io/es/docs/connectors/custom/auth0)
- [Documentación oficial de Supabase](https://supabase.com/docs)
- [Guía de la REST API de Supabase](https://supabase.com/docs/guides/api)
- [Guía de Auth de Supabase](https://supabase.com/docs/guides/auth)