---
title: "Connecteur PostHog"
description: "Guide complet d'intégration PostHog pour synchroniser analytique produit, feature flags et données de comportement utilisateur avec Brevo via Tajo."
url: https://tajo.io/fr/docs/connectors/custom/posthog/
markdown: https://tajo.io/fr/docs/connectors/custom/posthog.md
lang: fr-FR
robots: noindex
---

Demandez un accès anticipé

Indiquez votre prénom et votre adresse e-mail professionnelle. Nous vous enverrons un lien pour confirmer votre demande d’accès à Tajo.

# Connecteur PostHog

Statut du connecteur: Prévu Pas encore construit. Tajo n'exécute pas ce connecteur aujourd'hui.

| Champ source | Champ de destination | Valeur d’exemple |
| --- | --- | --- |
| `record.id` | `source_id` | `record_1042` |
| `record.updated_at` | `updated_at` | `2026-10-18T08:00:00Z` |
| `record.value` | `value` | `sample_value` |

Connectez PostHog à Brevo via Tajo pour synchroniser les données d’analyse produit, les événements de comportement utilisateur et les appartenances aux cohortes afin de piloter des campagnes marketing data-driven et d’engager les clients de manière personnalisée.

## Vue d’ensemble

| Propriété | Valeur |
| --- | --- |
| **Plateforme** | PostHog |
| **Catégorie** | Product Analytics (Custom) |
| **Complexité d’installation** | Moyenne |
| **Intégration officielle** | Non |
| **Données synchronisées** | Événements, personnes, feature flags, cohortes |
| **Méthode d’authentification** | Personal API Key / Project Token |

## Fonctionnalités

- **Synchronisation d’événements**, Transférez les événements analytiques PostHog vers Brevo pour le ciblage comportemental
- **Synchronisation des profils de personnes**, Synchronisez les propriétés des personnes PostHog vers les attributs de contact Brevo
- **Segmentation basée sur les cohortes**, Mappez les cohortes PostHog vers des listes de contacts Brevo
- **Synchronisation des feature flags**, Segmentez les contacts par feature flags activés
- **Données d’entonnoir**, Utilisez les données d’entonnoir de conversion pour un réengagement ciblé
- **Métadonnées de session replay**, Enrichissez les contacts avec des métriques d’engagement de session

## Prérequis

Avant de commencer, assurez-vous de disposer de :

1. Un compte PostHog (Cloud ou self-hosted)
2. Une Personal API Key depuis [PostHog Settings](https://app.posthog.com/settings/user-api-keys)
3. Votre Project API Key (token) depuis les [paramètres du projet](https://app.posthog.com/project/settings)
4. Un compte Brevo avec accès API
5. Un compte Tajo avec les permissions connecteur

## Authentification

### Personal API Key (endpoints privés)

```bash
# Générez-la sur 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  # ou https://eu.posthog.com
export TAJO_API_KEY=your_tajo_api_key
export BREVO_API_KEY=your_brevo_api_key
```

```javascript
// Les endpoints API privés utilisent l'authentification Bearer
const headers = {
  'Authorization': `Bearer ${process.env.POSTHOG_PERSONAL_API_KEY}`,
  'Content-Type': 'application/json'
};

// Les endpoints publics utilisent le project token
const publicHeaders = {
  'Content-Type': 'application/json'
};
// Le token est passé dans le corps de la requête pour les endpoints publics
```

Sécurité des clés API

Les Personal API keys donnent un accès complet au compte. Ne les exposez jamais dans du code côté client. Utilisez la Project API Key (token) pour les endpoints publics comme la capture d’événements et l’évaluation de feature flags.

## Configuration

### Configuration de base

```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 * * *"  # Toutes les 3 heures

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

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

### Mappage des champs

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

## Endpoints API

| Endpoint | Méthode | Description |
| --- | --- | --- |
| `{host}/api/projects/{id}/persons/` | GET | Lister les personnes |
| `{host}/api/projects/{id}/events/` | GET | Lister les événements |
| `{host}/api/projects/{id}/cohorts/` | GET | Lister les cohortes |
| `{host}/api/projects/{id}/feature_flags/` | GET | Lister les feature flags |
| `{host}/api/projects/{id}/feature_flags/evaluation/` | POST | Évaluer les flags |
| `{host}/api/projects/{id}/insights/` | GET | Lister les insights sauvegardés |
| `{host}/api/projects/{id}/query/` | POST | Exécuter des requêtes HogQL |
| `{host}/i/v0/e` | POST | Capturer des événements (public) |
| `{host}/decide/?v=3` | POST | Décisions de feature flags (public) |

## Exemples de code

### Initialiser le connecteur

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

### Synchroniser les personnes vers Brevo

```javascript
// Paginer les personnes PostHog
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;
}
```

### Synchroniser les cohortes en tant que listes Brevo

```javascript
// Obtenir les cohortes PostHog et synchroniser les membres vers des listes Brevo
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) {
  // Obtenir les personnes de cette cohorte
  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
        }
      });
    }
  }
}
```

### Exécuter des requêtes HogQL pour l’analytique

```javascript
// Utiliser HogQL pour interroger les données analytiques
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]
    }
  });
}
```

## Limites de débit

| Catégorie d’endpoint | Limite | Notes |
| --- | --- | --- |
| Endpoints analytiques | 240/min, 1 200/h | GET persons, events, insights |
| Endpoint query | 2 400/h | HogQL et requêtes personnalisées |
| Évaluation de feature flags | 600/min | Endpoint d’évaluation locale |
| Endpoints CRUD | 480/min, 4 800/h | Opérations create, update, delete |
| Endpoints publics (capture) | Illimité | Capture d’événements, décisions de flags |

Batch exports

Pour les exports d’événements à grande échelle, utilisez la fonctionnalité batch exports de PostHog plutôt que l’API. Les batch exports prennent en charge S3, BigQuery, Snowflake et d’autres destinations.

## Dépannage

| Problème | Cause | Solution |
| --- | --- | --- |
| 401 Unauthorized | Clé API invalide | Vérifiez la Personal API Key dans les paramètres |
| 400 Invalid project | Mauvais project ID | Vérifiez le project ID dans l’URL PostHog |
| Liste de personnes vide | Aucun utilisateur identifié | Assurez-vous que `posthog.identify()` est appelé |
| Propriétés manquantes | Propriétés non définies | Vérifiez les appels `$set` dans le SDK client |
| Limite de débit 429 | Trop de requêtes | Implémentez un backoff, vérifiez les en-têtes de limite |

### Mode debug

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

## Bonnes pratiques

1. **Identifiez les utilisateurs**, Appelez toujours `posthog.identify()` avec l’e-mail pour permettre la synchronisation des personnes
2. **Utilisez les cohortes pour la segmentation**, Exploitez les cohortes comportementales de PostHog pour les listes Brevo
3. **Groupez les requêtes API**, Utilisez la pagination et le traitement par lots pour les grands ensembles de données
4. **Utilisez HogQL pour les requêtes complexes**, Extrayez des analytiques personnalisées avec des requêtes SQL-like
5. **Mettez en place des batch exports**, Pour de gros volumes de données, préférez les batch exports au polling API
6. **Filtrez les événements pertinents**, Ne synchronisez que les événements pertinents pour le marketing pour réduire le bruit

## Sécurité

- **Personal API Key**, Authentification par Bearer token à portée limitée
- **Project token**, Token public pour les opérations côté client uniquement
- **HTTPS uniquement**, Tous les endpoints nécessitent un chiffrement TLS
- **Allowlist d’IP**, Disponible pour les instances self-hosted
- **Portée des clés**, Créez des clés API avec des scopes de permission spécifiques
- **Scanning des secrets GitHub**, PostHog s’associe à GitHub pour la détection des clés fuitées

## Ressources associées

- [Connecteur Optimizely](https://tajo.io/fr/docs/connectors/custom/optimizely)
- [Connecteur Segment](https://tajo.io/fr/docs/connectors/custom/segment)
- [Connecteur Snowflake](https://tajo.io/fr/docs/connectors/custom/snowflake)
- [Documentation de l’API PostHog](https://posthog.com/docs/api)