---
title: "Customer.io Connector"
description: "Vollständiger Leitfaden zur Customer.io-Integration für die Synchronisation von People, Events, Kampagnen und Workflow-Daten mit Brevo über Tajo."
url: https://tajo.io/de/docs/connectors/marketing/customerio/
markdown: https://tajo.io/de/docs/connectors/marketing/customerio.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.

# Customer.io 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 deine Customer.io-Messaging-Plattform mit Brevo für einheitliche Kundendaten, plattformübergreifende Kampagnenkoordination und konsolidierte Engagement-Analytics.

## Überblick

| Eigenschaft | Wert |
| --- | --- |
| **Plattform** | Customer.io |
| **Kategorie** | Marketing |
| **Einrichtungsaufwand** | Mittel |
| **Offizielle Integration** | Nein |
| **Synchronisierte Daten** | People, Events, Kampagnen, Segmente |
| **Genutzte APIs** | Track API, App API, Pipelines API |
| **Authentifizierung** | Site ID + API-Schlüssel / App-API-Schlüssel |
| **Basis-URLs** | `track.customer.io`, `api.customer.io` |

## Funktionen

- **People-Sync** - Bidirektionale Synchronisation der Kundenprofile mit Brevo-Kontakten
- **Event-Weiterleitung** - Tracke Verhaltensevents und leite sie an Brevo weiter, um Automationen auszulösen
- **Kampagnen-Analytics** - Synchronisiere Kampagnen-Performance-Metriken für ein einheitliches Reporting
- **Workflow-Daten** - Spiegele Customer.io-Workflow-Status in Brevo-Kontaktattribute
- **Segment-Replikation** - Repliziere Customer.io-Segmente als Brevo-Listen
- **Object-Data-Sync** - Synchronisiere Non-People-Objekte und Beziehungsdaten

## Voraussetzungen

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

1. Ein Customer.io-Konto mit API-Zugriff
2. Deine Site ID und deinen Track-API-Schlüssel (zu finden unter Settings > API Credentials)
3. Einen App-API-Schlüssel zum Lesen von Kampagnen- und Segmentdaten
4. Ein Brevo-Konto mit API-Zugriff
5. Ein Tajo-Konto mit aktivem Abonnement

## Authentifizierung

Customer.io nutzt zwei getrennte APIs mit unterschiedlichen Authentifizierungsmethoden:

### Track API (Verhaltensdaten)

Wird genutzt, um People, Events und Gerätedaten zu senden. Die Authentifizierung erfolgt über Site ID und API-Schlüssel per Basic Auth.

```bash
# Basic Auth: Site ID as username, API Key as password
curl -X POST https://track.customer.io/api/v1/customers/user123 \
  -u "$SITE_ID:$API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"email": "user@example.com"}'
```

### App API (Daten lesen)

Wird genutzt, um Kampagnen, Segmente und Kundendaten abzurufen. Die Authentifizierung erfolgt über ein Bearer-Token.

```bash
curl -X GET https://api.customer.io/v1/campaigns \
  -H "Authorization: Bearer $APP_API_KEY"
```

Trennung der API-Schlüssel

Der Track-API-Schlüssel und der App-API-Schlüssel sind unterschiedliche Anmeldedaten. Der Track-API-Schlüssel wird zum Schreiben von Daten verwendet, während der App-API-Schlüssel zum Lesen von Daten dient. Für die vollständige Tajo-Integration werden beide benötigt.

### Mit Tajo verbinden

```bash
tajo connectors install customerio \
  --site-id $CIO_SITE_ID \
  --track-api-key $CIO_TRACK_API_KEY \
  --app-api-key $CIO_APP_API_KEY
```

## Konfiguration

### Grundeinrichtung

```yaml
connectors:
  customerio:
    enabled: true
    region: "us"  # or "eu" for EU data center

    sync:
      people: true
      events: true
      campaigns: true
      segments: true
      objects: false

    lists:
      all_contacts: 12
      active_subscribers: 13
      churned: 14
```

### Feldzuordnung

Ordne Customer.io-Person-Attribute den Brevo-Kontaktattributen zu:

```yaml
field_mapping:
  # Standard fields
  id: CIO_ID
  email: email
  first_name: FIRSTNAME
  last_name: LASTNAME
  phone: SMS

  # Engagement metrics
  created_at: SIGNUP_DATE
  last_activity: LAST_ACTIVE
  plan: PLAN_NAME

  # Custom attributes
  company: COMPANY
  role: JOB_TITLE
  mrr: MONTHLY_REVENUE
  lifecycle_stage: LIFECYCLE_STAGE
```

### Event-Mapping

```yaml
event_mapping:
  # Customer.io event -> Brevo event
  purchase_completed: ORDER_PLACED
  subscription_started: SUBSCRIPTION_START
  feature_activated: FEATURE_USED
  support_ticket_opened: SUPPORT_REQUEST
```

## API-Endpoints

Tajo integriert sich mit den folgenden Customer.io-API-Endpoints:

| Endpoint | Methode | API | Zweck |
| --- | --- | --- | --- |
| `/api/v1/customers/{id}` | PUT | Track | Eine Person anlegen oder aktualisieren |
| `/api/v1/customers/{id}/events` | POST | Track | Ein Person-Event tracken |
| `/api/v1/events` | POST | Track | Anonyme Events tracken |
| `/api/v2/entity` | POST | Track | People/Objects anlegen oder aktualisieren (Pipelines) |
| `/v1/campaigns` | GET | App | Kampagnen auflisten |
| `/v1/campaigns/{id}/metrics` | GET | App | Kampagnen-Performance-Metriken |
| `/v1/segments` | GET | App | Segmente auflisten |
| `/v1/segments/{id}/membership` | GET | App | Segment-Mitglieder abrufen |
| `/v1/customers/{id}/attributes` | GET | App | Kundenattribute abrufen |
| `/v1/customers/{id}/activities` | GET | App | Aktivitätsprotokoll einer Kundin/eines Kunden abrufen |

## Code-Beispiele

### Connector initialisieren

```javascript
import { TajoClient } from '@tajo/sdk';

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

await tajo.connectors.connect('customerio', {
  siteId: process.env.CIO_SITE_ID,
  trackApiKey: process.env.CIO_TRACK_API_KEY,
  appApiKey: process.env.CIO_APP_API_KEY,
  region: 'us'
});
```

### People zu Brevo synchronisieren

```javascript
// Incremental sync of Customer.io people
await tajo.connectors.sync('customerio', {
  type: 'incremental',
  resources: ['people'],
  since: '2024-01-01',
  batchSize: 100
});

const status = await tajo.connectors.status('customerio');
console.log(status);
// {
//   connected: true,
//   lastSync: '2024-03-15T14:20:00Z',
//   peopleCount: 32500,
//   campaignsTracked: 18,
//   eventsProcessed: 87000
// }
```

### Events weiterleiten

```javascript
// Forward Customer.io reporting webhook events to Brevo
app.post('/webhooks/customerio', async (req, res) => {
  const events = req.body;

  for (const event of events) {
    await tajo.connectors.handleEvent('customerio', {
      type: event.metric,
      payload: {
        customerId: event.data.customer_id,
        campaignId: event.data.campaign_id,
        timestamp: event.timestamp
      }
    });
  }

  res.status(200).send('OK');
});
```

### Segment exportieren

```javascript
const result = await tajo.connectors.exportSegment('customerio', {
  segmentId: 42,
  targetList: 13,
  includeAttributes: ['email', 'first_name', 'last_name', 'plan']
});

console.log(`Exported ${result.count} people to Brevo list 13`);
```

## Rate Limits

Customer.io wendet je API unterschiedliche Rate Limits an:

| API | Rate Limit | Hinweise |
| --- | --- | --- |
| **Track API** | ~100 Anfragen/Sekunde | Pro Workspace |
| **App API** | 10 Anfragen/Sekunde | Pro API-Schlüssel |
| **Pipelines API** | 100 Anfragen/Sekunde | Empfohlen für Bulk-Daten |
| **Batch-Endpoint** | 1.000 People pro Anfrage | Maximaler Payload 500 KB |

Batch-Endpoints nutzen

Für große Synchronisationen nutzt Tajo den Customer.io-Batch-Endpoint und sendet bis zu 1.000 People pro Anfrage, um die Anzahl der API-Aufrufe deutlich zu reduzieren.

## Fehlerbehebung

### Häufige Probleme

| Problem | Ursache | Lösung |
| --- | --- | --- |
| 401 Unauthorized | Ungültige Site ID oder ungültiger API-Schlüssel | Anmeldedaten unter Customer.io Settings > API überprüfen |
| People werden nicht synchronisiert | Fehlender Identifier | Stelle sicher, dass jede Person eine `id` oder `email` hat |
| Events werden nicht getrackt | Falscher API-Schlüssel-Typ | Für Events den Track-API-Schlüssel nutzen, nicht den App-API-Schlüssel |
| EU-Daten nicht zugreifbar | Falsche Region konfiguriert | Region für EU-Workspaces auf `eu` setzen |
| Rate-Limit-Fehler | Zu viele App-API-Aufrufe | Polling-Frequenz für Kampagnendaten reduzieren |

### Debug-Modus

```yaml
connectors:
  customerio:
    debug: true
    log_level: verbose
    log_api_calls: true
```

### Verbindung testen

```bash
tajo connectors test customerio
# ✓ Track API connection successful
# ✓ App API connection successful
# ✓ People accessible
# ✓ Campaigns readable
# ✓ Segments listable
```

## Best Practices

1. **Pipelines API für Bulk-Daten nutzen** - Die neuere Pipelines API ist für High-Volume-Ingestion optimiert
2. **Reporting-Webhooks einrichten** - Leite Customer.io-E-Mail-Events in Echtzeit an Tajo weiter
3. **Lifecycle-Phasen mappen** - Synchronisiere Customer.io-Segmentmitgliedschaften in Brevo-Attribute
4. **Konsistente Identifier verwenden** - Gleiche `id`-Felder zwischen Customer.io und Brevo ab
5. **Inkrementell synchronisieren** - Vermeide Full-Exports und nutze `last_activity`-Zeitstempel
6. **Webhook-Zustellung überwachen** - Richte Alerts für fehlgeschlagene Webhook-Zustellungen ein

## Sicherheit

- **Basic Auth** - Die Track API authentifiziert sich mit Site ID und API-Schlüssel
- **Bearer Token** - Die App API nutzt OAuth-ähnliche Bearer-Tokens
- **Nur HTTPS** - Die gesamte API-Kommunikation wird per TLS 1.2+ verschlüsselt
- **Regionale Rechenzentren** - EU-Rechenzentrum als Option für die DSGVO-Konformität
- **Verschlüsselte Speicherung** - Alle Anmeldedaten werden in Tajo im Ruhezustand verschlüsselt
- **Webhook-Signaturen** - Webhook-Payloads werden mit HMAC-Signaturen verifiziert

## Verwandte Ressourcen

- [Braze Connector](https://tajo.io/de/docs/connectors/marketing/braze)
- [Iterable Connector](https://tajo.io/de/docs/connectors/marketing/iterable)
- [Customer-Sync-Skill](https://tajo.io/de/docs/skills/data-sync/customer-sync)
- [Brevo Contacts API](https://tajo.io/de/docs/contact-management)