---
title: "Konektor PostHog"
description: "Kompletní průvodce integrací PostHog pro synchronizaci produktové analytiky, příznaků funkcí a dat o chování uživatelů s Brevo přes Tajo."
url: https://tajo.io/cz/docs/connectors/custom/posthog/
markdown: https://tajo.io/cz/docs/connectors/custom/posthog.md
lang: cs-CZ
robots: noindex
---

Požádejte o přednostní přístup

Zadejte své jméno a pracovní e-mailovou adresu. Pošleme vám odkaz pro potvrzení žádosti o přístup k Tajo.

# Konektor PostHog

Stav konektoru: Plánováno Zatím nevytvořeno. Tajo tento konektor dnes neprovozuje.

| Zdrojové pole | Cílové pole | Ukázková hodnota |
| --- | --- | --- |
| `record.id` | `source_id` | `record_1042` |
| `record.updated_at` | `updated_at` | `2026-10-18T08:00:00Z` |
| `record.value` | `value` | `sample_value` |

Propojte PostHog s Brevo přes Tajo pro synchronizaci dat produktové analytiky, událostí chování uživatelů a členství v kohortách pro marketingové kampaně řízené daty a personalizované zapojení zákazníků.

## Přehled

| Vlastnost | Hodnota |
| --- | --- |
| **Platforma** | PostHog |
| **Kategorie** | Produktová analytika (Vlastní) |
| **Složitost nastavení** | Střední |
| **Oficiální integrace** | Ne |
| **Synchronizovaná data** | Události, Osoby, Příznaky funkcí, Kohorty |
| **Metoda ověření** | Osobní API klíč / Token projektu |

## Funkce

- **Synchronizace událostí** – Přeposílejte analytické události PostHog do Brevo pro behaviorální cílení
- **Synchronizace profilů osob** – Synchronizujte vlastnosti osob PostHog na atributy kontaktů Brevo
- **Segmentace na základě kohort** – Mapujte kohorty PostHog na seznamy kontaktů Brevo
- **Synchronizace příznaků funkcí** – Segmentujte kontakty podle povolených příznaků funkcí
- **Data funnelů** – Používejte data konverzního funnelu pro cílené opětovné zapojení
- **Metadata přehrávání relací** – Obohacujte kontakty o metriky zapojení relací

## Předpoklady

Než začnete, ujistěte se, že máte:

1. Účet PostHog (Cloud nebo self-hosted)
2. Osobní API klíč z [Nastavení PostHog](https://app.posthog.com/settings/user-api-keys)
3. API klíč projektu (token) z [Nastavení projektu](https://app.posthog.com/project/settings)
4. Účet Brevo s přístupem k API
5. Účet Tajo s oprávněními ke konektoru

## Ověření

### Osobní API klíč (Soukromé koncové body)

```bash
# Vygenerujte na 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  # nebo https://eu.posthog.com
export TAJO_API_KEY=your_tajo_api_key
export BREVO_API_KEY=your_brevo_api_key
```

```javascript
// Soukromé API koncové body používají Bearer ověření
const headers = {
  'Authorization': `Bearer ${process.env.POSTHOG_PERSONAL_API_KEY}`,
  'Content-Type': 'application/json'
};

// Veřejné koncové body používají token projektu
const publicHeaders = {
  'Content-Type': 'application/json'
};
// Token se předává v těle požadavku pro veřejné koncové body
```

Bezpečnost API klíče

Osobní API klíče poskytují plný přístup k účtu. Nikdy je nezveřejňujte v klientském kódu. Používejte API klíč projektu (token) pro veřejné koncové body jako zachytávání událostí a vyhodnocení příznaků funkcí.

## Konfigurace

### Základní nastavení

```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 * * *"  # Každé 3 hodiny

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

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

### Mapování polí

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

## Koncové body API

| Koncový bod | Metoda | Popis |
| --- | --- | --- |
| `{host}/api/projects/{id}/persons/` | GET | Výpis osob |
| `{host}/api/projects/{id}/events/` | GET | Výpis událostí |
| `{host}/api/projects/{id}/cohorts/` | GET | Výpis kohort |
| `{host}/api/projects/{id}/feature_flags/` | GET | Výpis příznaků funkcí |
| `{host}/api/projects/{id}/feature_flags/evaluation/` | POST | Vyhodnocení příznaků |
| `{host}/api/projects/{id}/insights/` | GET | Výpis uložených přehledů |
| `{host}/api/projects/{id}/query/` | POST | Spouštění HogQL dotazů |
| `{host}/i/v0/e` | POST | Zachytávání událostí (veřejné) |
| `{host}/decide/?v=3` | POST | Rozhodnutí o příznacích funkcí (veřejné) |

## Příklady kódu

### Inicializace konektoru

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

### Synchronizace osob do Brevo

```javascript
// Stránkování přes osoby 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;
}
```

### Synchronizace kohort jako seznamů Brevo

```javascript
// Získání kohort PostHog a synchronizace členů do seznamů 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) {
  // Získání osob v této kohortě
  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
        }
      });
    }
  }
}
```

### Spouštění HogQL dotazů pro analytiku

```javascript
// Použití HogQL pro dotazování analytických dat
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]
    }
  });
}
```

## Omezení rychlosti

| Kategorie koncového bodu | Limit | Poznámky |
| --- | --- | --- |
| Analytické koncové body | 240/min, 1 200/hod | GET osoby, události, přehledy |
| Koncový bod dotazů | 2 400/hod | HogQL a vlastní dotazy |
| Vyhodnocení příznaků funkcí | 600/min | Koncový bod lokálního vyhodnocení |
| CRUD koncové body | 480/min, 4 800/hod | Operace vytvoření, aktualizace, smazání |
| Veřejné koncové body (zachytávání) | Neomezeno | Zachytávání událostí, rozhodnutí o příznacích |

Dávkové exporty

Pro exporty dat událostí ve velkém měřítku používejte funkci dávkových exportů PostHog místo API. Dávkové exporty podporují S3, BigQuery, Snowflake a další cílové destinace.

## Řešení problémů

| Problém | Příčina | Řešení |
| --- | --- | --- |
| 401 Unauthorized | Neplatný API klíč | Ověřte osobní API klíč v nastavení |
| 400 Invalid project | Nesprávné ID projektu | Zkontrolujte ID projektu v URL PostHog |
| Prázdný seznam osob | Žádní identifikovaní uživatelé | Zajistěte, aby bylo voláno `posthog.identify()` |
| Chybějící vlastnosti | Vlastnosti nejsou nastaveny | Ověřte volání `$set` v klientském SDK |
| Limit rychlosti 429 | Příliš mnoho požadavků | Implementujte zpětné odběrání, zkontrolujte hlavičky limitu rychlosti |

### Režim ladění

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

## Osvědčené postupy

1. **Identifikujte uživatele** – Vždy volejte `posthog.identify()` s e-mailem pro povolení synchronizace osob
2. **Používejte kohorty pro segmentaci** – Využívejte behaviorální kohorty PostHog pro seznamy Brevo
3. **Dávkujte API požadavky** – Používejte stránkování a dávkové zpracování pro velké datové sady
4. **Používejte HogQL pro složité dotazy** – Extrahujte vlastní analytiku pomocí SQL-like dotazů
5. **Nastavte dávkové exporty** – Pro velké objemy dat upřednostňujte dávkové exporty před pollováním API
6. **Filtrujte relevantní události** – Synchronizujte pouze marketingově relevantní události pro snížení šumu

## Zabezpečení

- **Osobní API klíč** – Ověřování Bearer tokenem s omezeným rozsahem
- **Token projektu** – Veřejný token pouze pro operace na straně klienta
- **Pouze HTTPS** – Všechny koncové body vyžadují šifrování TLS
- **Whitelisting IP** – Dostupné pro self-hosted instance
- **Rozsah klíčů** – Vytvářejte API klíče s konkrétními rozsahy oprávnění
- **Skenování tajných klíčů GitHub** – PostHog spolupracuje s GitHubem na detekci uniklých klíčů

## Související zdroje

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