---
title: "Supabase Connector"
description: "Vollständiger Leitfaden zur Supabase-Integration für die Synchronisierung von Datenbank-Datensätzen, Nutzer:innen-Authentifizierung, File Storage und Echtzeit-Events mit deiner Engagement-Plattform."
url: https://tajo.io/de/docs/connectors/custom/supabase/
markdown: https://tajo.io/de/docs/connectors/custom/supabase.md
lang: de-DE
robots: noindex
---

Beantrage frühzeitigen Zugang

Gib deinen Vornamen und deine geschäftliche E-Mail-Adresse ein. Wir senden dir einen Link, mit dem du deine Anfrage für den Tajo-Zugang bestätigst.

# Supabase Connector

Connector-Status: Geplant Noch nicht gebaut. Tajo betreibt diesen Connector heute nicht.

| Quellfeld | Zielfeld | Beispielwert |
| --- | --- | --- |
| `record.id` | `source_id` | `record_1042` |
| `record.updated_at` | `updated_at` | `2026-10-18T08:00:00Z` |
| `record.value` | `value` | `sample_value` |

Verbinde dein Supabase-Projekt, um Datenbank-Datensätze, Nutzer:innen-Authentifizierungsdaten, File-Storage-Events und Echtzeit-Änderungen für die Automation deines Customer Engagements zu synchronisieren.

## Überblick

| Eigenschaft | Wert |
| --- | --- |
| **Plattform** | Supabase |
| **Kategorie** | Database & Backend |
| **Einrichtungsaufwand** | Einfach |
| **Offizielle Integration** | Nein |
| **Synchronisierte Daten** | Nutzer:innen, Tabellen, Storage, Events |
| **Verfügbare Skills** | 11 |
| **API-Typ** | REST (PostgREST) + Realtime WebSocket |
| **Offizielle Docs** | [supabase.com/docs](https://supabase.com/docs) |

## Funktionen

- **Automatisch generierte REST-API**, CRUD-Operationen auf jeder Postgres-Tabelle via PostgREST, kein Code erforderlich
- **Auth-User-Synchronisation**, Synchronisiere Supabase-Auth-Nutzer:innen (E-Mail, Telefon, Social Logins) mit deiner Engagement-Plattform
- **Echtzeit-Subscriptions**, Lausche in Echtzeit auf INSERT-, UPDATE-, DELETE-Events auf jeder Tabelle
- **Row Level Security**, Jeglicher API-Zugriff respektiert Postgres-RLS-Richtlinien für sichere Multi-Tenant-Daten
- **Storage-Integration**, Tracke File-Uploads und verwalte Assets über Storage Buckets
- **Edge Functions**, Rufe serverlose Deno-Funktionen für Custom-Logik und Webhooks auf
- **Full-Text Search**, Nutze die Volltextsuche-Funktionen von Postgres über die API

## Voraussetzungen

Bevor du beginnst, stelle sicher, dass du Folgendes hast:

1. Ein Supabase-Projekt ([app.supabase.com](https://app.supabase.com/))
2. Die **API-URL** und **API-Schlüssel** deines Projekts (zu finden unter Settings → API)
3. Ein Tajo-Konto mit API-Zugriff

API-Schlüssel

Supabase stellt zwei Schlüssel bereit: `anon` (öffentlich, respektiert RLS) und `service_role` (umgeht RLS, Admin-Zugriff). Nutze `service_role` für serverseitige Integrationen und `anon` für den Client.

## Authentifizierung

Supabase nutzt API-Schlüssel-Authentifizierung. Jede Anfrage erfordert den `apikey`-Header und optional einen `Authorization`-Bearer-Token für nutzerspezifischen Zugriff.

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

## Konfiguration

### Grundeinrichtung

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

### Feld-Mapping

Mappe Supabase-Tabellenspalten auf Engagement-Plattform-Attribute:

#### Standard-Nutzer:innen-Mappings

| Parameter | Type | Description |
| --- | --- | --- |
| `email` required | string | Nutzer:innen-E-Mail aus Supabase Auth (eindeutiger Identifier) |
| `phone` optional | string | Telefonnummer fürs SMS-/WhatsApp-Engagement |
| `user_metadata.full_name` optional | string | Anzeigename aus den Auth-User-Metadaten |
| `user_metadata.avatar_url` optional | string | URL des Profilbilds |
| `created_at` optional | timestamp | Zeitstempel der Account-Erstellung |
| `last_sign_in_at` optional | timestamp | Letzter Login fürs Engagement-Scoring |
| `app_metadata.provider` optional | string | Auth-Provider (email, google, github, etc.) |
| `confirmed_at` optional | timestamp | Zeitstempel der E-Mail-Bestätigung |

#### Custom-Tabellen-Mapping

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

## API-Endpoints

Die Supabase-REST-API wird automatisch aus deinem Datenbankschema unter `https://<ref>.supabase.co/rest/v1/` generiert.

| Endpoint | Methode | Beschreibung |
| --- | --- | --- |
| `/rest/v1/{table}` | `GET` | Zeilen mit Filterung, Sortierung, Pagination abfragen |
| `/rest/v1/{table}` | `POST` | Zeilen einfügen (unterstützt Bulk und Upsert) |
| `/rest/v1/{table}` | `PATCH` | Zeilen anhand von Filtern aktualisieren |
| `/rest/v1/{table}` | `DELETE` | Zeilen anhand von Filtern löschen |
| `/rest/v1/rpc/{function}` | `POST` | Postgres-Funktion aufrufen |
| `/auth/v1/signup` | `POST` | Neue Nutzer:in anlegen |
| `/auth/v1/token?grant_type=password` | `POST` | Mit Passwort einloggen |
| `/auth/v1/user` | `GET` | Aktuelle Nutzer:in abrufen |
| `/auth/v1/admin/users` | `GET` | Alle Nutzer:innen auflisten (service\_role) |
| `/storage/v1/object/{bucket}/{path}` | `POST` | Datei hochladen |
| `/storage/v1/object/list/{bucket}` | `POST` | Dateien im Bucket auflisten |
| `/functions/v1/{function_name}` | `POST` | Edge Function aufrufen |

### Filter-Operatoren

| Operator | Beschreibung | Beispiel |
| --- | --- | --- |
| `eq` | Gleich | `?status=eq.active` |
| `neq` | Ungleich | `?status=neq.deleted` |
| `gt`, `gte` | Größer als | `?amount=gt.100` |
| `lt`, `lte` | Kleiner als | `?created_at=lt.2024-01-01` |
| `like`, `ilike` | Pattern-Match | `?name=ilike.%john%` |
| `in` | In Array | `?status=in.(active,trial)` |
| `is` | Null-Prüfung | `?deleted_at=is.null` |

## Events

### Auth-Events

| Event | Trigger | Anwendungsfall |
| --- | --- | --- |
| `user.signed_up` | Neue Nutzer:innen-Registrierung | Welcome-Serie |
| `user.signed_in` | Login | Activity-Tracking |
| `user.updated` | Profiländerungen | Daten-Synchronisation |
| `user.deleted` | Accountlöschung | Cleanup-Workflows |

### Datenbank-Events (Realtime)

| Event | Trigger | Anwendungsfall |
| --- | --- | --- |
| `INSERT` | Neue Zeile hinzugefügt | Benachrichtigungen zu neuen Bestellungen/Kund:innen |
| `UPDATE` | Zeile geändert | Status-Change-Workflows |
| `DELETE` | Zeile entfernt | Churn-Erkennung |

### Webhook-Events

| Event | Trigger | Anwendungsfall |
| --- | --- | --- |
| `auth.user.created` | Nutzer:innen-Signup via Webhook | Onboarding auslösen |
| `storage.object.created` | Datei hochgeladen | Asset-Verarbeitung |

## Code-Beispiele

### Connector initialisieren

```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,
});
```

### Nutzer:innen mit Kontakten synchronisieren

```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',
});
```

### Auf Echtzeit-Änderungen lauschen

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

### Abfragen und segmentieren

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

## Rate Limits

API-Rate-Limits

Die Rate Limits von Supabase hängen von deinem Tarif ab. Free: 500 Anfragen/Minute. Pro: 1.000 Anfragen/Sekunde. Für Enterprise-Limits wende dich an Supabase.

| Tarif | Rate Limit | Realtime-Verbindungen |
| --- | --- | --- |
| Free | 500 Anfr./Min | 200 gleichzeitig |
| Pro | 1.000 Anfr./Sek | 500 gleichzeitig |
| Team | 2.000 Anfr./Sek | 1.000 gleichzeitig |
| Enterprise | Individuell | Individuell |

## Fehlerbehebung

### Häufige Probleme

| Problem | Ursache | Lösung |
| --- | --- | --- |
| 401 Unauthorized | Ungültiger oder abgelaufener API-Schlüssel | API-Schlüssel im Supabase Dashboard → Settings → API prüfen |
| 403 Forbidden | RLS-Richtlinie blockiert Zugriff | `service_role`-Schlüssel für Admin-Operationen nutzen oder RLS-Richtlinien prüfen |
| Keine Realtime-Events | Realtime nicht für Tabelle aktiviert | Unter Database → Replication → Tabelle zur Publication hinzufügen |
| Leere Query-Ergebnisse | RLS filtert alle Zeilen | Sicherstellen, dass RLS-Richtlinien Lesezugriff für die authentifizierte Rolle erlauben |
| Storage-Upload schlägt fehl | Bucket-Richtlinien | Prüfen, ob Storage-Bucket öffentlich ist oder korrekte RLS-Richtlinien hat |

### Debug-Modus

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

### Verbindung testen

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

## Best Practices

1. **service\_role-Schlüssel nur serverseitig nutzen**, Lege ihn nie in Client-Code offen
2. **RLS auf allen Tabellen aktivieren**, Auch mit service\_role: Gestalte mit RLS für Defense in Depth
3. **Realtime für eventgetriebene Synchronisation**, Effizienter als Polling auf Änderungen
4. **Operationen bündeln**, Nutze Bulk-Inserts und den `in`-Filter für Operationen mit hohem Volumen
5. **User-Metadaten mappen**, Speichere engagement-relevante Felder beim Signup in `user_metadata`
6. **Edge Functions für Webhooks nutzen**, Verarbeite eingehende Webhooks mit Supabase Edge Functions für niedrige Latenz

## Sicherheit

- **API-Schlüssel-Authentifizierung**, Alle Anfragen erfordern gültige API-Schlüssel
- **Row Level Security (RLS)**, Postgres-nativer Zugriffsschutz pro Zeile
- **JWT-Verifikation**, Auth-Tokens sind signierte JWTs und werden bei jeder Anfrage verifiziert
- **SSL/TLS**, Alle Verbindungen während der Übertragung verschlüsselt
- **SOC 2 Type II**, Supabase ist SOC-2-konform
- **Network Restrictions**, Optionales IP-Allowlisting in kostenpflichtigen Tarifen

## Verwandte Ressourcen

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