PostHog Browser JS Library

import posthog from 'posthog-js';
// Or with named imports
import { posthog, PostHog } from 'posthog-js';

const posthog = require('posthog-js').default;

import posthog from 'posthog-js';

// Initialize
posthog.init('<your-project-api-key>', {
    api_host: 'https://us.i.posthog.com'
});

// Track events
posthog.capture('button_clicked', { button_id: 'signup' });

// Identify users
posthog.identify('user-123', { email: 'user@example.com' });

// Check feature flags
if (posthog.isFeatureEnabled('new-dashboard')) {
    // Show new dashboard
}

// Start session recording
posthog.startSessionRecording();

function capture(event: EventName, properties?: Properties, options?: CaptureOptions): CaptureResult | void;
function register(properties: Properties, days?: number): void;
function register_once(properties: Properties, default_value?: Property, days?: number): void;

function identify(new_distinct_id?: string, userPropertiesToSet?: Properties, userPropertiesToSetOnce?: Properties): void;
function setPersonProperties(userPropertiesToSet?: Properties, userPropertiesToSetOnce?: Properties): void;
function alias(alias: string, original?: string): CaptureResult | void | number;
function reset(reset_device_id?: boolean): void;

function getFeatureFlag(key: string, options?: { send_event?: boolean }): boolean | string | undefined;
function isFeatureEnabled(key: string, options?: { send_event: boolean }): boolean | undefined;
function getFeatureFlagPayload(key: string): JsonType;
function reloadFeatureFlags(): void;
function onFeatureFlags(callback: FeatureFlagsCallback): () => void;

function startSessionRecording(override?: { sampling?: boolean; linked_flag?: boolean; url_trigger?: boolean; event_trigger?: boolean; } | true): void;
function stopSessionRecording(): void;
function sessionRecordingStarted(): boolean;
function get_session_id(): string;
function get_session_replay_url(options?: { withTimestamp?: boolean; timestampLookBack?: number; }): string;

function captureException(error: unknown, additionalProperties?: Properties): CaptureResult | undefined;
function startExceptionAutocapture(config?: ExceptionAutoCaptureConfig): void;
function stopExceptionAutocapture(): void;

function opt_in_capturing(options?: { captureEventName?: EventName | null | false; captureProperties?: Properties; }): void;
function opt_out_capturing(): void;
function has_opted_in_capturing(): boolean;
function has_opted_out_capturing(): boolean;
function get_explicit_consent_status(): 'granted' | 'denied' | 'pending';

// Version and configuration
readonly version: string;
readonly config: PostHogConfig;

// Sub-API instances
readonly featureFlags: PostHogFeatureFlags;
readonly surveys: PostHogSurveys;
readonly conversations: PostHogConversations;
readonly experiments: WebExperiments;
readonly heatmaps: Heatmaps;
readonly productTours: PostHogProductTours;
readonly sessionRecording?: SessionRecording;
readonly toolbar: Toolbar;
readonly exceptions: PostHogExceptions;
readonly consent: ConsentManager;

interface PostHogConfig {
    // Core
    api_host?: string;                                    // API endpoint
    token?: string;                                       // Project API key
    loaded?: (posthog: PostHog) => void;                 // Callback when loaded
    
    // Event Capture
    capture_pageview?: boolean | 'history_change';       // Auto page views
    autocapture?: boolean | AutocaptureConfig;           // Auto click tracking
    capture_exceptions?: boolean | ExceptionAutoCaptureConfig;  // Auto error capture
    
    // Storage
    persistence?: 'cookie' | 'localStorage' | 'sessionStorage' | 'memory' | 'localStorage+cookie';
    disable_persistence?: boolean;
    
    // Privacy
    opt_out_capturing_by_default?: boolean;
    respect_dnt?: boolean;
    cookieless_mode?: 'never' | 'always' | 'on_reject';
    
    // Feature Flags
    advanced_disable_feature_flags?: boolean;
    feature_flag_request_timeout_ms?: number;
    
    // Session Recording
    disable_session_recording?: boolean;
    session_recording?: SessionRecordingOptions;
    
    // Performance
    request_batching?: boolean;
    batch_size?: number;
    batch_max_wait_ms?: number;
    
    // Person Profiles
    person_profiles?: 'always' | 'identified_only' | 'never';
}

type Property = string | number | boolean | null | undefined;
type Properties = Record<string, Property | Property[]>;
type EventName = string;
type JsonType = any;

interface CaptureResult {
    event: string;
    properties: Record<string, any>;
}

interface CaptureOptions {
    send_instantly?: boolean;
    timestamp?: Date;
    $set?: Properties;
    $set_once?: Properties;
}

// Primary instance
posthog.init('token1');

// Named instance
posthog.init('token2', {}, 'secondary');

// Access named instance
posthog.secondary.capture('event');

{
    api_host: 'https://us.i.posthog.com',
    autocapture: true,
    capture_pageview: true,
    persistence: 'localStorage+cookie',
    request_batching: true,
    batch_size: 50,
    session_idle_timeout_seconds: 1800,
    person_profiles: 'identified_only'
}

// User lifecycle
posthog.alias(userId);              // On signup
posthog.identify(userId, props);    // Set properties
posthog.reset();                    // On logout

// Feature flags
posthog.onFeatureFlags(callback);   // Wait for flags
posthog.reloadFeatureFlags();       // Refresh flags

// Groups
posthog.group(type, key, props);    // Associate with group
posthog.getGroups();                // Get current groups