Providers

Choose official providers, understand support by environment, and route events intentionally.

Providers translate trakoo events into the APIs of the services you already use. You can start with one provider, add another later, or route specific methods and event names to the tools that should receive them.

PostHog

Client and server product analytics, feature flags, and session replay

OpenPanel

Client and server web and product analytics with optional session replay

Bento

Client and server lifecycle/email automation for identified users

Pirsch

Client and server privacy-friendly web analytics

EmitKit

Server-only event notifications with channel routing

Visitors

Client-only analytics with optional Stripe revenue attribution

Proxy

Browser queue + server ingest helpers for first-party event delivery

Support matrix

Providers included in trakoo import from trakoo/providers/client and trakoo/providers/server. Providers that wrap a vendor SDK ship as their own package; import them from its /client or /server subpath, such as @trakoo/posthog/client, and install only the SDK for that side. See Installation.

One event, multiple destinations

import { createClientAnalytics } from 'trakoo/client';
import {
  BentoClientProvider,
  VisitorsClientProvider
} from 'trakoo/providers/client';
import { PostHogClientProvider } from '@trakoo/posthog/client';
import { appEvents } from '@/lib/events';

const analytics = createClientAnalytics({
  events: appEvents,
  providers: [
    new PostHogClientProvider({
      token: import.meta.env.VITE_POSTHOG_KEY
    }),
    {
      provider: new BentoClientProvider({
        siteUuid: import.meta.env.VITE_BENTO_SITE_UUID
      }),
      methods: ['identify', 'track']
    },
    new VisitorsClientProvider({
      token: import.meta.env.VITE_VISITORS_TOKEN,
      persist: true
    })
  ]
});

await analytics.track('user_signed_up', {
  email: 'ada@example.com',
  plan: 'pro'
});

The application emits one typed event. trakoo fans it out to each enabled provider.

Routing

Some providers should not receive every call. Bento is usually better for identified user lifecycle events than anonymous page views. EmitKit is usually better for selected events than high-volume click streams. Wrap a provider in a config object to control exactly which methods and events reach it.

import { createClientAnalytics } from 'trakoo/client';
import { BentoClientProvider } from 'trakoo/providers/client';
import { PostHogClientProvider } from '@trakoo/posthog/client';
import { appEvents } from '@/lib/events';

const analytics = createClientAnalytics({
  events: appEvents,
  providers: [
    new PostHogClientProvider({ token: import.meta.env.VITE_POSTHOG_KEY }),
    {
      provider: new BentoClientProvider({
        siteUuid: import.meta.env.VITE_BENTO_SITE_UUID
      }),
      methods: ['identify', 'track'],
      eventPatterns: ['user_*', 'checkout_*']
    }
  ]
});

Routing options are part of the shared provider config:

methods wins over exclude when both are set. events, eventPatterns, and excludeEvents are mutually exclusive; the runtime logs a warning and uses the highest-priority option.

Personal data

An email tool needs the user’s email; a product-analytics tool usually shouldn’t store it. Set pii: false on a provider entry to keep personal data from that provider while the others still receive it:

providers: [
  { provider: new OpenPanelServerProvider({ /* ... */ }), pii: false },
  new BentoServerProvider({ /* ... */ }),
]

A provider with pii: false never receives the email, name, firstName, lastName, or phone traits in identify(), nor the email or those traits in an event’s user context. It still receives the user id, event properties, and the rest of the context. Keep personal data out of event properties themselves: pii doesn’t inspect them.

Browser-to-server delivery

Use the proxy when browser events should go through your domain before reaching server providers.

import { createClientAnalytics } from 'trakoo/client';
import { ProxyProvider } from 'trakoo/providers/client';
import { appEvents } from '@/lib/events';

export const analytics = createClientAnalytics({
  events: appEvents,
  providers: [
    new ProxyProvider({
      endpoint: '/api/events',
      batch: { size: 10, interval: 2000 }
    })
  ]
});

import { createServerAnalytics } from 'trakoo/server';
import { createProxyHandler } from 'trakoo/providers/server';
import { EmitKitServerProvider } from '@trakoo/emitkit/server';
import { appEvents } from '@/lib/events';

const serverAnalytics = createServerAnalytics({
  events: appEvents,
  providers: [
    new EmitKitServerProvider({
      apiKey: process.env.EMITKIT_API_KEY!,
      channelName: 'product-events'
    })
  ]
});

export const POST = createProxyHandler(serverAnalytics);

Build your own provider

If a service is not built in, implement the AnalyticsProvider interface or extend BaseAnalyticsProvider.

import {
  BaseAnalyticsProvider,
  type BaseEvent,
  type EventContext
} from 'trakoo/client';

export class CustomProvider extends BaseAnalyticsProvider {
  name = 'CustomProvider';

  initialize() {}

  track(event: BaseEvent, context?: EventContext) {
    console.log(event.action, event.properties, context);
  }

  identify(userId: string, traits?: Record<string, unknown>) {}

  pageView(properties?: Record<string, unknown>, context?: EventContext) {}

  reset() {}
}

Learn more about custom providers →