---
title: "Supabase-koppling"
description: "Komplett integrationsguide för Supabase för att synkronisera databasposter, användarautentisering, fillagring och realtidshändelser med din engagemangsplattform."
url: https://tajo.io/se/docs/connectors/custom/supabase/
markdown: https://tajo.io/se/docs/connectors/custom/supabase.md
lang: sv-SE
robots: noindex
---

Ansök om tidig åtkomst

Ange ditt förnamn och din e-postadress på jobbet. Vi skickar en länk för att bekräfta din begäran om åtkomst till Tajo.

# Supabase-koppling

Kopplingens status: Planerad Inte byggd än. Tajo kör inte den här kopplingen i dag.

| Källfält | Målfält | Exempelvärde |
| --- | --- | --- |
| `record.id` | `source_id` | `record_1042` |
| `record.updated_at` | `updated_at` | `2026-10-18T08:00:00Z` |
| `record.value` | `value` | `sample_value` |

Anslut ditt Supabase-projekt för att synka databasposter, data för användarautentisering, fillagringshändelser och realtidsändringar för automation av kundengagemang.

## Översikt

| Egenskap | Värde |
| --- | --- |
| **Plattform** | Supabase |
| **Kategori** | Databas & Backend |
| **Installationskomplexitet** | Enkel |
| **Officiell integration** | Nej |
| **Data som synkas** | Användare, tabeller, lagring, händelser |
| **Tillgängliga skills** | 11 |
| **API-typ** | REST (PostgREST) + Realtime WebSocket |
| **Officiella dokument** | [supabase.com/docs](https://supabase.com/docs) |

## Funktioner

- **Autogenererat REST API**, CRUD-operationer på vilken Postgres-tabell som helst via PostgREST, ingen kod krävs
- **Synk av Auth-användare**, Synka Supabase Auth-användare (e-post, telefon, sociala inloggningar) till din engagemangsplattform
- **Realtidsprenumerationer**, Lyssna på INSERT, UPDATE, DELETE-händelser på vilken tabell som helst i realtid
- **Row Level Security**, All API-åtkomst respekterar Postgres RLS-policyer för säker data med flera tenants
- **Lagringsintegration**, Spåra filuppladdningar och hantera tillgångar över Storage-buckets
- **Edge Functions**, Anropa serverlösa Deno-funktioner för anpassad logik och webhooks
- **Fulltextsökning**, Utnyttja Postgres fulltextsökningsfunktioner via API:et

## Förutsättningar

Innan du börjar, se till att du har:

1. Ett Supabase-projekt ([app.supabase.com](https://app.supabase.com/))
2. Ditt projekts **API-URL** och **API-nycklar** (finns i Settings → API)
3. Ett Tajo-konto med API-åtkomst

API-nycklar

Supabase tillhandahåller två nycklar: `anon` (publik, respekterar RLS) och `service_role` (kringgår RLS, adminåtkomst). Använd `service_role` för serversideintegrationer och `anon` för klientsida.

## Autentisering

Supabase använder API-nyckelautentisering. Varje förfrågan kräver `apikey`-headern och valfritt en `Authorization`-bearer-token för användarscoped åtkomst.

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

### Grundinställning

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

### Fältmappning

Mappa Supabase-tabellkolumner till engagemangsplattformsattribut:

#### Standardmappningar för användare

| Parameter | Type | Description |
| --- | --- | --- |
| `email` required | string | Användarens e-post från Supabase Auth (unik identifierare) |
| `phone` optional | string | Telefonnummer för SMS/WhatsApp-engagemang |
| `user_metadata.full_name` optional | string | Visningsnamn från Auth-användarens metadata |
| `user_metadata.avatar_url` optional | string | URL till profilbild |
| `created_at` optional | timestamp | Tidsstämpel för kontoskapande |
| `last_sign_in_at` optional | timestamp | Senaste inloggning för engagemangspoäng |
| `app_metadata.provider` optional | string | Auth-leverantör (email, google, github, etc.) |
| `confirmed_at` optional | timestamp | Tidsstämpel för e-postbekräftelse |

#### Mappning av anpassade tabeller

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

Supabase REST API genereras automatiskt från ditt databasschema på `https://<ref>.supabase.co/rest/v1/`.

| Endpoint | Metod | Beskrivning |
| --- | --- | --- |
| `/rest/v1/{table}` | `GET` | Fråga rader med filtrering, sortering, sidindelning |
| `/rest/v1/{table}` | `POST` | Infoga rader (stöder bulk och upsert) |
| `/rest/v1/{table}` | `PATCH` | Uppdatera rader som matchar filter |
| `/rest/v1/{table}` | `DELETE` | Radera rader som matchar filter |
| `/rest/v1/rpc/{function}` | `POST` | Anropa en Postgres-funktion |
| `/auth/v1/signup` | `POST` | Skapa en ny användare |
| `/auth/v1/token?grant_type=password` | `POST` | Logga in med lösenord |
| `/auth/v1/user` | `GET` | Hämta aktuell användare |
| `/auth/v1/admin/users` | `GET` | Lista alla användare (service\_role) |
| `/storage/v1/object/{bucket}/{path}` | `POST` | Ladda upp fil |
| `/storage/v1/object/list/{bucket}` | `POST` | Lista filer i bucket |
| `/functions/v1/{function_name}` | `POST` | Anropa Edge Function |

### Filtreringsoperatorer

| Operator | Beskrivning | Exempel |
| --- | --- | --- |
| `eq` | Lika med | `?status=eq.active` |
| `neq` | Inte lika med | `?status=neq.deleted` |
| `gt`, `gte` | Större än | `?amount=gt.100` |
| `lt`, `lte` | Mindre än | `?created_at=lt.2024-01-01` |
| `like`, `ilike` | Mönstermatchning | `?name=ilike.%john%` |
| `in` | I array | `?status=in.(active,trial)` |
| `is` | Null-kontroll | `?deleted_at=is.null` |

## Händelser

### Auth-händelser

| Händelse | Utlösare | Användningsfall |
| --- | --- | --- |
| `user.signed_up` | Ny användarregistrering | Välkomstserie |
| `user.signed_in` | Användarinloggning | Aktivitetsspårning |
| `user.updated` | Profiländringar | Datasynk |
| `user.deleted` | Kontoradering | Rensningsarbetsflöden |

### Databashändelser (Realtime)

| Händelse | Utlösare | Användningsfall |
| --- | --- | --- |
| `INSERT` | Ny rad tillagd | Notifieringar för ny beställning/kund |
| `UPDATE` | Rad ändrad | Arbetsflöden för statusändring |
| `DELETE` | Rad borttagen | Churnupptäckt |

### Webhook-händelser

| Händelse | Utlösare | Användningsfall |
| --- | --- | --- |
| `auth.user.created` | Användarregistrering via webhook | Utlös onboarding |
| `storage.object.created` | Fil uppladdad | Tillgångsbearbetning |

## Kodexempel

### Initiera kopplingen

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

### Synka användare till kontakter

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

### Lyssna på realtidsändringar

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

### Fråga och segmentera

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

## Hastighetsbegränsningar

API-hastighetsbegränsningar

Supabases hastighetsbegränsningar beror på din plan. Free tier: 500 förfrågningar/minut. Pro: 1 000 förfrågningar/sekund. Kontakta Supabase för Enterprise-gränser.

| Plan | Hastighetsbegränsning | Realtidsanslutningar |
| --- | --- | --- |
| Free | 500 förfrågningar/min | 200 samtidiga |
| Pro | 1 000 förfrågningar/sek | 500 samtidiga |
| Team | 2 000 förfrågningar/sek | 1 000 samtidiga |
| Enterprise | Anpassad | Anpassad |

## Felsökning

### Vanliga problem

| Problem | Orsak | Lösning |
| --- | --- | --- |
| 401 Unauthorized | Ogiltig eller utgången API-nyckel | Kontrollera API-nycklar i Supabase Dashboard → Settings → API |
| 403 Forbidden | RLS-policy blockerar åtkomst | Använd `service_role`-nyckel för adminoperationer, eller kontrollera RLS-policyer |
| Inga realtidshändelser | Realtime ej aktiverat för tabell | Aktivera i Database → Replication → lägg till tabell i publikation |
| Tomma frågeresultat | RLS filtrerar bort alla rader | Verifiera att RLS-policyer tillåter den autentiserade rollen att läsa |
| Lagringsuppladdning misslyckas | Bucket-policyer | Kontrollera att Storage-bucket är satt till publik eller har korrekta RLS-policyer |

### Felsökningsläge

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

### Testa anslutning

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

## Bästa praxis

1. **Använd service\_role-nyckel endast på serversidan**, Exponera den aldrig i klientkod
2. **Aktivera RLS på alla tabeller**, Även med service\_role, designa med RLS för djupförsvar
3. **Använd Realtime för händelsedriven synk**, Mer effektivt än polling efter ändringar
4. **Batcha operationer**, Använd bulk-insättningar och `in`-filtret för operationer med stor volym
5. **Mappa användarmetadata**, Lagra engagemangsrelevanta fält i `user_metadata` vid registrering
6. **Använd Edge Functions för webhooks**, Behandla inkommande webhooks med Supabase Edge Functions för låg latens

## Säkerhet

- **API-nyckelautentisering**, Alla förfrågningar kräver giltiga API-nycklar
- **Row Level Security (RLS)**, Postgres-nativ åtkomstkontroll per rad
- **JWT-verifiering**, Auth-tokens är signerade JWT:er som verifieras vid varje förfrågan
- **SSL/TLS**, Alla anslutningar krypterade i transit
- **SOC 2 Type II**, Supabase är SOC 2-kompatibel
- **Nätverksbegränsningar**, Valfri IP-allowlisting på betalplaner

## Relaterade resurser

- [Shopify-koppling](https://tajo.io/se/docs/connectors/ecommerce/shopify)
- [Stripe-koppling](https://tajo.io/se/docs/connectors/ecommerce/stripe)
- [Auth0-koppling](https://tajo.io/se/docs/connectors/custom/auth0)
- [Officiella Supabase-dokument](https://supabase.com/docs)
- [Supabase REST API-guide](https://supabase.com/docs/guides/api)
- [Supabase Auth-guide](https://supabase.com/docs/guides/auth)