PostHog Kompletter Leitfaden 2026: Open-Source-Produktanalyse & AI-Observability-Plattform für Einsteiger

Dev-Tools 2026-07-18 PostHog 产品分析开源工具 AI 可观测性数据驱动

Was ist PostHog?

PostHog ist aktuell die beliebteste Open-Source-Plattform für Produktanalyse und AI-Observability auf GitHub (⭐ über 19.000 Sterne). Im Gegensatz zu proprietären Tools wie Google Analytics vereint PostHog Produktanalyse, Nutzerverhalten-Tracking, A/B-Experimente, Feature Flags und Fehler-Tracking in einer einzigen Open-Source-Plattform – mit vollständiger Datenhoheit.

Warum Entwickler PostHog wählen

Vergleichsaspekt	Google Analytics	Mixpanel	PostHog
Open Source / Self-Hosting	❌	❌	✅ MIT-Lizenz
Datenhoheit	Bei Google	Bei Mixpanel	Bei dir
Session Replay	❌	✅ kostenpflichtig	✅ eingebaut
Feature Flags	❌	❌	✅ eingebaut
A/B-Experimente	❌	✅ kostenpflichtig	✅ eingebaut
AI-Observability	❌	❌	✅ LLM-Aufrufe tracken
Freies Kontingent	Unlimited (aber gesampelt)	1 Mio. Events/Monat	1 Mio. Events/Monat
Preisgestaltung	Enterprise teuer	nach Nutzung	nach Übernutzung

Die Kernaufgabe von PostHog: Produktteams und Entwicklern helfen, Nutzerverhalten zu verstehen und datengetriebene Produktentscheidungen zu treffen. Die Alleinstellungsmerkmale:

All-in-One-Plattform: Ein Tool für Produktanalyse, Web-Analyse, Session Replay, Feature Flags, Experimente, Fehler-Tracking, Logs und Umfragen
AI-Observability: Tracking von LLM-Aufrufen hinsichtlich Latenz, Kosten und generierten Inhalten – ein Differenzierungsmerkmal im Jahr 2026
MCP-Integration: Anbindung an AI-Coding-Tools wie Claude Code und Cursor über das MCP-Protokoll, um Daten direkt im Editor abzufragen
Self-driving-Modus: Erkennt automatisch Rage Clicks, Fehler und gescheiterte Suchanfragen, erstellt Analyseberichte und Pull Requests

Architekturunterschiede: PostHog vs. andere Lösungen

┌─────────────────────────────────────────────────┐
│                   PostHog                        │
├──────────┬──────────┬──────────┬────────────────┤
│Produkt-  │ Session  │ Feature  │ AI-            │
│analyse   │ Replay   │ Flags    │ Observability  │
│(Events)  │          │          │(LLM-Traces)    │
├──────────┴──────────┴──────────┴────────────────┤
│         Einheitliche ClickHouse-Datenengine      │
├─────────────────────────────────────────────────┐
│   Frontend-SDK | Backend-SDK | API | MCP         │
└─────────────────────────────────────────────────┘

PostHog selbst deployen

Option 1: PostHog Cloud (empfohlen)

Der schnellste Weg zum Einstieg, ganz ohne Infrastruktur:

PostHog Cloud US — für Nutzer außerhalb Europas
PostHog Cloud EU — für europäische Nutzer mit Datenschutzanforderungen

Im kostenlosen Kontingent enthalten: 1 Mio. Events, 5.000 Recordings, 1 Mio. Flag-Requests und 100.000 Exceptions pro Monat.

Option 2: One-Click-Deployment mit Docker (Self-Hosting)

Wenn du die volle Datenkontrolle möchtest, bietet PostHog ein extrem simples Hobby-Deployment.

Voraussetzungen: - Linux-Server - Mindestens 4 GB RAM - Docker + Docker Compose

Deployment mit einem Befehl:

BASH

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/posthog/posthog/HEAD/bin/deploy-hobby)"

Nach dem Deployment erreichst du die PostHog-Verwaltungsoberfläche unter http://localhost:8000.

Option 3: Manuelles Deployment mit Docker Compose

Für feinere Konfigurationsmöglichkeiten:

YAML

# docker-compose.yml
version: '3.8'

services:
  posthog:
    image: posthog/posthog:latest
    ports:
      - "8000:8000"
    environment:
      - DATABASE_URL=postgres://posthog:posthog@db:5432/posthog
      - REDIS_URL=redis://redis:6379/
    depends_on:
      - db
      - redis

  db:
    image: postgres:15
    environment:
      POSTGRES_PASSWORD: posthog
    volumes:
      - pgdata:/var/lib/postgresql/data

  redis:
    image: redis:7

volumes:
  pgdata:

BASH

# Dienste starten
docker-compose up -d

# Logs ansehen
docker-compose logs -f posthog

⚠️ Hinweis: Für die Open-Source-Self-Hosting-Version empfehlen wir maximal ~100.000 Events/Monat. Darüber hinaus ist PostHog Cloud die bessere Wahl.

Schnellstart: Deine erste App anbinden

Frontend: JavaScript-SDK

SDK installieren:

BASH

npm install posthog-js

Im Einstiegspunkt deiner App initialisieren:

JAVASCRIPT

import posthog from 'posthog-js';

posthog.init('DEIN_POSTHOG_API_KEY', {
  api_host: 'https://us.posthog.com',  // Bei Self-Hosting: http://dein-server:8000
  autocapture: true,  // Erfasst automatisch alle Klicks, Pageviews etc.
});

// Manuelles Custom Event senden
posthog.capture('user_signed_up', {
  method: 'email',
  plan: 'free',
});

// Benutzer-Identität setzen (bei Login aufrufen)
posthog.identify('user-unique-id-123', {
  email: 'developer@example.com',
  name: 'Max Mustermann',
});

Mit autocapture: true musst du überhaupt keinen Tracking-Code schreiben – jeder Button-Klick, Link-Klick und jedes Formular-Submit wird automatisch erfasst.

Backend: Python-SDK

Für Backend-Events wie erfolgreiche Zahlungen oder erstellte Bestellungen:

BASH

pip install posthog

PYTHON

from posthog import Posthog

# Initialisierung (API-Key am besten per Umgebungsvariable)
posthog = Posthog(
    project_api_key='DEIN_PROJEKT_API_KEY',
    host='https://us.posthog.com'
)

# Event erfassen
posthog.capture(
    distinct_id='user-unique-id-123',
    event='payment_completed',
    properties={
        'amount': 99.00,
        'currency': 'USD',
        'payment_method': 'stripe',
    }
)

# Benutzer-Attribute setzen
posthog.identify(
    distinct_id='user-unique-id-123',
    properties={
        'email': 'developer@example.com',
        'plan': 'pro',
        'company': 'TechCorp',
    }
)

# Client schließen (beim Beenden der App)
posthog.shutdown()

Next.js Full-Stack-Projekt

BASH

npm install posthog-js posthog-node

TSX

// components/PostHogProvider.tsx
import { PostHogProvider as PHProvider } from 'posthog-js/react';
import { useEffect, useState } from 'react';
import posthog from 'posthog-js';

export function PostHogProvider({ children }: { children: React.ReactNode }) {
  const [clientReady, setClientReady] = useState(false);

  useEffect(() => {
    posthog.init(process.env.NEXT_PUBLIC_POSTHOG_KEY!, {
      api_host: process.env.NEXT_PUBLIC_POSTHOG_HOST || 'https://us.posthog.com',
      person_profiles: 'identified_only',
    });
    setClientReady(true);
  }, []);

  if (!clientReady) return null;
  return <PHProvider client={posthog}>{children}</PHProvider>;
}

TSX

// app/layout.tsx
import { PostHogProvider } from '@/components/PostHogProvider';

export default function RootLayout({ children }) {
  return (
    <html lang="de">
      <body>
        <PostHogProvider>{children}</PostHogProvider>
      </body>
    </html>
  );
}

TSX

// app/page.tsx
'use client';
import { usePostHog } from 'posthog-js/react';

export default function HomePage() {
  const posthog = usePostHog();

  return (
    <button onClick={() => {
      posthog.capture('cta_clicked', {
        cta_text: 'Kostenlos testen',
        page: 'homepage',
      });
    }}>
      Jetzt kostenlos testen
    </button>
  );
}

Kernfunktionen in der Praxis

1. Produktanalyse: Nutzerverhalten verstehen

Nach der Datenanbindung generiert PostHog automatisch Trenddiagramme, Funnel-Analysen und Retention-Kurven.

Funnel-Analyse Beispiel: Registrierung → Aktivierung → Bezahlung

SQL

-- PostHog unterstützt direkte SQL-Abfragen (ClickHouse)
SELECT
    event,
    COUNT(DISTINCT distinct_id) as users
FROM events
WHERE event IN ('user_signed_up', 'feature_activated', 'payment_completed')
  AND timestamp > now() - INTERVAL 30 DAY
GROUP BY event
ORDER BY timestamp

In der PostHog-UI: 1. Gehe zu Product Analytics → Funnels 2. Füge Schritte hinzu: user_signed_up → feature_activated → payment_completed 3. Sieh dir die Konversionsrate jedes Schritts an

Retention-Analyse: 1. Gehe zu Product Analytics → Retention 2. Wähle ein Startevent (z. B. user_signed_up) und ein Return-Event (z. B. pageview) 3. Betrachte die D1/D7/D30-Retention-Kurven

2. Session Replay: Echte Nutzeraktionen ansehen

Session Replay zeigt dir die echte Nutzung als Video – mit Mausbewegungen, Scrollen und Klicks.

Konfiguration:

JAVASCRIPT

posthog.init('DEIN_API_KEY', {
  api_host: 'https://us.posthog.com',
  session_recording: {
    maskAllInputs: false,  // Eingaben nicht verdecken (bei sensiblen Daten auf true)
    recordCrossOriginIframes: true,
  },
});

Rage Clicks identifizieren:

JAVASCRIPT

// Wenn ein Nutzer dasselbe Element 5+ Mal schnell anklickt, wird ein Rage-Click-Event ausgelöst
posthog.onFeatureFlags(() => {
  posthog.capture('rageclick', {
    element: document.activeElement.tagName,
    page: window.location.pathname,
  });
});

Im PostHog-Dashboard kannst du: 1. Alle Sessions mit Rage Clicks filtern 2. Die Recordings direkt ansehen und das UI-Problem identifizieren 3. Mit einem Klick ein Issue erstellen und dem Dev-Team zuweisen

3. Feature Flags: Sicheres Rollout

Feature Flags ermöglichen es dir, Features ohne Code-Deployment zu steuern:

JAVASCRIPT

// Prüfen, ob ein Feature für einen Nutzer freigeschaltet ist
posthog.onFeatureFlags(() => {
  const newDashboard = posthog.getFeatureFlag('new-dashboard');

  if (newDashboard) {
    // Neues Dashboard anzeigen
    renderNewDashboard();
  } else {
    // Altes Dashboard beibehalten
    renderOldDashboard();
  }
});

Experimentelles Rollout einrichten:

JAVASCRIPT

// Targeting nach Benutzer-Attributen
posthog.capture('feature_viewed', {
  $feature_flag: 'beta-search',
  $feature_flag_response: true,
});

Im PostHog-Backend: 1. Gehe zu Feature Flags → Create Flag 2. Setze den Namen beta-search 3. Wähle die Rollout-Strategie: - Volles Rollout (100 % der Nutzer) - Prozentuales Rollout (z. B. 10 % der Nutzer) - Gezieltes Rollout (nach E-Mail-Domain, Nutzergruppe) 4. Nach dem Speichern wirkt das SDK sofort – kein Redeployment nötig

4. A/B-Experimente: Datengetriebene Entscheidungen

A/B-Experimente helfen dir, die Wirkung von Feature-Änderungen statistisch abzusichern.

JAVASCRIPT

// Experiment-Code
posthog.onFeatureFlags(() => {
  const experiment = posthog.getFeatureFlag('landing-page-test');

  if (experiment === 'variant-a') {
    showVariantA();
  } else if (experiment === 'variant-b') {
    showVariantB();
  }

  // Experiment-Exposure tracken
  posthog.capture('experiment_exposure', {
    $feature_flag: 'landing-page-test',
    variant: experiment,
  });
});

Experiment in PostHog erstellen: 1. Gehe zu Experiments → Create Experiment 2. Wähle den passenden Feature Flag 3. Definiere die Zielmetrik (z. B. payment_completed-Event) 4. Setze das Signifikanzniveau (üblich: 95 %) 5. Starte das Experiment und warte auf statistische Signifikanz

PostHog berechnet automatisch p-Wert, Konfidenzintervall und Gewinnwahrscheinlichkeit.

5. Fehler-Tracking: Frontend-Exceptions automatisch erfassen

JAVASCRIPT

import posthog from 'posthog-js';

posthog.init('DEIN_API_KEY', {
  api_host: 'https://us.posthog.com',
  capture_performance: true,
});

// Uncaught Errors automatisch erfassen
window.addEventListener('error', (event) => {
  posthog.capture('frontend_error', {
    error_message: event.message,
    error_url: event.filename,
    error_line: event.lineno,
    error_col: event.colno,
    stack: event.error?.stack,
  });
});

// Unhandled Promise Rejections erfassen
window.addEventListener('unhandledrejection', (event) => {
  posthog.capture('promise_rejection', {
    error_message: event.reason?.message || String(event.reason),
  });
});

Auf der Error-Tracking-Seite in PostHog kannst du: - Fehlertrends über Zeit verfolgen - Fehler mit betroffenen Session-Recordings verknüpfen - Alarmregeln einrichten (z. B. Slack-Benachrichtigung bei > 100 Fehlern/Tag)

6. AI-Observability: LLM-Aufrufe tracken

Das ist das Highlight-Feature von PostHog im Jahr 2026, speziell für AI-App-Entwickler.

OpenAI-Aufrufe mit Python-SDK tracken:

BASH

pip install posthog openai

PYTHON

from posthog import Posthog
import openai

posthog = Posthog('DEIN_API_KEY', host='https://us.posthog.com')

def generate_with_tracking(user_id: str, prompt: str):
    import time
    start = time.time()

    response = openai.ChatCompletion.create(
        model="gpt-4",
        messages=[{"role": "user", "content": prompt}]
    )

    latency = time.time() - start
    tokens_used = response.usage.total_tokens

    # LLM-Aufruf tracken
    posthog.capture(
        distinct_id=user_id,
        event='llm_call_completed',
        properties={
            'model': 'gpt-4',
            'prompt_length': len(prompt),
            'response_length': len(response.choices[0].message.content),
            'tokens_used': tokens_used,
            'latency_ms': latency * 1000,
            'success': True,
        }
    )

    return response

Tracking mit LangChain:

PYTHON

from langchain.callbacks import PostHogCallbackHandler

handler = PostHogCallbackHandler(
    api_key='DEIN_API_KEY',
    host='https://us.posthog.com',
    distinct_id='user-123',
)

# In der Chain verwenden
chain = LLMChain(llm=llm, prompt=prompt, callbacks=[handler])
result = chain.run("Hallo, bitte stelle PostHog vor")

Im PostHog-Dashboard siehst du: - Latenzverteilung aller LLM-Aufrufe - Token-Verbrauch und Kostenstatistiken - Fehlerursachen gescheiterter Requests - Aufrufmuster gruppiert nach Nutzer

MCP-Integration: Daten direkt im Editor abfragen

PostHog unterstützt das MCP-Protokoll. Du kannst Produktdaten direkt in Claude Code, Cursor und ähnlichen Tools abfragen.

MCP einrichten (Claude Code):

JSON

// .mcp.json
{
  "mcpServers": {
    "posthog": {
      "command": "npx",
      "args": ["-y", "@posthog/mcp"],
      "env": {
        "POSTHOG_API_KEY": "phc_your_api_key",
        "POSTHOG_PERSONAL_API_KEY": "phx_your_personal_key",
        "POSTHOG_PROJECT_ID": "12345",
        "POSTHOG_API_HOST": "https://us.posthog.com"
      }
    }
  }
}

Nach der Konfiguration kannst du in Claude Code einfach fragen:

> Wie viele Nutzer haben sich in den letzten 7 Tagen registriert?
> Zeig mir den Conversion-Funnel für /dashboard
> Welche Seite hatte gestern die meisten Rage Clicks?

Häufig gestellte Fragen

Reicht die kostenlose Version von PostHog?

Für die meisten Indie-Entwickler und kleinen Teams: Ja. 1 Mio. Events + 5.000 Recordings pro Monat sind in der Regel ausreichend. Bei einer typischen SaaS-Webseite entsprechen 1 Mio. Events etwa 50.000–100.000 MAU.

Was ist der Unterschied zwischen Cloud und Self-Hosting?

	Cloud	Self-Hosting
Betrieb	Kein Aufwand	Docker + DB-Verwaltung nötig
Datenstandort	PostHog-Server	Dein eigener Server
Funktionsumfang	Alle Features	Einige Enterprise-Features nicht verfügbar
Empfohlene Größe	Beliebig	≤ 100.000 Events/Monat
Preis	Frei + pay-per-use	Serverkosten

Hat PostHog großen Performance-Overhead?

Das JavaScript-SDK wird asynchron geladen und blockiert das Rendering der Seite nicht. Das Backend-SDK nutzt eine Queue für Batch-Versand – ohne Einfluss auf die Business-Logik.

Unterstützt PostHog Datenschutz (DSGVO/PIPL)?

Ja. Die PostHog-EU-Instanz erfüllt die DSGVO-Anforderungen. Für den chinesischen Markt kann PIPL durch maskAllInputs und benutzerdefinierte Datenfilterregeln eingehalten werden.

Fazit

PostHog ist die umfassendste Open-Source-Produktanalyseplattform auf dem Markt und ersetzt die Kombination aus Google Analytics + Hotjar + LaunchDarkly + Optimizely + Sentry. Für Entwickler und Produktteams liegt der größte Nutzen in voller Datenhoheit + All-in-One-Erfahrung.

Wichtige Ressourcen: - PostHog-Website - GitHub-Repository ⭐ 19.000+ - Dokumentation - Deployment-Guide - Company Handbook (Open Source)

Wenn dir dieser Artikel geholfen hat, teile ihn gerne mit anderen Entwicklern!

PostHog ist eine beliebte Open-Source-Produktanalyseplattform auf GitHub, die Event-Tracking, Session Replay, Feature Flags, A/B-Tests und AI-Observability bietet. Dieser Artikel zeigt dir Schritt für Schritt, wie du PostHog selbst deployst, Frontend- und Backend-SDKs anbindest und einen vollständigen Produktanalyse-Workflow aufbaust.