What is the Jitsu remote MCP server?
The Jitsu remote MCP server is a hosted Model Context Protocol endpoint at https://use.jitsu.com/mcp, so AI assistants can connect to it without installing or running anything locally.
Jitsu MCP ServerVerifiedFeatured
@Jitsu
Basic information
Transport
Streamable HTTP
Authentication
OAuth
Category
Data & Analytics
Author
Jitsu
Submitted by
Soham Mehta
About Jitsu MCP Server
Jitsu is an open-source Customer Data Platform — an MIT-licensed alternative to Segment. This MCP server gives your AI assistant direct control over a Jitsu workspace, so you can run and debug data pipelines in conversation instead of clicking through the console. 25 tools cover the full workflow: • Configuration — inspect and edit destinations, streams, services, and the connections between them, including reading the JSON schema for any resource type before creating or updating it. • Syncs — trigger a sync, cancel a running one, list recent tasks, and pull task logs newest-first when something fails. • Sources — fetch a connector spec, discover available streams, verify credentials, and test a connection before wiring it into production. • Live events — query recent event-log records across incoming streams, function runs, bulker writes, and the dead-letter queue, filtered by source, time range, or search term. • Functions — execute a Jitsu function or profile builder against real data without persisting anything. • Statistics — event throughput, sync history, and profile builder metrics. Every tool carries read-only or destructive annotations, so reads run without interrupting you and anything that modifies or deletes configuration asks first. Authentication is OAuth 2.1 with dynamic client registration — there is no API key to create or paste. You approve access once and the client connects to the workspaces your Jitsu account already has. Works with Jitsu Cloud or a self-hosted instance.
#cdp#analytics#data-pipeline#etl#event-streaming#data-warehouse#clickhouse#segment-alternative#open-source
Connection details
https://use.jitsu.com/mcpSetup
claude mcp add jitsu --transport http https://use.jitsu.com/mcpJitsu MCP Server tools
25List the Jitsu workspaces the authenticated user can access (paginated, max 100 per page). Returns { workspaces, total, limit, offset, hasMore }; page with `offset` while `hasMore` is true. Use a workspace `id` as the `workspaceId` argument to other tools.
List configuration resources of a given type in a workspace. type ∈ {destination, stream, function, service, custom-image, domain, notification, connection}. Use "connection" for connections (links between streams/services and destinations).
Get a single configuration resource by id. type ∈ {destination, stream, function, service, custom-image, domain, notification, connection}.
JSON Schema describing the payload for creating/updating a resource. type ∈ {destination, stream, function, service, custom-image, domain, notification, connection}. Use `subtype` to narrow: a destination/service kind (e.g. "postgres"), or for "connection" the connection kind ("sync", or a destination type for push connections).
Create a configuration resource. type ∈ {destination, stream, function, service, custom-image, domain, notification, connection}. `data` must match get_resource_schema for the type. For "connection", `data` is the connection body: { fromId, toId, type: "push"|"sync", data }.
Update a configuration resource by id (merged into the existing object). type ∈ {destination, stream, function, service, custom-image, domain, notification, connection}. For "connection", `data` is the connection body and the link is upserted by id.
Delete a configuration resource by id (soft delete). type ∈ {destination, stream, function, service, custom-image, domain, notification, connection}.
List the sources (actors) you can pass as `source` to query_events, for a workspace. Optionally narrow by `type`: "incoming" → streams; "function"/"bulker_batch"/"bulker_stream" → connections, destinations, profile builders; "dead-letter" adds the "all" sentinel.
Read recent event-log records for a workspace. type ∈ {incoming, function, bulker_batch, bulker_stream, dead-letter}. `source` filters to one actor (a stream id for "incoming"; a connection id for "function"/"bulker_*"; any actor or "all" for "dead-letter"). Omit `source` (or pass "all") to query across ALL the workspace's sources. Use list_event_sources to discover ids. Results are newest-first, capped by `limit`.
Schedule a sync (a connection of type "sync") to run immediately. Returns the new `taskId`; poll list_sync_tasks with it for status and get_sync_logs for output. If a task is already running the call fails and returns `runningTask` — pass ignoreRunning=true to cancel it and start anyway. fullSync=true drops the saved cursor and re-syncs from scratch.
Cancel a running sync task. Cancellation is asynchronous — poll list_sync_tasks until the task status becomes CANCELLED.
Up to 50 most recent sync tasks in a workspace, newest first. Filter by `syncId`, a single `taskId` (returns `task`), `status` (RUNNING, SUCCESS, PARTIAL, FAILED, CANCELLED, SKIPPED), and a `from`/`to` time window.
Log records of a sync task, newest first (default 200 records, max 5000).
JSON schema of a connector package's credentials (the `credentials` field of a service). ASYNC: the first call starts a fetch on the sync controller and returns `{ ok: false, pending: true }` — call again (every few seconds) until `ok: true` and `specs` is set, or `error` is returned. force=true bypasses the cache.
Ask the connector of an existing service to list its available streams (the catalog used to configure a sync). ASYNC: returns `{ ok: false, pending: true }` while running — call again (every few seconds) until `ok: true` and `catalog` is set. refresh=true re-fetches an already-cached catalog; force=true ignores the cache entirely.
Start an async credentials check for an existing service (source) using its stored config. Returns `{ pending: true, storageKey }` — poll get_source_check_result with the storageKey until it resolves. For destinations use test_connection instead (synchronous).
Poll the result of check_source_credentials: `{ ok: true }` on success, `{ ok: false, error }` on failure, `{ ok: false, pending: true }` while still running.
The saved incremental cursor of a sync, keyed by stream (empty object if none saved).
Delete the saved cursor of a sync so the next run re-syncs from scratch. Pass `stream` to reset a single stream, omit it to reset all. Fails while the sync is running. Returns the remaining state.
Synchronously test destination credentials via bulker. Pass `id` to test an existing destination as stored, or `config` (see get_resource_schema) to test an unsaved config — masked secrets in `config` are resolved from the object referenced by `config.id`. For services (sources) use check_source_credentials instead.
Run a transformation function against a sample event on the workspace's functions server and return the result, logs, and store mutations. `code` omitted → the stored function's draft/code is used. Nothing is persisted; events are not sent anywhere.
Run a profile-builder function against sample events and return the computed profile, logs, and store mutations. `code`/`settings` omitted → loaded from the stored profile builder. Nothing is persisted.
Event counts per period, connection, stream, destination, and status (success/dropped/error) for a workspace. Defaults to the last month with day granularity.
Number of distinct source→destination pairs with at least one successful sync task in the period (defaults to the last month).
Build progress of a profile-builder version: status (ready/building/unknown), processed/total users, and speed. `version` omitted → the current version.
Overview
What is Jitsu?
Jitsu is an open-source Customer Data Platform. It collects event data from your websites, apps, and servers and delivers it to your data warehouse and to whatever other tools you use. It covers the same ground as Segment, but it's MIT-licensed and self-hostable — the whole pipeline can run inside your own infrastructure, or on Jitsu Cloud.
The MCP server ships inside the Jitsu console, so it works with either.
What you can do with it
Connect it and your assistant can run and debug pipelines in conversation instead of clicking through the console:
- Debug a failing sync — list recent sync tasks, pull the logs newest-first, inspect the connection, re-run it.
- Query live events — read the event log across incoming streams, function runs, bulker writes, and the dead-letter queue, filtered by source, time range, or search term.
- Edit configuration — read the JSON schema for a resource type, then create or update destinations, streams, services, and connections.
- Test before shipping — verify source credentials, discover available streams, and run a Jitsu function or profile builder against real data without persisting anything.
Tools
25 tools, grouped by what they touch:
| Area | Tools |
|---|---|
| Configuration | list_workspaces, list_resources, get_resource, get_resource_schema, create_resource, update_resource, delete_resource |
| Syncs | run_sync, cancel_sync, list_sync_tasks, get_sync_logs, get_sync_state, reset_sync_state |
| Sources & connectors | get_connector_spec, discover_streams, check_source_credentials, get_source_check_result, test_connection |
| Events & functions | list_event_sources, query_events, run_function, run_profile_builder |
| Statistics | get_event_stat, get_sync_stat, get_profile_builder_stats |
Every tool declares a title and the applicable readOnlyHint / destructiveHint. Thirteen are read-only, so your client can run them without a confirmation prompt; anything that modifies or deletes configuration is marked destructive and asks first.
Connecting
- Endpoint:
https://use.jitsu.com/mcp - Transport: Streamable HTTP
- Auth: OAuth 2.1 with dynamic client registration — no API key to create or paste
claude mcp add jitsu --transport http https://use.jitsu.com/mcp
On first connect you are sent through an OAuth approval. After that the server sees the workspaces your Jitsu account already has. Self-hosting Jitsu? The MCP server is part of the console, so your own deployment exposes it too.
Destinations Jitsu delivers to
ClickHouse, BigQuery, Snowflake, Redshift, Postgres, MySQL, S3, and GCS for warehouses and storage, plus SaaS destinations including Amplitude, Braze, HubSpot, Intercom, Mixpanel, MongoDB, PostHog, Salesforce, Segment, SendGrid, GA4, Google Ads, Google Tag Manager, Hotjar, and LogRocket.
Links
- Documentation
- Jitsu on GitHub — MIT licensed
- Jitsu Cloud
Frequently asked questions
How do I connect to the Jitsu MCP server?
Add the endpoint https://use.jitsu.com/mcp to any MCP-compatible client such as Claude Code, Cursor, or VS Code. The setup snippets on this page configure each client in one step.
Does the Jitsu MCP server require authentication?
Yes. Jitsu uses OAuth: the first time you connect, your MCP client opens a browser window to sign in and authorize access, then reuses the credentials for future sessions.
Which transport does the Jitsu MCP server use?
Jitsu exposes a Streamable HTTP endpoint, the transport used by remote MCP servers and supported by all major MCP clients.
More remote MCP servers
%20-%20Sarah%20Xu.svg){kind=icon}
Adobe Marketing Agent
Marketing campaign and audience insights from Adobe
AI Video MCP by AITuber
AI Video MCP by AITuber is a hosted MCP server that lets AI agents create and publish video. You connect it once, then ask your agent for a video in plain language. It writes the script, picks a voice, generates the visu
API Direct
Search and read public data from X/Twitter, Reddit, YouTube, Instagram, TikTok, Facebook, Threads, Bluesky, Trustpilot, Amazon, Google Maps, news, forums and the web. 90+ read-only tools plus ready-made research playbook
Aard
Aard connects Macroeconomic and other official data from 170+ publishers including World Bank, IMF, BIS, ECB, Eurostat, and National Statistical Offices. Aard is powered by a large graph of the metadata universe and an
A
Aayat AI
Pay-per-use data and tools for AI agents: crypto token safety and rug checks, web search with cited answers, page-to-Markdown, up-to-date library docs, package safety, company research and UK/EU open data. 160 tools, 20
Comments