---
title: "Connettore Supabase"
description: "Guida completa all'integrazione di Supabase per sincronizzare record del database, auth utente, file storage ed eventi real-time con la tua piattaforma di engagement."
url: https://tajo.io/it/docs/connectors/custom/supabase/
markdown: https://tajo.io/it/docs/connectors/custom/supabase.md
lang: it-IT
robots: noindex
---

Richiedi l’accesso anticipato

Inserisci il tuo nome e indirizzo email aziendale. Ti invieremo un link per confermare la richiesta di accesso a Tajo.

# Connettore Supabase

Stato del connettore: Pianificato Non ancora realizzato. Oggi Tajo non esegue questo connettore.

| Campo di origine | Campo di destinazione | Valore di esempio |
| --- | --- | --- |
| `record.id` | `source_id` | `record_1042` |
| `record.updated_at` | `updated_at` | `2026-10-18T08:00:00Z` |
| `record.value` | `value` | `sample_value` |

Collega il tuo progetto Supabase per sincronizzare record del database, dati di autenticazione utente, eventi di file storage e modifiche in real-time per l’automazione dell’engagement cliente.

## Panoramica

| Proprietà | Valore |
| --- | --- |
| **Piattaforma** | Supabase |
| **Categoria** | Database & Backend |
| **Complessità di setup** | Facile |
| **Integrazione ufficiale** | Sì |
| **Dati sincronizzati** | Utenti, Tabelle, Storage, Eventi |
| **Skill disponibili** | 11 |
| **Tipo di API** | REST (PostgREST) + Realtime WebSocket |
| **Documentazione ufficiale** | [supabase.com/docs](https://supabase.com/docs) |

## Funzionalità

- **REST API auto-generata**, Operazioni CRUD su qualsiasi tabella Postgres tramite PostgREST, senza codice
- **Sync utenti Auth**, Sincronizza utenti Supabase Auth (email, telefono, login social) sulla tua piattaforma di engagement
- **Sottoscrizioni real-time**, Ascolta eventi INSERT, UPDATE, DELETE su qualsiasi tabella in real-time
- **Row Level Security**, Tutti gli accessi API rispettano le policy RLS di Postgres per dati multi-tenant sicuri
- **Integrazione Storage**, Traccia gli upload di file e gestisci asset nei bucket Storage
- **Edge Functions**, Invoca funzioni serverless Deno per logica personalizzata e webhook
- **Full-text search**, Sfrutta le capacità di full-text search di Postgres tramite l’API

## Prerequisiti

Prima di iniziare, assicurati di avere:

1. Un progetto Supabase ([app.supabase.com](https://app.supabase.com/))
2. L’**API URL** e le **API key** del progetto (in Settings → API)
3. Un account Tajo con accesso API

API Key

Supabase fornisce due chiavi: `anon` (pubblica, rispetta RLS) e `service_role` (bypassa RLS, accesso admin). Usa `service_role` per integrazioni server-side e `anon` per client-side.

## Autenticazione

Supabase usa l’autenticazione tramite API key. Ogni richiesta richiede l’header `apikey` e, opzionalmente, un bearer token `Authorization` per l’accesso con scope utente.

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

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

## Configurazione

### Setup di base

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

    # Opzioni di sync dei dati
    sync:
      users: true
      tables:
        - customers
        - orders
        - products
      storage: true
      realtime: true

    # Mappa utenti Supabase Auth su contatti
    user_mapping:
      email: email
      phone: SMS
      user_metadata.full_name: FIRSTNAME
      created_at: SIGNUP_DATE
```

### Mapping dei campi

Mappa le colonne delle tabelle Supabase sugli attributi della piattaforma di engagement:

#### Mapping utente di default

| Parameter | Type | Description |
| --- | --- | --- |
| `email` required | string | Email utente da Supabase Auth (identificatore univoco) |
| `phone` optional | string | Numero di telefono per engagement SMS/WhatsApp |
| `user_metadata.full_name` optional | string | Nome visualizzato dai metadati utente Auth |
| `user_metadata.avatar_url` optional | string | URL immagine di profilo |
| `created_at` optional | timestamp | Timestamp di creazione dell'account |
| `last_sign_in_at` optional | timestamp | Ultimo login per lo scoring di engagement |
| `app_metadata.provider` optional | string | Provider di auth (email, google, github, ecc.) |
| `confirmed_at` optional | timestamp | Timestamp di conferma email |

#### Mapping tabelle personalizzato

```yaml
table_mapping:
  customers:
    # Mapping colonna → attributo
    email: email
    full_name: FIRSTNAME
    company: COMPANY
    plan: SUBSCRIPTION_PLAN
    mrr: MONTHLY_REVENUE
    created_at: SIGNUP_DATE

  orders:
    # Traccia come eventi
    sync_as: events
    event_name: "order_placed"
    properties:
      total: amount
      status: order_status
      items: line_items
```

## Endpoint API

La REST API di Supabase è auto-generata dallo schema del tuo database su `https://<ref>.supabase.co/rest/v1/`.

| Endpoint | Metodo | Descrizione |
| --- | --- | --- |
| `/rest/v1/{table}` | `GET` | Interroga righe con filtri, ordinamento, paginazione |
| `/rest/v1/{table}` | `POST` | Inserisci righe (supporta bulk e upsert) |
| `/rest/v1/{table}` | `PATCH` | Aggiorna righe che corrispondono ai filtri |
| `/rest/v1/{table}` | `DELETE` | Elimina righe che corrispondono ai filtri |
| `/rest/v1/rpc/{function}` | `POST` | Chiama una funzione Postgres |
| `/auth/v1/signup` | `POST` | Crea un nuovo utente |
| `/auth/v1/token?grant_type=password` | `POST` | Accedi con password |
| `/auth/v1/user` | `GET` | Ottieni l’utente corrente |
| `/auth/v1/admin/users` | `GET` | Elenca tutti gli utenti (service\_role) |
| `/storage/v1/object/{bucket}/{path}` | `POST` | Carica file |
| `/storage/v1/object/list/{bucket}` | `POST` | Elenca i file in un bucket |
| `/functions/v1/{function_name}` | `POST` | Invoca una Edge Function |

### Operatori di filtro

| Operatore | Descrizione | Esempio |
| --- | --- | --- |
| `eq` | Uguale | `?status=eq.active` |
| `neq` | Diverso | `?status=neq.deleted` |
| `gt`, `gte` | Maggiore di | `?amount=gt.100` |
| `lt`, `lte` | Minore di | `?created_at=lt.2024-01-01` |
| `like`, `ilike` | Match di pattern | `?name=ilike.%john%` |
| `in` | In array | `?status=in.(active,trial)` |
| `is` | Controllo null | `?deleted_at=is.null` |

## Eventi

### Eventi Auth

| Evento | Trigger | Caso d’uso |
| --- | --- | --- |
| `user.signed_up` | Registrazione nuovo utente | Welcome series |
| `user.signed_in` | Login utente | Tracciamento attività |
| `user.updated` | Modifica del profilo | Sync dei dati |
| `user.deleted` | Cancellazione account | Workflow di cleanup |

### Eventi del database (Realtime)

| Evento | Trigger | Caso d’uso |
| --- | --- | --- |
| `INSERT` | Nuova riga aggiunta | Notifiche nuovi ordini/clienti |
| `UPDATE` | Riga modificata | Workflow di cambio stato |
| `DELETE` | Riga rimossa | Rilevamento churn |

### Eventi webhook

| Evento | Trigger | Caso d’uso |
| --- | --- | --- |
| `auth.user.created` | Signup utente via webhook | Attivare onboarding |
| `storage.object.created` | File caricato | Elaborazione asset |

## Esempi di codice

### Inizializzare il connettore

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

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

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

### Sincronizzare gli utenti come contatti

```javascript
// Sincronizza tutti gli utenti Supabase Auth come contatti
await tajo.connectors.sync('supabase', {
  type: 'full',
  resources: ['users'],
});

// Sync incrementale (solo utenti nuovi/modificati)
await tajo.connectors.sync('supabase', {
  type: 'incremental',
  resources: ['users'],
  since: '2024-01-01T00:00:00Z',
});
```

### Ascoltare i cambiamenti in real-time

```javascript
// Sottoscrivi i nuovi ordini per attivare l'engagement
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) => {
      // Inoltra a Tajo come evento
      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();
```

### Query e segmentazione

```javascript
// Interroga i clienti per piano per campagne mirate
const { data: proUsers } = await supabase
  .from('customers')
  .select('email, full_name, plan, mrr')
  .eq('plan', 'pro')
  .gt('mrr', 100)
  .order('mrr', { ascending: false });

// Sincronizza su una lista Brevo per il targeting della campagna
await tajo.lists.addContacts(PRO_LIST_ID, proUsers);
```

## Limiti di rate

Rate limit API

I rate limit di Supabase dipendono dal tuo piano. Tier Free: 500 richieste/minuto. Pro: 1.000 richieste/secondo. Contatta Supabase per i limiti Enterprise.

| Piano | Rate limit | Connessioni Realtime |
| --- | --- | --- |
| Free | 500 req/min | 200 concorrenti |
| Pro | 1.000 req/s | 500 concorrenti |
| Team | 2.000 req/s | 1.000 concorrenti |
| Enterprise | Custom | Custom |

## Risoluzione dei problemi

### Problemi comuni

| Problema | Causa | Soluzione |
| --- | --- | --- |
| 401 Unauthorized | API key non valida o scaduta | Controlla le API key nella Dashboard Supabase → Settings → API |
| 403 Forbidden | Policy RLS che blocca l’accesso | Usa la chiave `service_role` per operazioni admin o controlla le policy RLS |
| Nessun evento realtime | Realtime non abilitato per la tabella | Abilita in Database → Replication → aggiungi la tabella alla publication |
| Risultati query vuoti | RLS filtra tutte le righe | Verifica che le policy RLS consentano al ruolo autenticato di leggere |
| Upload storage fallito | Policy del bucket | Controlla che il bucket Storage sia pubblico o abbia policy RLS corrette |

### Modalità debug

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

### Testare la connessione

```bash
tajo connectors test supabase
# ✓ Connessione API riuscita
# ✓ Endpoint Auth accessibile
# ✓ Tabelle leggibili (12 tabelle trovate)
# ✓ Storage accessibile (3 bucket)
# ✓ Connessione Realtime stabilita
# ✓ Edge Functions disponibili (4 funzioni)
```

## Best practice

1. **Usa la service\_role key solo server-side**, Non esporla mai nel codice client
2. **Abilita RLS su tutte le tabelle**, Anche con service\_role, progetta con RLS per difesa in profondità
3. **Usa Realtime per sync event-driven**, Più efficiente del polling per i cambiamenti
4. **Operazioni in batch**, Usa inserti bulk e il filtro `in` per operazioni ad alto volume
5. **Mappa i metadati utente**, Memorizza campi rilevanti per l’engagement in `user_metadata` durante il signup
6. **Usa Edge Functions per i webhook**, Elabora webhook in ingresso con Edge Functions Supabase per bassa latenza

## Sicurezza

- **Autenticazione API key**, Tutte le richieste richiedono API key valide
- **Row Level Security (RLS)**, Controllo di accesso Postgres-native per riga
- **Verifica JWT**, I token Auth sono JWT firmati verificati a ogni richiesta
- **SSL/TLS**, Tutte le connessioni cifrate in transito
- **SOC 2 Type II**, Supabase è conforme SOC 2
- **Restrizioni di rete**, IP allowlisting opzionale sui piani a pagamento

## Risorse correlate

- [Connettore Shopify](https://tajo.io/it/docs/connectors/ecommerce/shopify)
- [Connettore Stripe](https://tajo.io/it/docs/connectors/ecommerce/stripe)
- [Connettore Auth0](https://tajo.io/it/docs/connectors/custom/auth0)
- [Documentazione ufficiale Supabase](https://supabase.com/docs)
- [Guida REST API Supabase](https://supabase.com/docs/guides/api)
- [Guida Supabase Auth](https://supabase.com/docs/guides/auth)