DOCSEARCHbyAlgolia
Submit Docs

Jitsu Documentation

website·Indexed 34 days ago

https://jitsu.com/docs/

Documentation for Jitsu, an event data ingestion and pipeline platform. Includes guides on sending data via JavaScript, React, React Native, iOS, Android, and HTTP APIs, as well as configuring destinations like BigQuery, Amplitude, and HubSpot. Covers core concepts, the Management API, Jitsu CLI, and data processing features such as Functions, identity stitching, deduplication, and automatic schema management.

Tokens
45.3K
Snippets
156
Records
341
Agent score
68%

What's inside Jitsu

  1. Overview of Jitsu Profile Builder

    Profile Builder is an enterprise feature that creates customer profile records in your warehouse based on event data sent to Jitsu. It primarily generates profiles using the traits object in identify events, but it also supports custom JavaScript functions to define profile generation logic using up to a year's worth of user event data. To enable this feature, contact support at support@jitsu.com.

  2. Overview of Jitsu Observability Exports

    Observability Exports allow you to stream operational data—such as function logs, warehouse delivery statuses, sync results, and processing errors—to an external monitoring stack in near real-time. Data is delivered as OpenTelemetry (OTLP) log records over HTTP, making it compatible with backends like Datadog, Grafana Cloud, New Relic, Elastic, or a custom OpenTelemetry Collector.

    Key Constraints:

    • Available only on Enterprise plans of Jitsu Cloud.
    • Exports operational logs only; raw incoming event traffic is not exported.
    • Export delivery is decoupled from event processing; if the export endpoint is down, events continue to flow to their destinations.
    • Exported records count toward the plan's event volume.

  3. Overview of Jitsu event pipeline

    Jitsu is an open-source event pipeline under the MIT license. It collects events from websites, apps, or servers, allows for real-time JavaScript transformations in flight, and delivers data to warehouses and tools in seconds. It supports three deployment modes: a hosted service, a Jitsu-managed dedicated deployment, or entirely on the user's own servers (including Kubernetes). It is built using Go and backed by ClickHouse.

  4. Overview of Jitsu data ingestion methods

    Jitsu provides multiple ways to ingest events data. Integration methods include using an HTML snippet, the HTTP API, a JavaScript library, React integration, or a Segment Proxy. Interactive, step-by-step instructions for these methods are available within the Jitsu UI under the 'Setup instruction' section of the Site context menu.

  5. Overview of Jitsu event collection

    Jitsu is an open-source (MIT licensed) event collection layer designed to move events from where they happen to a destination (such as a warehouse). Unlike full-stack marketing platforms, Jitsu focuses exclusively on the collection pipe and does not perform reverse ETL or audience building. It is self-hostable and offers published pricing to avoid sales-led procurement.

  6. Overview of Jitsu Production Architecture

    Jitsu is a distributed system consisting of several stateless services configured exclusively via environment variables. For a feature-complete production deployment (starting with Jitsu 2.14), a Kubernetes cluster is required to support Functions, profile builders, and Connector syncs.

    Core Components:

    • Console: Management UI (Next.js).
    • Ingest: Events ingestion API (Go).
    • Rotor: Event pipeline and dispatcher (Node.js).
    • Function Servers: Execute user functions and profile builders (Go). Provisioned automatically by the Operator.
    • Operator: Kubernetes controller that manages function-server deployments and routing tables in Postgres (Go).
    • Bulker: Batches and sends events to warehouse destinations (Go).
    • Syncctl: (Optional) Manages Jitsu Connectors by scheduling Kubernetes CronJobs and pods (Go).

    External Dependencies:

    • PostgreSQL: Configuration and metadata storage.
    • Kafka or Redpanda: Main transport layer between components.
    • ClickHouse: Events log and metrics storage.
    • MongoDB: Required for Identity Stitching, profile builders, and Persistent Storage.
    • Redis: Optional alternative for functions state store.

  7. Overview of Jitsu event pipeline

    Jitsu is an open-source event pipeline under the MIT license. It collects events, transforms them using JavaScript in flight, and delivers them to warehouses and other tools. It can be run as a hosted service, a dedicated deployment, or entirely on your own servers across all tiers.

  8. Overview of Jitsu event pipeline

    Jitsu is an MIT-licensed open-source event pipeline that allows developers to send events without pre-defining a schema. It automatically creates warehouse columns based on the arriving data and provides structured data that is ready to query immediately. For users on the free tier, a ClickHouse database is included, removing the need to provision a separate data warehouse to get started.
    # Jitsu repository
github.com/jitsucom/jitsu

  9. Understand Jitsu 2.14 Kubernetes-native architecture

    Jitsu 2.14 transitions functions, profile builders, and connector syncs from a single shared process to managed Kubernetes workloads. This enables independent scaling, workload isolation, and cloud portability through three primary components:

    • Function Servers: Dedicated pods that execute user-defined JavaScript Functions (for filtering, reshaping, and routing events) and Profile Builder v2 (for aggregating events into user profiles).
    • Jitsu Operator: A Kubernetes operator responsible for creating and reconciling these workloads for each deployment.
    • syncctl: A controller that schedules connector syncs as Kubernetes CronJobs, removing the previous dependency on Google Cloud Scheduler.

  10. Evaluate PostHog for product analytics and data pipelines

    PostHog provides a broad product suite that combines event collection with analysis tools.

    Capabilities:

    • Product analytics and session replay.
    • Feature flags and A/B testing (experiments).
    • CDP-like pipelines to send data to destinations.

    Deployment Options:

    • Self-Hosted: Available via MIT-licensed Docker Compose deployment (user manages infrastructure, scaling, and backups).
    • Cloud: Recommended for most users. Includes a free tier (1M product analytics events/month, 5k session recordings, 1M managed warehouse rows).

  11. Connect an AI agent to Jitsu via MCP

    Jitsu provides an MCP server that allows AI agents to manage pipelines, create destinations, wire up streams, and edit functions. The server is available at https://use.jitsu.com/mcp for Jitsu Cloud. For self-hosted instances, the server is located at /mcp on the console host.

    For interactive clients, authentication uses OAuth 2.1. Upon first use, a browser tab will open for approval, granting the client a scoped, revocable token.

  12. Understand Jitsu's core data flow concepts

    Jitsu manages the flow of event data from sources to destinations using the following primary entities:

    • Sites: Push sources (websites, mobile apps, backend services) that send events to Jitsu.
    • Destinations: Where Jitsu sends events (Databases, SaaS APIs, or client-side JS tags).
    • Connections: Many-to-many links between a Site and a Destination. They define the rules for how data is processed and allow for multiplexing (one site sending to many destinations).
    • Connectors: Pull sources that extract data from external services via API (often based on Airbyte or native Jitsu connectors).
    • Syncs: Many-to-many links between a Connector and a Destination, defining what data to pull and the frequency of the sync.
    • Functions: JavaScript code used for filtering, enriching, and transforming event data.