---
title: "PostHog Connector"
description: "Vollständiger Leitfaden zur PostHog-Integration für die Synchronisierung von Produktanalysen, Feature Flags und Nutzerverhaltensdaten mit Brevo über Tajo."
url: https://tajo.io/de/docs/connectors/custom/posthog/
markdown: https://tajo.io/de/docs/connectors/custom/posthog.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.

# PostHog 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 PostHog über Tajo mit Brevo, um Produktanalyse-Daten, Nutzerverhaltens-Events und Cohort-Mitgliedschaften für datengetriebene Marketingkampagnen und personalisiertes Customer Engagement zu synchronisieren.

## Überblick

| Eigenschaft | Wert |
| --- | --- |
| **Plattform** | PostHog |
| **Kategorie** | Product Analytics (Custom) |
| **Einrichtungsaufwand** | Mittel |
| **Offizielle Integration** | Nein |
| **Synchronisierte Daten** | Events, Persons, Feature Flags, Cohorts |
| **Authentifizierung** | Personal API Key / Project Token |

## Funktionen

- **Event-Synchronisation** - Leite PostHog-Analyse-Events an Brevo für verhaltensbasiertes Targeting weiter
- **Person-Profil-Synchronisation** - Synchronisiere PostHog-Person-Eigenschaften als Brevo-Kontaktattribute
- **Cohort-basierte Segmentierung** - Mappe PostHog-Cohorts auf Brevo-Kontaktlisten
- **Feature-Flag-Synchronisation** - Segmentiere Kontakte nach aktivierten Feature Flags
- **Funnel-Daten** - Nutze Conversion-Funnel-Daten für zielgerichtetes Re-Engagement
- **Session-Replay-Metadaten** - Reichere Kontakte mit Session-Engagement-Metriken an

## Voraussetzungen

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

1. Ein PostHog-Konto (Cloud oder selbst gehostet)
2. Einen Personal API Key aus den [PostHog-Einstellungen](https://app.posthog.com/settings/user-api-keys)
3. Deinen Project API Key (Token) aus den [Projekt-Einstellungen](https://app.posthog.com/project/settings)
4. Ein Brevo-Konto mit API-Zugriff
5. Ein Tajo-Konto mit Connector-Berechtigungen

## Authentifizierung

### Personal API Key (Private Endpoints)

```bash
# Generate at https://app.posthog.com/settings/user-api-keys
export POSTHOG_PERSONAL_API_KEY=phx_your_personal_api_key
export POSTHOG_PROJECT_TOKEN=phc_your_project_token
export POSTHOG_HOST=https://us.posthog.com  # or https://eu.posthog.com
export TAJO_API_KEY=your_tajo_api_key
export BREVO_API_KEY=your_brevo_api_key
```

```javascript
// Private API endpoints use Bearer authentication
const headers = {
  'Authorization': `Bearer ${process.env.POSTHOG_PERSONAL_API_KEY}`,
  'Content-Type': 'application/json'
};

// Public endpoints use the project token
const publicHeaders = {
  'Content-Type': 'application/json'
};
// Token is passed in the request body for public endpoints
```

API-Schlüssel-Sicherheit

Personal API Keys bieten vollständigen Kontozugriff. Lege sie niemals in Client-seitigem Code offen. Nutze den Project API Key (Token) für öffentliche Endpoints wie Event-Capture und Feature-Flag-Evaluation.

## Konfiguration

### Grundeinrichtung

```yaml
connectors:
  posthog:
    enabled: true
    host: "${POSTHOG_HOST}"
    personal_api_key: "${POSTHOG_PERSONAL_API_KEY}"
    project_token: "${POSTHOG_PROJECT_TOKEN}"
    project_id: "12345"

    sync:
      persons: true
      events: true
      cohorts: true
      feature_flags: true
      schedule: "0 */3 * * *"  # Every 3 hours

    event_filters:
      - "$pageview"
      - "purchase_completed"
      - "signup_completed"
      - "feature_used"

    lists:
      all_users: 25
      active_users: 26
      power_users: 27
```

### Feld-Mapping

```yaml
field_mapping:
  email: email
  $name: FIRSTNAME
  $browser: BROWSER
  $os: OS
  $initial_referrer: REFERRAL_SOURCE
  total_events: EVENT_COUNT
  last_seen: LAST_ACTIVE_DATE
  signup_date: SIGNUP_DATE
  plan: SUBSCRIPTION_PLAN
  company: COMPANY
  cohort_names: POSTHOG_COHORTS
```

## API-Endpoints

| Endpoint | Methode | Beschreibung |
| --- | --- | --- |
| `{host}/api/projects/{id}/persons/` | GET | Persons auflisten |
| `{host}/api/projects/{id}/events/` | GET | Events auflisten |
| `{host}/api/projects/{id}/cohorts/` | GET | Cohorts auflisten |
| `{host}/api/projects/{id}/feature_flags/` | GET | Feature Flags auflisten |
| `{host}/api/projects/{id}/feature_flags/evaluation/` | POST | Flags evaluieren |
| `{host}/api/projects/{id}/insights/` | GET | Gespeicherte Insights auflisten |
| `{host}/api/projects/{id}/query/` | POST | HogQL-Queries ausführen |
| `{host}/i/v0/e` | POST | Events erfassen (öffentlich) |
| `{host}/decide/?v=3` | POST | Feature-Flag-Decisions (öffentlich) |

## 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('posthog', {
  host: process.env.POSTHOG_HOST,
  personalApiKey: process.env.POSTHOG_PERSONAL_API_KEY,
  projectToken: process.env.POSTHOG_PROJECT_TOKEN,
  projectId: '12345'
});
```

### Persons mit Brevo synchronisieren

```javascript
// Paginate through PostHog persons
let nextUrl = `${posthogHost}/api/projects/${projectId}/persons/?` +
  new URLSearchParams({ limit: '100' });

while (nextUrl) {
  const response = await fetch(nextUrl, {
    headers: {
      'Authorization': `Bearer ${process.env.POSTHOG_PERSONAL_API_KEY}`
    }
  });

  const data = await response.json();

  for (const person of data.results) {
    const email = person.properties.$email || person.properties.email;
    if (!email) continue;

    await tajo.contacts.sync({
      email,
      attributes: {
        FIRSTNAME: person.properties.$name || person.properties.name,
        LAST_ACTIVE_DATE: person.properties.$last_seen,
        SIGNUP_DATE: person.created_at,
        EVENT_COUNT: person.properties.$event_count,
        BROWSER: person.properties.$browser,
        OS: person.properties.$os,
        REFERRAL_SOURCE: person.properties.$initial_referrer
      },
      listIds: [25]
    });
  }

  nextUrl = data.next;
}
```

### Cohorts als Brevo-Listen synchronisieren

```javascript
// Get PostHog cohorts and sync members to Brevo lists
const cohortsResponse = await fetch(
  `${posthogHost}/api/projects/${projectId}/cohorts/`,
  {
    headers: {
      'Authorization': `Bearer ${process.env.POSTHOG_PERSONAL_API_KEY}`
    }
  }
);

const { results: cohorts } = await cohortsResponse.json();

for (const cohort of cohorts) {
  // Get persons in this cohort
  const personsResponse = await fetch(
    `${posthogHost}/api/projects/${projectId}/cohorts/${cohort.id}/persons/`,
    {
      headers: {
        'Authorization': `Bearer ${process.env.POSTHOG_PERSONAL_API_KEY}`
      }
    }
  );

  const { results: persons } = await personsResponse.json();

  for (const person of persons) {
    const email = person.properties.$email || person.properties.email;
    if (email) {
      await tajo.contacts.update(email, {
        attributes: {
          POSTHOG_COHORTS: cohort.name
        }
      });
    }
  }
}
```

### HogQL-Queries für Analysen ausführen

```javascript
// Use HogQL to query analytics data
const queryResponse = await fetch(
  `${posthogHost}/api/projects/${projectId}/query/`,
  {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${process.env.POSTHOG_PERSONAL_API_KEY}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      query: {
        kind: 'HogQLQuery',
        query: `
          SELECT
            properties.$email AS email,
            count() AS event_count,
            max(timestamp) AS last_event
          FROM events
          WHERE event = 'purchase_completed'
            AND timestamp > now() - interval 30 day
          GROUP BY email
          HAVING event_count > 3
          ORDER BY event_count DESC
          LIMIT 1000
        `
      }
    })
  }
);

const queryResult = await queryResponse.json();

for (const row of queryResult.results) {
  await tajo.contacts.update(row[0], {
    attributes: {
      PURCHASE_COUNT_30D: row[1],
      LAST_PURCHASE: row[2]
    }
  });
}
```

## Rate Limits

| Endpoint-Kategorie | Limit | Hinweise |
| --- | --- | --- |
| Analytics-Endpoints | 240/Min, 1.200/Std | GET persons, events, insights |
| Query-Endpoint | 2.400/Std | HogQL und Custom Queries |
| Feature-Flag-Evaluation | 600/Min | Lokaler Evaluation-Endpoint |
| CRUD-Endpoints | 480/Min, 4.800/Std | Create-, Update-, Delete-Operationen |
| Öffentliche Endpoints (Capture) | Unbegrenzt | Event-Capture, Flag-Decisions |

Batch Exports

Nutze für umfangreiche Event-Daten-Exporte das Batch-Export-Feature von PostHog statt der API. Batch Exports unterstützen S3, BigQuery, Snowflake und weitere Ziele.

## Fehlerbehebung

| Problem | Ursache | Lösung |
| --- | --- | --- |
| 401 Unauthorized | Ungültiger API-Schlüssel | Personal API Key in den Einstellungen prüfen |
| 400 Invalid project | Falsche Projekt-ID | Projekt-ID in der PostHog-URL prüfen |
| Leere Persons-Liste | Keine identifizierten Nutzer:innen | Sicherstellen, dass `posthog.identify()` aufgerufen wird |
| Fehlende Properties | Properties nicht gesetzt | `$set`-Aufrufe im Client-SDK prüfen |
| Rate Limit 429 | Zu viele Anfragen | Backoff implementieren, Rate-Limit-Header prüfen |

### Debug-Modus

```yaml
connectors:
  posthog:
    debug: true
    log_level: verbose
    log_queries: true
    log_sync: true
```

## Best Practices

1. **Nutzer:innen identifizieren** - Rufe immer `posthog.identify()` mit E-Mail auf, um Person-Synchronisation zu ermöglichen
2. **Cohorts zur Segmentierung nutzen** - Nutze die verhaltensbasierten Cohorts von PostHog für Brevo-Listen
3. **API-Anfragen bündeln** - Nutze Pagination und Batch-Verarbeitung für große Datensätze
4. **HogQL für komplexe Queries nutzen** - Extrahiere Custom Analytics mit SQL-ähnlichen Queries
5. **Batch Exports einrichten** - Bei großen Datenmengen Batch Exports gegenüber API-Polling bevorzugen
6. **Relevante Events filtern** - Synchronisiere nur marketingrelevante Events, um Rauschen zu reduzieren

## Sicherheit

- **Personal API Key** - Gescoptes Bearer-Token zur Authentifizierung
- **Project Token** - Öffentlicher Token nur für Client-seitige Operationen
- **Nur HTTPS** - Alle Endpoints erfordern TLS-Verschlüsselung
- **IP-Allowlisting** - Verfügbar für selbst gehostete Instanzen
- **Key-Scoping** - Erstelle API-Schlüssel mit spezifischen Berechtigungs-Scopes
- **GitHub Secret Scanning** - PostHog arbeitet mit GitHub zur Erkennung durchgesickerter Schlüssel zusammen

## Verwandte Ressourcen

- [Optimizely Connector](https://tajo.io/de/docs/connectors/custom/optimizely)
- [Segment Connector](https://tajo.io/de/docs/connectors/custom/segment)
- [Snowflake Connector](https://tajo.io/de/docs/connectors/custom/snowflake)
- [PostHog API-Dokumentation](https://posthog.com/docs/api)