---
title: "Connecteur Supabase"
description: "Guide complet d'intégration Supabase pour synchroniser enregistrements de base de données, auth utilisateur, stockage de fichiers et événements en temps réel avec votre plateforme d'engagement."
url: https://tajo.io/fr/docs/connectors/custom/supabase/
markdown: https://tajo.io/fr/docs/connectors/custom/supabase.md
lang: fr-FR
robots: noindex
---

Demandez un accès anticipé

Indiquez votre prénom et votre adresse e-mail professionnelle. Nous vous enverrons un lien pour confirmer votre demande d’accès à Tajo.

# Connecteur Supabase

Statut du connecteur: Prévu Pas encore construit. Tajo n'exécute pas ce connecteur aujourd'hui.

| Champ source | Champ de destination | Valeur d’exemple |
| --- | --- | --- |
| `record.id` | `source_id` | `record_1042` |
| `record.updated_at` | `updated_at` | `2026-10-18T08:00:00Z` |
| `record.value` | `value` | `sample_value` |

Connectez votre projet Supabase pour synchroniser les enregistrements de base de données, les données d’authentification utilisateur, les événements de stockage de fichiers et les changements en temps réel pour l’automatisation de l’engagement client.

## Vue d’ensemble

| Propriété | Valeur |
| --- | --- |
| **Plateforme** | Supabase |
| **Catégorie** | Base de données et backend |
| **Complexité d’installation** | Facile |
| **Intégration officielle** | Non |
| **Données synchronisées** | Utilisateurs, tables, stockage, événements |
| **Skills disponibles** | 11 |
| **Type d’API** | REST (PostgREST) + WebSocket Realtime |
| **Docs officielle** | [supabase.com/docs](https://supabase.com/docs) |

## Fonctionnalités

- **API REST auto-générée**, Opérations CRUD sur toute table Postgres via PostgREST, sans code
- **Synchronisation des utilisateurs Auth**, Synchronisez les utilisateurs Supabase Auth (e-mail, téléphone, logins sociaux) vers votre plateforme d’engagement
- **Abonnements temps réel**, Écoutez les événements INSERT, UPDATE, DELETE sur toute table en temps réel
- **Row Level Security**, Tout accès à l’API respecte les politiques RLS Postgres pour des données multi-tenants sécurisées
- **Intégration de stockage**, Suivez les uploads de fichiers et gérez les assets entre les buckets Storage
- **Edge Functions**, Invoquez des fonctions Deno serverless pour la logique personnalisée et les webhooks
- **Recherche plein texte**, Exploitez les capacités de recherche plein texte Postgres via l’API

## Prérequis

Avant de commencer, assurez-vous de disposer de :

1. Un projet Supabase ([app.supabase.com](https://app.supabase.com/))
2. L’**URL de l’API** et les **clés d’API** de votre projet (dans Settings → API)
3. Un compte Tajo avec accès API

Clés API

Supabase fournit deux clés : `anon` (publique, respecte RLS) et `service_role` (contourne RLS, accès admin). Utilisez `service_role` pour les intégrations côté serveur et `anon` côté client.

## Authentification

Supabase utilise une authentification par clé API. Chaque requête nécessite l’en-tête `apikey` et éventuellement un bearer token `Authorization` pour un accès scoped à l’utilisateur.

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

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

## Configuration

### Configuration de base

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

    # Options de synchronisation des données
    sync:
      users: true
      tables:
        - customers
        - orders
        - products
      storage: true
      realtime: true

    # Mapper les utilisateurs Supabase Auth vers les contacts
    user_mapping:
      email: email
      phone: SMS
      user_metadata.full_name: FIRSTNAME
      created_at: SIGNUP_DATE
```

### Mappage des champs

Mappez les colonnes des tables Supabase vers les attributs de la plateforme d’engagement :

#### Default User Mappings

| Parameter | Type | Description |
| --- | --- | --- |
| `email` required | string | E-mail utilisateur depuis Supabase Auth (identifiant unique) |
| `phone` optional | string | Numéro de téléphone pour l'engagement SMS/WhatsApp |
| `user_metadata.full_name` optional | string | Nom affiché depuis les métadonnées utilisateur Auth |
| `user_metadata.avatar_url` optional | string | URL de l'image de profil |
| `created_at` optional | timestamp | Horodatage de création du compte |
| `last_sign_in_at` optional | timestamp | Dernière connexion pour le scoring d'engagement |
| `app_metadata.provider` optional | string | Fournisseur d'auth (email, google, github, etc.) |
| `confirmed_at` optional | timestamp | Horodatage de confirmation de l'e-mail |

#### Mappage de table personnalisé

```yaml
table_mapping:
  customers:
    # Mappage Colonne → Attribut
    email: email
    full_name: FIRSTNAME
    company: COMPANY
    plan: SUBSCRIPTION_PLAN
    mrr: MONTHLY_REVENUE
    created_at: SIGNUP_DATE

  orders:
    # Suivre en tant qu'événements
    sync_as: events
    event_name: "order_placed"
    properties:
      total: amount
      status: order_status
      items: line_items
```

## Endpoints API

L’API REST Supabase est auto-générée à partir du schéma de votre base de données sur `https://<ref>.supabase.co/rest/v1/`.

| Endpoint | Méthode | Description |
| --- | --- | --- |
| `/rest/v1/{table}` | `GET` | Interroger les lignes avec filtres, tri, pagination |
| `/rest/v1/{table}` | `POST` | Insérer des lignes (bulk et upsert pris en charge) |
| `/rest/v1/{table}` | `PATCH` | Mettre à jour les lignes correspondant aux filtres |
| `/rest/v1/{table}` | `DELETE` | Supprimer les lignes correspondant aux filtres |
| `/rest/v1/rpc/{function}` | `POST` | Appeler une fonction Postgres |
| `/auth/v1/signup` | `POST` | Créer un nouvel utilisateur |
| `/auth/v1/token?grant_type=password` | `POST` | Se connecter avec mot de passe |
| `/auth/v1/user` | `GET` | Obtenir l’utilisateur courant |
| `/auth/v1/admin/users` | `GET` | Lister tous les utilisateurs (service\_role) |
| `/storage/v1/object/{bucket}/{path}` | `POST` | Uploader un fichier |
| `/storage/v1/object/list/{bucket}` | `POST` | Lister les fichiers d’un bucket |
| `/functions/v1/{function_name}` | `POST` | Invoquer une Edge Function |

### Opérateurs de filtrage

| Opérateur | Description | Exemple |
| --- | --- | --- |
| `eq` | Égal | `?status=eq.active` |
| `neq` | Non égal | `?status=neq.deleted` |
| `gt`, `gte` | Supérieur | `?amount=gt.100` |
| `lt`, `lte` | Inférieur | `?created_at=lt.2024-01-01` |
| `like`, `ilike` | Correspondance de motif | `?name=ilike.%john%` |
| `in` | Dans un tableau | `?status=in.(active,trial)` |
| `is` | Vérification null | `?deleted_at=is.null` |

## Événements

### Événements Auth

| Événement | Déclencheur | Cas d’usage |
| --- | --- | --- |
| `user.signed_up` | Inscription d’un nouvel utilisateur | Série de bienvenue |
| `user.signed_in` | Connexion utilisateur | Suivi d’activité |
| `user.updated` | Changements de profil | Synchronisation de données |
| `user.deleted` | Suppression de compte | Workflows de nettoyage |

### Événements base de données (Realtime)

| Événement | Déclencheur | Cas d’usage |
| --- | --- | --- |
| `INSERT` | Nouvelle ligne ajoutée | Notifications nouvelle commande/client |
| `UPDATE` | Ligne modifiée | Workflows de changement de statut |
| `DELETE` | Ligne supprimée | Détection de churn |

### Événements webhook

| Événement | Déclencheur | Cas d’usage |
| --- | --- | --- |
| `auth.user.created` | Inscription utilisateur via webhook | Déclencher l’onboarding |
| `storage.object.created` | Fichier uploadé | Traitement d’assets |

## Exemples de code

### Initialiser le connecteur

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

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

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

### Synchroniser les utilisateurs vers des contacts

```javascript
// Synchroniser tous les utilisateurs Supabase Auth en tant que contacts
await tajo.connectors.sync('supabase', {
  type: 'full',
  resources: ['users'],
});

// Synchronisation incrémentale (uniquement utilisateurs nouveaux/modifiés)
await tajo.connectors.sync('supabase', {
  type: 'incremental',
  resources: ['users'],
  since: '2024-01-01T00:00:00Z',
});
```

### Écouter les changements en temps réel

```javascript
// S'abonner aux nouvelles commandes pour déclencher 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) => {
      // Transférer à Tajo en tant qu'événement
      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();
```

### Requête et segmentation

```javascript
// Interroger les clients par plan pour des campagnes ciblées
const { data: proUsers } = await supabase
  .from('customers')
  .select('email, full_name, plan, mrr')
  .eq('plan', 'pro')
  .gt('mrr', 100)
  .order('mrr', { ascending: false });

// Synchroniser vers une liste Brevo pour cibler des campagnes
await tajo.lists.addContacts(PRO_LIST_ID, proUsers);
```

## Limites de débit

Limites de débit API

Les limites de débit Supabase dépendent de votre plan. Tier Free : 500 requêtes/minute. Pro : 1 000 requêtes/seconde. Contactez Supabase pour les limites Enterprise.

| Plan | Limite de débit | Connexions Realtime |
| --- | --- | --- |
| Free | 500 req/min | 200 simultanées |
| Pro | 1 000 req/s | 500 simultanées |
| Team | 2 000 req/s | 1 000 simultanées |
| Enterprise | Personnalisé | Personnalisé |

## Dépannage

### Problèmes courants

| Problème | Cause | Solution |
| --- | --- | --- |
| 401 Unauthorized | Clé API invalide ou expirée | Vérifiez les clés API dans Supabase Dashboard → Settings → API |
| 403 Forbidden | Politique RLS bloquant l’accès | Utilisez la clé `service_role` pour les opérations admin, ou vérifiez les politiques RLS |
| Aucun événement realtime | Realtime non activé pour la table | Activez-le dans Database → Replication → ajouter la table à la publication |
| Résultats de requête vides | RLS filtrant toutes les lignes | Vérifiez que les politiques RLS autorisent le rôle authentifié à lire |
| L’upload de stockage échoue | Politiques de bucket | Vérifiez que le bucket Storage est public ou a les bonnes politiques RLS |

### Mode debug

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

### Tester la connexion

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

## Bonnes pratiques

1. **Utilisez la clé service\_role uniquement côté serveur**, Ne l’exposez jamais dans du code client
2. **Activez RLS sur toutes les tables**, Même avec service\_role, concevez avec RLS pour une défense en profondeur
3. **Utilisez Realtime pour la synchronisation événementielle**, Plus efficace que le polling pour les changements
4. **Opérations par lots**, Utilisez les inserts en masse et le filtre `in` pour les opérations à fort volume
5. **Mappez les métadonnées utilisateur**, Stockez les champs pertinents pour l’engagement dans `user_metadata` à l’inscription
6. **Utilisez les Edge Functions pour les webhooks**, Traitez les webhooks entrants avec les Supabase Edge Functions pour une gestion à faible latence

## Sécurité

- **Authentification par clé API**, Toutes les requêtes nécessitent des clés API valides
- **Row Level Security (RLS)**, Contrôle d’accès natif Postgres par ligne
- **Vérification JWT**, Les tokens d’auth sont des JWT signés vérifiés à chaque requête
- **SSL/TLS**, Toutes les connexions chiffrées en transit
- **SOC 2 Type II**, Supabase est conforme SOC 2
- **Restrictions réseau**, Allowlist d’IP en option sur les plans payants

## Ressources associées

- [Connecteur Shopify](https://tajo.io/fr/docs/connectors/ecommerce/shopify)
- [Connecteur Stripe](https://tajo.io/fr/docs/connectors/ecommerce/stripe)
- [Connecteur Auth0](https://tajo.io/fr/docs/connectors/custom/auth0)
- [Docs officielle Supabase](https://supabase.com/docs)
- [Guide de l’API REST Supabase](https://supabase.com/docs/guides/api)
- [Guide Supabase Auth](https://supabase.com/docs/guides/auth)