---
title: "PostHog-kobling"
description: "Fullstendig PostHog-integrasjonsveiledning for synkronisering av produktanalyse, feature flags og brukeratferdsdata med Brevo gjennom Tajo."
url: https://tajo.io/no/docs/connectors/custom/posthog/
markdown: https://tajo.io/no/docs/connectors/custom/posthog.md
lang: no-NO
robots: noindex
---

Be om tidlig tilgang

Skriv inn fornavn og e-postadresse på jobb. Vi sender deg en lenke for å bekrefte forespørselen om tilgang til Tajo.

# PostHog-kobling

Koblingsstatus: Planlagt Ikke bygget ennå. Tajo kjører ikke denne koblingen i dag.

| Kildefelt | Målfelt | Eksempelverdi |
| --- | --- | --- |
| `record.id` | `source_id` | `record_1042` |
| `record.updated_at` | `updated_at` | `2026-10-18T08:00:00Z` |
| `record.value` | `value` | `sample_value` |

Koble PostHog til Brevo gjennom Tajo for å synkronisere produktanalysedata, brukeratferdshendelser og kohortmedlemskap for datadrevne markedsføringskampanjer og personalisert kundeengasjement.

## Oversikt

| Egenskap | Verdi |
| --- | --- |
| **Plattform** | PostHog |
| **Kategori** | Produktanalyse (Custom) |
| **Oppsettskompleksitet** | Moderat |
| **Offisiell integrasjon** | Nei |
| **Synkroniserte data** | Hendelser, personer, feature flags, kohorter |
| **Autentiseringsmetode** | Personlig API-nøkkel / Project Token |

## Funksjoner

- **Hendelsessynkronisering** - Videresend PostHog-analysehendelser til Brevo for atferdsmålretting
- **Synkronisering av personprofiler** - Synkroniser PostHog-personegenskaper til Brevo-kontaktattributter
- **Kohortbasert segmentering** - Mapp PostHog-kohorter til Brevo-kontaktlister
- **Feature flag-synkronisering** - Segmenter kontakter etter aktiverte feature flags
- **Trakt-data** - Bruk konverteringstraktdata for målrettet re-engasjement
- **Metadata for økt-replay** - Berik kontakter med metrikker for øktengasjement

## Forutsetninger

Før du begynner, sørg for at du har:

1. En PostHog-konto (Cloud eller selvhostet)
2. En personlig API-nøkkel fra [PostHog Settings](https://app.posthog.com/settings/user-api-keys)
3. Din Project API Key (token) fra [Project Settings](https://app.posthog.com/project/settings)
4. En Brevo-konto med API-tilgang
5. En Tajo-konto med konnektor-rettigheter

## Autentisering

### Personlig API-nøkkel (private endepunkter)

```bash
# Generer på 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  # eller https://eu.posthog.com
export TAJO_API_KEY=your_tajo_api_key
export BREVO_API_KEY=your_brevo_api_key
```

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

// Offentlige endepunkter bruker Project Token
const publicHeaders = {
  'Content-Type': 'application/json'
};
// Tokenet sendes i forespørselsbody for offentlige endepunkter
```

API-nøkkelsikkerhet

Personlige API-nøkler gir full kontotilgang. Eksponer dem aldri i klientside-kode. Bruk Project API Key (token) for offentlige endepunkter som hendelsesfangst og feature flag-evaluering.

## Konfigurasjon

### Grunnleggende oppsett

```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 * * *"  # Hver 3. time

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

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

### Feltmapping

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

| Endepunkt | Metode | Beskrivelse |
| --- | --- | --- |
| `{host}/api/projects/{id}/persons/` | GET | List personer |
| `{host}/api/projects/{id}/events/` | GET | List hendelser |
| `{host}/api/projects/{id}/cohorts/` | GET | List kohorter |
| `{host}/api/projects/{id}/feature_flags/` | GET | List feature flags |
| `{host}/api/projects/{id}/feature_flags/evaluation/` | POST | Evaluer flags |
| `{host}/api/projects/{id}/insights/` | GET | List lagrede insights |
| `{host}/api/projects/{id}/query/` | POST | Kjør HogQL-spørringer |
| `{host}/i/v0/e` | POST | Fang opp hendelser (offentlig) |
| `{host}/decide/?v=3` | POST | Feature flag-beslutninger (offentlig) |

## Kodeeksempler

### Initialiser kobling

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

### Synkroniser personer til Brevo

```javascript
// Paginer gjennom PostHog-personer
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;
}
```

### Synkroniser kohorter som Brevo-lister

```javascript
// Hent PostHog-kohorter og synkroniser medlemmer til Brevo-lister
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) {
  // Hent personer i denne kohorten
  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
        }
      });
    }
  }
}
```

### Kjør HogQL-spørringer for analyse

```javascript
// Bruk HogQL for å spørre om analysedata
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]
    }
  });
}
```

## Ratebegrensninger

| Endepunktskategori | Grense | Merknader |
| --- | --- | --- |
| Analyseendepunkter | 240/min, 1 200/time | GET personer, hendelser, insights |
| Query-endepunkt | 2 400/time | HogQL og egendefinerte spørringer |
| Feature flag-evaluering | 600/min | Lokalt evalueringsendepunkt |
| CRUD-endepunkter | 480/min, 4 800/time | Opprett, oppdater, slett-operasjoner |
| Offentlige endepunkter (capture) | Ubegrenset | Hendelsesfangst, flag-beslutninger |

Batch-eksport

For storskala eksport av hendelsesdata, bruk PostHogs batch export-funksjon i stedet for API-et. Batch-eksport støtter S3, BigQuery, Snowflake og andre destinasjoner.

## Feilsøking

| Problem | Årsak | Løsning |
| --- | --- | --- |
| 401 Unauthorized | Ugyldig API-nøkkel | Verifiser personlig API-nøkkel i innstillinger |
| 400 Invalid project | Feil prosjekt-ID | Sjekk prosjekt-ID i PostHog-URL |
| Tom personliste | Ingen identifiserte brukere | Sørg for at `posthog.identify()` kalles |
| Manglende egenskaper | Egenskaper ikke satt | Verifiser `$set`-kall i klient-SDK |
| Ratebegrensning 429 | For mange forespørsler | Implementer backoff, sjekk ratebegrensningsheadere |

### Feilsøkingsmodus

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

## Beste praksis

1. **Identifiser brukere** - Kall alltid `posthog.identify()` med e-post for å muliggjøre personsynkronisering
2. **Bruk kohorter for segmentering** - Utnytt PostHogs atferdskohorter for Brevo-lister
3. **Batch API-forespørsler** - Bruk paginering og batch-prosessering for store datasett
4. **Bruk HogQL for komplekse spørringer** - Trekk ut egendefinert analyse med SQL-lignende spørringer
5. **Sett opp batch-eksport** - For store datavolumer, foretrekk batch-eksport fremfor API-polling
6. **Filtrer relevante hendelser** - Synkroniser kun markedsføringsrelevante hendelser for å redusere støy

## Sikkerhet

- **Personlig API-nøkkel** - Avgrenset Bearer-tokenautentisering
- **Project token** - Offentlig token kun for klientside-operasjoner
- **Kun HTTPS** - Alle endepunkter krever TLS-kryptering
- **IP-hviteliste** - Tilgjengelig for selvhostede instanser
- **Nøkkelscoping** - Opprett API-nøkler med spesifikke rettighetsscoper
- **GitHub-hemmelighetsskanning** - PostHog samarbeider med GitHub for deteksjon av lekkede nøkler

## Relaterte ressurser

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