Jitsu

Jitsu is an MIT-licensed event pipeline with 5,100+ GitHub stars that takes Segment-spec track, identify, page and group calls and streams or batches them into your warehouse, and it bills only for events delivered to a destination, so captured events cost nothing.

In this Jitsu review, I’ll take a closer look at Jitsu’s pricing, features, and self-hosting story, so you can see exactly whether it can replace Segment or RudderStack in your stack.

Editor’s note: This Jitsu review is based on my hands-on test of the @jitsu/js 1.11.0 SDK against a local ingest endpoint in October 2026, plus Jitsu Cloud’s documented setup and the 2.14 release. I weigh pricing, tracking SDKs and Segment compatibility, warehouse delivery and Functions, self-hosting, and project health.

Quick verdict: I recommend Jitsu for developer-led teams who want Segment-spec tracking into ClickHouse, BigQuery, Snowflake or Postgres for $99 a month at 2M events. Go in knowing it has about two dozen destinations, a full self-host needs Kubernetes, and identity stitching is Enterprise-only on Cloud.

Key Takeaways:

• The Free plan covers 200k active events a month, and captured events are unlimited on every plan
• Business costs $99/month for 2M active events, then $40 per extra 1M
• The SDK speaks Segment: in my test, identify, track, page and group payloads used the same field names as Segment’s spec
• The Node SDK drops events on failure: an HTTP 500 or unreachable endpoint got one attempt and no retry
• Full self-hosting needs Kubernetes since 2.14, and the Docker Compose setup is deprecated

Pros and Cons

How Much Does Jitsu Cost?

Jitsu never bills a captured event: every plan accepts unlimited incoming events and charges only for active events, meaning events successfully delivered to at least one destination. An event sent to three destinations counts once. An event a Function drops isn’t billed, unless that Function made a fetch call before dropping it, and a Function that multiplies one event into five bills all five.

• Free ($0): for side projects and first pipelines, with 200k active events a month, a provisioned ClickHouse warehouse, manual connector runs plus 1 daily active sync, and up to 7 days of event backups
• Business ($99/month): for production sites past 200k delivered events, with 2M active events, $40 per extra 1M, hourly syncs, 5 monthly active syncs included ($20 each after), up to 90 days of backups and custom domains
• Enterprise (custom): for teams that need identity stitching, Profile Builder, a dedicated ingest shard, OIDC SSO, an uptime SLA and invoice billing, with 1-minute syncs and unlimited active syncs

Plan	Price	Active events	Overage	Connector syncs	Event backups
Free	$0	200k/month	Upgrade required	Manual + 1 daily active sync	Up to 7 days
Business	$99/month	2M/month	$40 per extra 1M	Up to hourly; 5 monthly active syncs, then $20 each	Up to 90 days
Enterprise	Custom	Custom	Custom	Up to 1-minute; unlimited	Custom retention

Jitsu’s plan comparison lists identity stitching and custom domains on every tier, Free included, but Jitsu’s feature terms limit identity stitching and Profile Builder to Enterprise on Cloud and custom domains to Business and Enterprise. I’d plan around the stricter terms and confirm with sales before relying on stitching below Enterprise.

Is Jitsu Good Value for Money?

• Mid-volume event streams: 5M active events cost $99 + 3 x $40 = $219 a month, and 10M cost $99 + 8 x $40 = $419
• High user counts: Segment’s Team plan is $120 for 10,000 monthly tracked users, then $12 per 1,000 to 25,000 and $11 per 1,000 to 100,000, so 50,000 users cost $575 a month on Segment regardless of event volume
• Against RudderStack: RudderStack’s Growth plan starts at $265 a month for 1M events, while 1M delivered events fit inside Jitsu’s $99 Business plan
• Where Jitsu loses: a product with 10,000 users firing 1,000 events each sends 10M events, which is $419 on Jitsu and $120 on Segment’s Team plan, so event-heavy apps with few users are cheaper on per-user billing
• Self-hosting: the MIT license costs nothing, but a full deployment runs Kubernetes, Kafka or Redpanda, ClickHouse, MongoDB and Postgres, and you pay for all of it

Reviewer’s Notes: I’d start on Free, point one site at the provisioned ClickHouse, and move to Business only once delivered events pass 200k a month. Before upgrading, I’d write a Function that drops internal and test traffic, since dropped events never become billable, as long as the Function doesn’t call fetch first.

My Experience With Jitsu

Jitsu’s Node SDK dropped my events without a retry when my mock ingest server returned an HTTP 500, and that one behavior shapes how I’d deploy it. Payload field names, identify traits and privacy flags all behaved the way a Segment user would expect.

Setting Up a Site, Destination and Connection

Jitsu Cloud’s setup runs in four steps:

1. Create a workspace at use.jitsu.com, free up to 200k active events
2. Add a Site under Sites > Add Site, which issues the write keys and a tracking endpoint at <site-id>.d.jitsu.com on Free
3. Add a Destination, either a warehouse or a tool like Mixpanel
4. Create a Connection between the Site and the Destination, pick batch or stream mode, attach any Functions, then embed the snippet

Jitsu Classic users get renamed objects: an API Key is now a Site, a Source is now a Service Connector, and the old Destination is split into Destination, Connection, Function and Sync. Live Events shows incoming events and destination writes.

Sending My First Events With @jitsu/js

I installed @jitsu/js 1.11.0 from npm (MIT license, 0 vulnerabilities reported at install) on Node v26.11.1. In Node, the SDK needs a fetch implementation passed in its options, which the browser build doesn’t.

With s2s: true, my identify, track, page and group calls went to /api/s/s2s/identify, /api/s/s2s/track and so on, with the write key in an x-write-key header in key:secret form. Each JSON body used Segment’s field names: type, event, properties, userId, anonymousId, timestamp, sentAt, messageId and a context object with library, traits, page, clientIds and campaign. The SDK generated the anonymousId as a UUID on its own.

After I called identify("user-42", ...), every later track and page call carried userId “user-42” and the identify traits in context.traits without me passing them again. All 4 events took about 50 ms against localhost.

The echoEvents: true option skipped the network and printed each full event to the console, so I could check payloads without a server.

A write key without a colon threw “Legacy write key detected” and crashed the Node process, because the error fires during plugin initialization rather than on the awaited call. Jitsu Classic keys won’t work with this SDK, so they have to be reissued in key:secret form.

Testing Privacy Controls and Failure Handling

• disableUserIds: the track payload carried no userId, no anonymousId and no context.clientIds
• dontSend: 0 requests left the process
• ipPolicy “remove”: the SDK only added an x-ip-policy header, so IP stripping happens on Jitsu’s server, not in the client
• Unreachable endpoint: with the default errorPolicy “log”, the call resolved immediately, logged “fetch failed”, and the event was gone, with no queue
• HTTP 500: my server saw exactly 1 request over the next 3 seconds, so no retry
• errorPolicy “rethrow”: the error surfaced as an uncaught exception that crashed my script instead of a rejection I could catch around await track()
• 1,000 concurrent track() calls: 1,000 separate POSTs in 564 ms, since the Node SDK doesn’t batch on the client

Reviewer’s Notes: For server-side tracking, I wouldn’t call the Node SDK bare. I’d wrap it in my own queue with retries, or post batches straight to the HTTP API, which implements Segment’s batch endpoint, because a 30-second ingest outage otherwise means 30 seconds of lost events.

Tracking SDKs and Segment Compatibility

Jitsu 2.0 replaced Classic’s custom event format with the Segment spec, so analytics.js-style calls port with little more than a host and write key change.

📦 SDKs and Endpoints

• HTML snippet for sites without a build step
• @jitsu/js, an isomorphic npm package for browser and Node
• @jitsu/jitsu-react for React and Next.js
• HTTP API: POST /api/s/{type} for page, track, identify or group, authenticated by an X-Write-Key header, Basic auth or a query parameter meant for testing only
• Pixel API: a GIF endpoint at /api/px/{type} since v2.8.2, for email opens and ad impressions where only an image request works
• Mobile and server: React Native, iOS, Android and server-to-server

🔁 Migrating From Segment

The JS API is built on Analytics.js, and the HTTP API implements Segment’s batch endpoint, so most Segment client libraries work after a host change. Segment’s Webhooks (Actions) destination can also forward events to Jitsu’s server-to-server endpoint, which lets both pipelines run side by side on the same traffic. RudderStack offers a similar Segment-compatible API, while Snowplow uses its own schema-first tracking SDKs, so moving Segment calls to Snowplow means writing a schema for every event first. Version 2.14 added Segment-style sentAt clock-skew correction.

🍪 Identity and Consent

• Anonymous ID: stored in a __eventn_id cookie by default, renamable through cookieNames
• Ad cookies: the library captures _fbc, _fbp and _ga, which I saw as fbc and fbp slots in context.clientIds
• Safari ITP: an idEndpoint option sets the ID as a server-side httpOnly cookie
• Consent: consentCategories pass through in context.categoryPreferences, but wiring a consent platform such as OneTrust is a manual callback
• IP policy: keep, stripLastOctet or remove

Free workspaces track from a jitsu.com subdomain, and Jitsu warns that ad blockers can drop up to about 30% of data without a custom domain, while Safari’s tracking prevention hits d.jitsu.com cookies. For any production site, I’d budget for Business to get a custom domain.

Warehouse Delivery, Destinations and Functions

Jitsu lists about two dozen destinations against Segment’s 700+ integrations, but its 10 warehouse and storage targets cover the warehouses most data teams run.

Destination type	Examples	Notes
Warehouses	BigQuery, ClickHouse, Snowflake, Redshift, PostgreSQL, MySQL, MongoDB, MotherDuck/DuckDB	Stream or batch; dedup on by default
Block storage	S3, Google Cloud Storage	Batch files
Cloud tools	Amplitude, Mixpanel, PostHog, HubSpot, Salesforce, Google Ads, Resend, SendGrid, Statsig, Xero	Server-side delivery; Functions apply
Device tools	GA4 tag, Hotjar, Microsoft Clarity, generic Tag	Loaded in the browser; no Functions
Generic	Webhook	Any HTTP endpoint

🏛️ Warehouse Destinations

Every warehouse connection runs in stream or batch mode, and Jitsu recommends batch for most warehouses. ClickHouse stream mode carries a “Do not use in production” flag.

Deduplication is on by default. On ClickHouse it uses a ReplacingMergeTree table keyed on message_id, so queries need the FINAL modifier to rule out duplicates before background merges finish. Identity stitching builds on the same mechanism, rewriting older rows in place once an anonymous visitor is identified.

Schema handling is automatic: nested JSON is flattened, camelCase becomes snake_case, and new fields add columns through ALTER TABLE. Schema Freeze routes unknown fields to an _unmapped_data JSON column instead, and a 1,500-column cap is still under development. Column types come from the first value seen, so a property that starts as an integer and later arrives as a decimal fails unless a Function sets the __sql_type_ override.

📤 Cloud and Device Destinations

The cloud list covers product analytics and CRM basics, and GA4 is available both as a server-side destination and as a browser tag, but the catalog has no Facebook Conversions API or Databricks destination. For anything missing, I’d use the Webhook destination or a Function with fetch. A GitHub issue opened October 4, 2026 flagged the Google Ads destination still calling API v22, three days before Google sunset that version, so destination updates can lag.

⚙️ Functions

Functions are async JavaScript default exports that receive the event and a context object:

• Return nothing to keep the event, an object to replace it, “drop” to discard it, or an array to multiply it
• ctx.store: a key-value store with a 31-day default TTL, isolated per workspace
• ctx.fetch, ctx.getWarehouse, ctx.geo and ctx.ua: outbound calls, warehouse queries, geolocation and user-agent parsing

Functions don’t run on device destinations or on connector data. The jitsu-cli scaffolds a TypeScript Functions project with tests, so transformations can live in your own repo with CI. Jitsu doesn’t compute sessions by default; its session recipe is a Function that stamps session IDs with ctx.store.getOrSet and a 1-hour TTL.

🔌 Connectors

Connectors pull data from SaaS sources into the same destinations. Most are wrappers around Airbyte connectors, plus some native ones Jitsu maintains, and sync frequency follows your plan, from 1 daily active sync on Free to 1-minute syncs on Enterprise.

Self-Hosting Jitsu: MIT License, Kubernetes Required

Since version 2.14, a feature-complete Jitsu self-host requires Kubernetes: Functions and profile builders run on operator-managed function servers, and connector syncs run as Kubernetes CronJobs. The Docker Compose setup is deprecated, can’t run Functions, profile builders or syncs, and will be removed. Jitsu’s recommended local path is its development Helm chart on Minikube with at least 8 GB of VM memory.

A production deployment runs seven services, one of them optional, on four required dependencies:

• Console (Next.js), Ingest (Go), Rotor (Node.js), Bulker (Go)
• Function Servers and the Operator, a Kubernetes controller that must be deployed before Rotor or event delivery breaks
• Syncctl (optional) for connector syncs
• Dependencies: PostgreSQL, Kafka or Redpanda, ClickHouse, MongoDB, and optionally Redis

Self-hosting loses event backups, custom domains and the provisioned ClickHouse, but identity stitching and Profile Builder are unrestricted, as long as MongoDB is running.

Version 2.14.0, released July 9, 2026, was the first stable release in nearly a year and carried roughly 1,600 commits. It removed Google Cloud Scheduler support, turned on API rate limiting by default, and added an MCP server in the Console, an OpenAPI spec, SOC 2-oriented activity logs and dead-letter queue reprocessing. Beta builds keep shipping, with 2.15.0-beta.77 tagged on October 12, 2026.

Two contributors account for most commits, roughly 2,890 and 765, so the project leans on a very small core team. Self-hosters have open GitHub issues on a Bulker ingestion stall after a Kafka consumer restart, timestamps changing timezone after an upgrade from 2.7 to 2.11, and GitHub OAuth login breaking on 2.14.

Jitsu’s MIT license is the strongest argument for self-hosting. RudderStack’s server ships under the Elastic License 2.0, which bars offering it as a managed service to third parties, and Snowplow’s core moved to the Snowplow Limited Use License in January 2024, which limits use to non-production or non-commercial purposes without a commercial license. MIT carries neither restriction.

How Does Jitsu Compare to Competitors?

Jitsu is the only tool in this group that bills purely on delivered events under an MIT license, and each rival below still beats it somewhere.

Tool	Pricing unit	Free tier	Entry paid plan	License	Best for
Jitsu	Delivered (active) events	200k events/month	$99/month for 2M events	MIT	Warehouse-first developer teams
Segment	Monthly tracked users	1,000 MTUs	$120/month for 10,000 MTUs	Proprietary	Marketing stacks needing 700+ integrations
RudderStack	Events	250K events/month	$265/month for 1M events	Elastic License 2.0 (server)	Regulated teams needing HIPAA
Snowplow	Quote-based	Not published	Not published	Snowplow Limited Use License	Strict schema governance
PostHog	Events and exported rows	1M analytics events; 10,000 trigger events + 1M exported rows	Usage-based	Open core	Analytics and pipelines in one tool

• Segment: wins on breadth, with 700+ integrations, HIPAA eligibility and its standing as the category default for marketing teams, but its per-user billing counts anonymous visitors and 50,000 users cost $575 a month on Team. Jitsu wins when users are many and events per user are modest.
• RudderStack: wins for regulated teams, since its Enterprise plan adds HIPAA, 5-minute warehouse syncs and Profiles, and Jitsu offers no HIPAA. Its Free plan is slightly larger at 250K events, though warehouse syncs run every 3 hours on Free and every 30 minutes on Growth. Jitsu wins on price at 1M events ($99 against $265) and on license if you plan to host the pipeline for others.
• Snowplow: wins when every event must validate against a schema before it lands, and when data quality matters more than setup speed. Snowplow publishes no price, so budgeting starts with a sales call. Teams that want its design under Apache 2.0 can look at the OpenSnowcat fork. Jitsu wins for anyone who needs a production self-host without a commercial license.
• PostHog: wins if you want session replay, feature flags and experiments next to the pipeline, and its analytics free tier covers 1M events, while Jitsu has no funnels, session replay or experiments planned. Its pipelines allowance is only 10,000 trigger events plus 1M exported rows, so Jitsu wins as a pure pipe into your own warehouse.
• mParticle and Hightouch: mParticle fits enterprises that want a full managed CDP, and Hightouch fits teams whose data already sits in the warehouse and needs to flow out to business tools. Jitsu handles the opposite direction, collecting events into the warehouse, and pairs with Hightouch rather than replacing it.

How I Reviewed Jitsu

I installed @jitsu/js 1.11.0 in Node and pointed it at a local ingest endpoint that logged every request. I ran identify, track, page and group calls, the disableUserIds, dontSend and ipPolicy privacy flags, the echoEvents debug mode, an unreachable endpoint, an HTTP 500, a legacy-format write key and a burst of 1,000 track calls. I didn’t run Jitsu Cloud or the self-hosted stack, so the setup and self-hosting sections describe the documented product.

I compared costs at 1M, 5M and 10M delivered events against Segment’s and RudderStack’s published rates, doing the math myself. For self-hosting, I mapped the services and dependencies a 2.14 deployment needs. I also weighed the 2.14 release, the Classic-to-2.0 migration path and the open GitHub issues self-hosters have filed.

I weighed five areas: pricing, tracking SDKs and Segment compatibility, warehouse delivery and Functions, self-hosting, and project health.

Prices current as of October 2026.

Should You Use Jitsu for Event Tracking?

Jitsu is the cheapest hosted Segment-spec pipeline in this comparison, and the one I’d pick for warehouse-first event tracking. Use it if you’re a developer-led team that wants Segment-spec events in ClickHouse, BigQuery, Snowflake or Postgres without Segment’s per-user bill. My test confirmed the SDK speaks Segment’s spec, and the pricing holds up: 5M delivered events cost $219 a month, and the Free plan includes a ClickHouse warehouse. Functions with a key-value store and warehouse queries give it more transformation power than its price suggests.

The Node SDK drops events on a failed request, so server-side tracking needs your own retry layer, and a full self-host means running Kubernetes, Kafka, ClickHouse, MongoDB and Postgres.

Skip Jitsu if your marketing team needs 100+ tool destinations (Segment fits better), if you need HIPAA (RudderStack Enterprise), or if strict schema enforcement matters more than cost (Snowplow). Teams without anyone to own a Kubernetes cluster should stay on Jitsu Cloud rather than self-host.

My next step would be to open a Free workspace, mirror production traffic into it through Segment’s Webhooks (Actions) destination, and compare the warehouse tables from both pipelines for a week before switching.

FAQs

Is Jitsu free?

Yes. Jitsu Cloud’s Free plan includes 200k active events a month, unlimited captured events and a provisioned ClickHouse warehouse, with no credit card required. Only events delivered to a destination count. Self-hosting is free under the MIT license, though you pay for the Kubernetes, Kafka, ClickHouse, MongoDB and Postgres infrastructure it runs on.

Is Jitsu open source?

Yes. Jitsu is MIT-licensed, with 5,100+ stars on GitHub and commits as recent as October 2026. The MIT license has no restriction on hosting it for others, unlike RudderStack’s Elastic License 2.0. A feature-complete self-host needs Kubernetes since version 2.14, because Docker Compose can’t run Functions or connector syncs.

Is Jitsu a good Segment alternative?

For warehouse-first teams, yes. Its JS SDK is built on Analytics.js, its HTTP API implements Segment’s batch endpoint, and my test showed Segment’s field names in every payload. The trade-off is about two dozen destinations against Segment’s 700+, so marketing-heavy stacks may miss integrations.

What happened to Jitsu Classic?

Jitsu Classic was shut down on March 1, 2025, after Jitsu 2.0 shipped in August 2024. Version 2.0 switched to the Segment event spec and renamed core objects, so API Keys became Sites. Classic write keys don’t work with the current SDK, which requires new keys in key:secret format.

Does Jitsu support identity resolution?

Yes, through Identity Stitching, but only on the Enterprise plan on Jitsu Cloud, even though Jitsu’s plan comparison shows it on every tier. Self-hosted Jitsu doesn’t restrict it, as long as MongoDB is running. Profile Builder, which builds customer profiles in the warehouse, follows the same gating.