---
title: "So exportierst du Klaviyo-Daten nach Databricks"
description: "Richte Databricks als Outbound-Synchronisierungsziel ein, damit Klaviyo deine Profil-, Ereignis- und Metrikdaten kontinuierlich in Delta-Tabellen in deinem Databricks-Workspace schreibt."
canonical_url: "https://help.klaviyo.com/hc/de-de/articles/56749052645019"
markdown_url: "https://help.klaviyo.com/hc/de-de/articles/56749052645019.md"
locale: "de-de"
category: "Advanced KDP und Personalization"
section: "Synchronisierung"
updated: "2026-10-21"
---

# So exportierst du Klaviyo-Daten nach Databricks

**📝 Note:** **[Advanced Klaviyo Data Platform](https://help.klaviyo.com/hc/de-de/articles/17655007276059.md)** ist nicht in Klaviyos Standard-Marketing-Anwendung enthalten, und für den Zugriff auf die zugehörigen Funktionen ist ein Abonnement erforderlich. Gehe zu unserem [Leitfaden zur Abrechnung](https://help.klaviyo.com/hc/de-de/articles/115000976672.md), um zu erfahren, wie du diesen Plan kaufst.

## Übersicht

Erfahre, wie du Databricks als Ziel für eine Outbound-Synchronisierung einrichtest, damit Klaviyo deine Profil-, Ereignis- und Metrikdaten kontinuierlich in Delta-Tabellen in deinem eigenen Databricks-Workspace schreibt. Nach der Verbindung kann dein Datenteam Klaviyo-Daten mit dem Rest deines Lakehouse für Analyse, Modellierung und Reporting verknüpfen.

Möchtest du stattdessen Daten aus Databricks *in* Klaviyo übertragen? Siehe [Klaviyo und Databricks verbinden](https://help.klaviyo.com/hc/de-de/articles/42790208080283.md).

## Bevor du anfängst

Stelle sicher, dass du Folgendes hast:

- **Einen Databricks-Arbeitsbereich mit aktiviertem Unity Catalog.** Arbeitsbereiche nur mit Hive-Metastore werden nicht unterstützt. Wenn du den Hive-Metastore verwendest, ziehe [Hive-Metastore-Verbund](https://docs.databricks.com/aws/en/query-federation/hms-federation-concepts) in Betracht.

- **Ein SQL-Data-Warehouse**, das `VARIANT` Spalten und sitzungsbezogene temporäre Tabellen unterstützt, damit Klaviyo Daten schreiben kann. Serverlose SQL-Data-Warehouses werden empfohlen; Classic- und Pro-Data-Warehouses können mehrere Minuten zum Starten benötigen, was Synchronisierungen verzögern kann.

- **Berechtigung, Schemata, Tabellen und Berechtigungen** im Katalog zu erstellen, den du verwenden wirst (oder Unterstützung durch eine*n Databricks-Admin).

- Berechtigung zum Verwalten von Integrationen in Klaviyo.

- **Klaviyos ausgehende IP-Adressen auf die Zulassungsliste gesetzt**, wenn dein Workspace eingehenden Traffic mit IP-Zugriffslisten einschränkt:

  - `184.72.183.187/32`

  - `52.206.71.52/32`

  - `3.227.146.32/32`

  - `44.198.39.11/32`

  - `35.172.58.121/32`

  - `3.228.37.244/32`

  - `54.88.219.8/32`

  - `3.214.211.176/32`



**📝 Note:** Du kannst pro Klaviyo-Konto nur 1 Exportziel für Data Warehouses haben. Wenn du bereits in ein anderes Warehouse exportierst (z. B. Snowflake oder S3), musst du dieses Ziel entfernen, bevor du Databricks hinzufügst.

## Schritt 1: Ein Schema für Klaviyo-Daten erstellen

In Databricks befinden sich Schemas innerhalb eines Katalogs. Erstelle ein dediziertes Schema, in dem die Tabellen gespeichert werden, in die Klaviyo schreibt. Die SQL-Beispiele in diesem Artikel verwenden `main` als Katalog und `KLAVIYO_EXPORT` als Schema. Wenn du andere Namen verwendest, ersetze sie in allen SQL-Beispielen und gib in Klaviyo während Schritt 5 dieselben Namen ein.

```sql
USE CATALOG main;  -- or your organization's designated catalog
CREATE SCHEMA IF NOT EXISTS KLAVIYO_EXPORT;
```

## Schritt 2: Die Zieltabellen erstellen

Führe das folgende Skript in dem Schema aus, das du in Schritt 1 erstellt hast. Klaviyo schreibt in 3 Tabellen:

- `**klaviyo_profile**`**:** Eine Zeile pro Profil, einschließlich Standardfeldern, Standort und benutzerdefinierten Eigenschaften.

- `**klaviyo_event**`**:** Eine Zeile pro Ereignis (zum Beispiel *Placed Order* oder *Opened Email*), verknüpft mit einem Profil und einer Metrik.

- `**klaviyo_metric**`**:** Eine Zeile pro Metrik, die verwendet wird, um den Metriknamen und die Quellintegration für jedes Ereignis nachzuschlagen.



Benutzerdefinierte Profileigenschaften und Ereigniseigenschaften werden in `VARIANT` -Spalten gespeichert, sodass du verschachteltes JSON direkt abfragen kannst, ohne Hunderte einzelner Spalten verwalten zu müssen.

```sql
USE SCHEMA main.KLAVIYO_EXPORT;

CREATE TABLE klaviyo_profile (
  id                 STRING NOT NULL,
  external_id        STRING,
  email              STRING,
  phone_number       STRING,
  first_name         STRING,
  last_name          STRING,
  title              STRING,
  organization       STRING,
  properties         VARIANT,
  image              STRING,
  created            TIMESTAMP,
  updated            TIMESTAMP,
  location_address1  STRING,
  location_address2  STRING,
  location_city      STRING,
  location_country   STRING,
  location_latitude  STRING,
  location_longitude STRING,
  location_region    STRING,
  location_zip       STRING,
  PRIMARY KEY (id)
)
TBLPROPERTIES ('delta.feature.variantType-preview' = 'supported');

CREATE TABLE klaviyo_event (
  id               STRING NOT NULL,
  metric_id        STRING NOT NULL,
  profile_id       STRING,
  event_properties VARIANT,
  datetime         TIMESTAMP,
  uuid             STRING,
  PRIMARY KEY (id)
)
TBLPROPERTIES ('delta.feature.variantType-preview' = 'supported');

CREATE TABLE klaviyo_metric (
  id                   STRING NOT NULL,
  name                 STRING NOT NULL,
  integration_id       STRING,
  integration_name     STRING,
  integration_category STRING,
  created              TIMESTAMP,
  updated              TIMESTAMP,
  PRIMARY KEY (id)
);
```

**⚠️ Warning:** Tabellennamen müssen exakt übereinstimmen. Klaviyo sucht im Schema, das du bei der Einrichtung angibst, nach `klaviyo_profile`, `klaviyo_event` und `klaviyo_metric`.

## Schritt 3: Service Principal und Zugriffstoken erstellen

Klaviyo authentifiziert sich bei Databricks mit einem persönlichen Zugriffstoken (PAT). Wir empfehlen, eine*n dedizierte*n Service Principal zu erstellen, der nur für diese Integration verwendet wird, statt das Konto einer Person zu nutzen.

1. Erstelle einen [Dienstprinzipal](https://docs.databricks.com/aws/en/admin/users-groups/service-principals) (oder eine*n Workspace-Nutzer*in) für Klaviyo.

2. Ein persönliches Zugriffstoken generieren:

   - **Serviceprinzipal:** Bitte eine*n Workspace-Admin bitten, [das anfängliche Token mit der Databricks CLI zu erstellen](https://docs.databricks.com/aws/en/dev-tools/auth/pat#create-personal-access-tokens-for-service-principals).

   - **Workspace-Benutzer*in:** [Erstelle ein Token in der Databricks-UI](https://docs.databricks.com/aws/en/dev-tools/auth/pat#create-personal-access-tokens-for-workspace-users).

3. Speichere das Token an einem sicheren Ort. Du fügst es in Schritt 5 in Klaviyo ein.



**⚠️ Warning:** Behandle das Zugriffstoken wie ein Passwort. Jede*r mit dem Token kann mit den Berechtigungen des zugehörigen Kontos auf Databricks zugreifen. Rotiere es regelmäßig und nach Personalwechseln.

Wenn du bereits einen Dienstprinzipal für [den Import aus Databricks](https://help.klaviyo.com/hc/de-de/articles/42790208080283.md) erstellt hast, kannst du ihn wiederverwenden. Füge einfach die Exportberechtigungen in Schritt 4 hinzu.

## Schritt 4: Berechtigungen erteilen

Gewähre dem Klaviyo-Dienstprinzipal Zugriff auf den Katalog, das Schema und das SQL-Warehouse. Ersetze `klaviyo_service_user` durch die Anwendungs-ID oder den Benutzernamen deines Dienstprinzipals.

```sql
GRANT USE CATALOG ON CATALOG main TO `klaviyo_service_user`;
GRANT USE SCHEMA, SELECT, MODIFY ON SCHEMA main.KLAVIYO_EXPORT TO `klaviyo_service_user`;
```

| Berechtigung | Zweck |
| --- | --- |
| `USE CATALOG` | Ermöglicht Klaviyo den Zugriff auf den Katalog, der dein Exportschema enthält. |
| `USE SCHEMA` | Ermöglicht Klaviyo den Zugriff auf das Exportschema. |
| `SELECT` | Ermöglicht Klaviyo, vorhandene Zeilen zu lesen, damit Datensätze aktualisiert werden können, statt sie zu duplizieren. |
| `MODIFY` | Ermöglicht Klaviyo, Zeilen in den Zieltabellen einzufügen, zu aktualisieren und zu löschen. |

Gib dem Serviceprinzipal für das SQL Warehouse, das du verwenden möchtest, außerdem die Berechtigung **Can use**. Gehe in Databricks zu **SQL Warehouses**, wähle dein Warehouse aus, klicke auf **Permissions**, und füge den Serviceprinzipal hinzu.

### Richte dein Setup ein (optional)

Bestätige mit derselben Identität und demselben Token, die du Klaviyo gibst, die Tabellen und Berechtigungen:

```sql
SHOW TABLES IN main.KLAVIYO_EXPORT;
SHOW GRANTS ON SCHEMA main.KLAVIYO_EXPORT;
```

Du solltest alle 3 Tabellen sehen, und der Service Principal sollte mit `USE SCHEMA`, `SELECT` und `MODIFY` aufgeführt sein.

## Schritt 5: Databricks in Klaviyo verbinden

1. Navigiere in Klaviyo zu **Erweitert > Datenmanagement > Synchronisierung**.

2. Wenn du bereits eine Synchronisierung hast, klicke auf **Synchronisierung erstellen**.

3. Wähle **Daten in dein Data Warehouse exportieren** aus.

4. Wähle **Databricks** aus, und klicke dann auf **Mit Databricks verbinden**.

5. Gib deine Verbindungsdetails ein:



| Feld | Beschreibung | Wo du sie findest |
| --- | --- | --- |
| **Name** | Ein Name, mit dem du diese Verbindung identifizieren kannst. | Gib einen aussagekräftigen Namen ein, z. B. Klaviyo-Export. |
| **Server-Hostname** | Der Host deines Databricks-Workspaces. | Die Adressleiste deines Browsers, wenn du bei Databricks angemeldet bist. Beispiel: `abc-12345678.cloud.databricks.com` |
| **HTTP-Pfad** | Der HTTP-Pfad des SQL Warehouse, das Klaviyo verwenden wird. | **SQL-Warehouses** > wähle dein Warehouse aus > **Verbindungsdetails**. Beispiel: `/sql/1.0/warehouses/1234abcd5678efgh` |
| **Katalog** | Der Katalog, der dein Exportschema enthält. | Der Katalog, den du in Schritt 1 verwendet hast (z. B. `main`). |
| **Schema** | Das Schema, das die 3 Klaviyo-Tabellen enthält. | Das Schema, das du in Schritt 1 erstellt hast (z. B. `KLAVIYO_EXPORT`). |
| **Zugangstoken** | Das persönliche Zugriffstoken für die Dienstprinzipal- oder Workspace-Nutzer*in, die du erstellt hast. | Das Token, das du in Schritt 3 generiert hast. |

Klicke auf **Weiter**, um deine Synchronisierung zu konfigurieren.

Du findest Databricks auch im Marketplace für Apps von Klaviyo, indem du zu **Integrationen > Apps erkunden** gehst und nach *Databricks* suchst.

## Schritt 6: Konfiguriere deine Datensynchronisierung

Wähle aus, was Klaviyo an Databricks sendet und wann es synchronisiert wird.

### Datenobjekte

Wähle aus, ob du Profile, Events oder beides synchronisieren möchtest. Metrikdaten werden zusammen mit Events synchronisiert, damit du den Metriknamen und die Quelle jedes Events nachschlagen kannst.

**📝 Note:** Das Synchronisieren aller Daten aus Klaviyo kann deine Databricks-Compute- und -Speicherkosten erhöhen.

### Auszuschließende Integrationen

Wähle alle Integrationen aus, deren Ereignisse du nicht an Databricks senden möchtest. Dies gilt nur für Ereignisdaten; Profile werden dadurch nicht ausgeschlossen.

### Selektive Synchronisierung

Wähle die Metriken aus, deren Ereignisse du synchronisieren möchtest, z. B. Placed Order. Lasse **Selective sync** leer, um alle Ereignisse aus Integrationen zu synchronisieren, die du nicht ausgeschlossen hast. Dieses Feld wird nur angezeigt, wenn du das Datenobjekt **Events** auswählst.

### Synchronisierungshäufigkeit

Wähle unter **Alle** aus, wie oft neue und aktualisierte Daten synchronisiert werden sollen: alle 1, 2, 4, 6, 12 oder 24 Stunden. Der Standardwert beträgt 1 Stunde. Lege **Startdatum**, **Startzeit** und **Zeitzone** für den Zeitplan fest.

### Historische Daten

Wähle aus, wie viele historische Daten während der ersten Synchronisierung gesendet werden sollen:

- 30 Tage

- 90 Tage

- 1 Jahr

- Alle Zeiträume



**📝 Note:** Große historische Synchronisierungen können eine Weile dauern und deine Databricks-Kosten erhöhen. Erwäge, mit einem kürzeren Zeitraum zu beginnen, wenn du nur aktuelle Daten benötigst.

## Schritt 7: Überprüfe, verbinde und überwache deine Synchronisierung

1. Klicke auf **Weiter**, um **Überprüfen** zu öffnen. Überprüfe deine Verbindungsdetails, geteilten Daten, ausgeschlossenen Integrationen, ausgewählten Metriken und den Bereich der initialen Datensynchronisierung.

2. Klicke auf **Verbinden**. Klaviyo testet die Verbindung und erstellt den Export, wenn der Test erfolgreich ist.



Wenn die Einrichtung erfolgreich ist, zeigt Klaviyo eine Bestätigungsnachricht an und bringt dich zurück zu **Synchronisierung**. Dein Export ist aktiviert, und du kannst dort seinen Synchronisierungsstatus überwachen.

Wenn der Verbindungstest fehlschlägt, prüfe die Fehlerdetails. Klicke auf **Anmeldedaten bearbeiten**, um deine Verbindungsdaten zu korrigieren, und klicke dich dann in den Dateneinstellungen über **Weiter** zurück zu **Überprüfen** und klicke erneut auf **Verbinden**.

Um deinen Sync zu überwachen, gehe zu **Advanced > Data management > Syncing** und klicke in der Zeile mit der Kennzeichnung **Export** auf **Databricks**. Verwende diese Tabs:

- **Historisch:** Der Status deines anfänglichen Backfills.

- **Periodisch:** Der Status der Synchronisierungen in deiner ausgewählten Frequenz, einschließlich *Datenaktualität* (wie weit deine Databricks-Tabellen hinter Klaviyo zurückliegen).

- **Einstellungen**: Zeige deine Verbindungsdetails, Datenauswahl, Synchronisierungsintervall und historischen Zeitraum an und bearbeite sie. Klicke auf **Informationen aktualisieren** im Abschnitt, den du änderst, um zu speichern.



Weitere Details zu Synchronisierungsstatus, zum Pausieren und Fortsetzen von Synchronisierungen sowie zum Anzeigen von Fehlerprotokollen findest du unter [Grundlagen zur Data-Warehouse-Synchronisierung in Klaviyo](https://help.klaviyo.com/hc/de-de/articles/17759932376475.md).

## Deine Klaviyo-Daten in Databricks abfragen

Hier sind ein paar Beispiele für den Einstieg.

**Ereignisse nach Metriknamen in den letzten 7 Tagen zählen:**

```sql
SELECT m.name AS metric, COUNT(*) AS events
FROM main.KLAVIYO_EXPORT.klaviyo_event e
JOIN main.KLAVIYO_EXPORT.klaviyo_metric m ON e.metric_id = m.id
WHERE e.datetime >= current_timestamp() - INTERVAL 7 DAYS
GROUP BY m.name
ORDER BY events DESC;
```

**Lies eine benutzerdefinierte Profileigenschaft aus der** `**properties**` **-VARIANT-Spalte:**

```sql
SELECT id, email, properties:loyalty_tier::STRING AS loyalty_tier
FROM main.KLAVIYO_EXPORT.klaviyo_profile
WHERE properties:loyalty_tier IS NOT NULL;
```

**Bestellwert aus Placed-Order-Ereignissen abrufen:**

```sql
SELECT e.profile_id, e.datetime, e.event_properties:`$value`::DOUBLE AS order_value
FROM main.KLAVIYO_EXPORT.klaviyo_event e
JOIN main.KLAVIYO_EXPORT.klaviyo_metric m ON e.metric_id = m.id
WHERE m.name = 'Placed Order';
```

## Fehlerbehebung

| Problem | Was zu prüfen ist |
| --- | --- |
| Der Verbindungstest schlägt mit einem Authentifizierungsfehler fehl | Bestätige, dass der Hostname kein `https://` -Präfix oder keinen nachgestellten Schrägstrich hat und dass das Zugriffstoken gültig ist und nicht abgelaufen ist. |
| Verbindungstest schlägt mit einem Berechtigungsfehler fehl | Bestätige die Berechtigungen in Schritt 4, einschließlich `USE CATALOG` und **Can use** für das SQL Warehouse. |
| Klaviyo kann die Zieltabellen nicht finden | Bestätige, dass der Katalog und das Schema in Klaviyo mit dem Ort übereinstimmen, an dem du das Skript aus Schritt 2 ausgeführt hast, und dass die Tabellennamen exakt `klaviyo_profile`, `klaviyo_event` und `klaviyo_metric` sind. |
| Fehler zum Typ `VARIANT` | Stelle sicher, dass dein SQL Warehouse eine Databricks SQL-Version ausführt, die `VARIANT` unterstützt, und dass die Tabellen mit dem in Schritt 2 gezeigten `TBLPROPERTIES` erstellt wurden. |
| Synchronisierungen starten nur langsam | Das Starten von Classic- und Pro-SQL-Warehouses kann mehrere Minuten dauern. Verwende ein serverloses SQL-Warehouse oder erhöhe die Auto-Stop-Zeit des Warehouses. |
| Anfragen werden blockiert | Wenn dein Workspace IP-Zugriffslisten verwendet, setze die in *Before you begin* aufgeführten Klaviyo-IP-Adressen auf die Whitelist. |

## Einen Databricks-Export entfernen

Wenn du den Export entfernst, werden zukünftige Synchronisierungen beendet. Daten, die bereits in deine Databricks-Tabellen geschrieben wurden, werden nicht gelöscht.

1. Gehe zu **Integrationen** in Klaviyo.

2. Öffne das Menü neben der Databricks-Export-Integration und wähle **Integration entfernen** aus.

3. Klicke im Bestätigungsdialog auf **Integration entfernen**.



## Weitere Ressourcen

- [Klaviyo und Databricks verbinden](https://help.klaviyo.com/hc/de-de/articles/42790208080283.md) (Import)

- [Grundlegendes zur Data-Warehouse-Synchronisierung in Klaviyo](https://help.klaviyo.com/hc/de-de/articles/17759932376475.md)

- [Erste Schritte mit Advanced KDP](https://help.klaviyo.com/hc/de-de/articles/17655007276059.md)
