Customer-facing analytics
without per-viewer pricing
Self-host Emban on ClickHouse, publish tenant-scoped dashboards, embed by signed iframe in minutes, and switch to the React SDK when the dashboard must feel native.
Try the live seeded demo first. Free plan still includes one published dashboard, signed embeds, and Emban branding.
curl -fsSL https://emban.sidelabs.dev/compose.yml | docker compose -f - upSelf-hostedPOST /v1/embed-sessions
{
"tenant_id": "org_k8x9m2nv",
"dashboard_id": "dash_ai_usage",
"expires_in": 3600,
"permissions": {
"allow_drill_down": true
}
}One dashboard. Three tenants. See the isolation.
Interact with the real customer-facing embed. Switch tenants, change filters, click charts — no signup, no setup, no token paste.
Customer Dashboards
Builder, templates, draft/publish, and a live embed surface for real SaaS customers
Signed Sessions
One published dashboard, many tenant-scoped sessions, with the boundary kept on the server
Planner + Metrics
Safe rollups for counts and HLL uniques, plus p95/p99 metrics on raw events with explicit fallback reasons
Self-Hosted
Go service in front of your ClickHouse cluster, plus browser helper and React mounting paths
Live in under ten minutes
No onboarding calls. No integration partners. The whole path from install to an embedded dashboard is one engineer, one afternoon.
One Docker container or a single Go binary. No JVM, no dependencies, no cluster.
Point Emban at your existing ClickHouse. Schema autodiscovered, rollups prepared.
Drag-and-drop builder with real-time preview. Queries compiled to ClickHouse-native SQL.
Generate a signed JWT session and render the dashboard inside your product.
Not another BI tool
Emban is for SaaS teams that need customer dashboards on ClickHouse, not a general-purpose workspace for internal analysts.
- Internal BI focus — customer embed is an afterthought, not the product
- White-label, multi-tenant, and SSO usually live behind annual enterprise contracts
- Generic SQL layer — no ClickHouse rollups, no HLL, no partition-aware planning
- Tenant isolation requires manual setup across multiple admin screens
- Your data leaves your infra — hosted vendors own the query path
- Built from day one for tenant-scoped customer dashboards, not internal BI
- Single Go binary next to your ClickHouse — self-hosted, your infra, your data
- JWT-signed embed sessions with locked filters, drill-down control, and TTL
- ClickHouse-native planner: auto rollup selection, HLL uniques, p95/p99 on raw events
- Draft → publish workflow, React SDK, and embed in 4 lines of code
From events to embedded analytics
The product path is deliberately narrow: events, dashboards, publish, signed sessions, live customer-facing embed.
Ingest Events
Send events with tenant_id and numeric or string props. Emban discovers the schema and starts from the data shape you already have.
curl -X POST https://emban.sidelabs.dev/v1/events \
-H "Authorization: Bearer $EMBAN_INGEST_API_KEY" \
-d '{
"tenant_id": "org_k8x9m2nv",
"event_type": "api.call",
"properties": { "model": "gpt-4", "latency_ms": 812 }
}'Build Dashboards
Use the builder to create customer-facing charts, KPI cards, tables, and filters. Start from templates or generate from real data.
widget = {
"type": "timeseries",
"metric": "p95",
"value_prop": "latency_ms",
"group_by": "model"
}Publish Version
Keep editing in draft, publish a stable version for production, and bring it back if you need to restore the last live snapshot.
draft -> publish -> live embed
restore_published()
save_as_new()
duplicate_dashboard()Create Sessions
Create a signed tenant-scoped session for a published dashboard, then mount it in your app with the browser helper or React wrapper.
const session = await client.createEmbedSession({
dashboardId: "dash_ai_usage",
tenantId: "org_k8x9m2nv",
expiresIn: 3600
})Built for production
Everything you need to ship customer-facing analytics, nothing you don't.
Visual Builder
Drag-and-drop dashboard creation with real-time preview. Configure charts, filters, and layouts without writing code.
widget.add({ type: 'timeseries', metric: 'p95' })Dashboard Templates
Pre-built templates for common use cases: API usage, activity feeds, billing metrics. Fork and customize.
emban template fork ai-usage --name my-dashboardTenant-Scoped Embeds
JWT session tokens enforce row-level filtering at the query planner. No RLS setup needed.
WHERE tenant_id = {tenant_id:String}ClickHouse Planner
Rollup-aware query selection. Hourly for <30d, daily for >30d, raw as explicit fallback.
FROM events_hourly_mv -- auto-selectedPercentile Metrics
p95 and p99 via ClickHouse quantile functions on raw events. HLL rollups for unique counts at scale.
quantileExact(0.95)(latency_ms)React / Browser Helper
Server SDK for session creation, React wrapper, and vanilla browser mount path.
<EmbanEmbedFrame embedUrl={session.embed_url} />Built for product teams
Emban is shaped around the shape of real customer analytics — tenant-scoped, embedded, operated by the product team that ships the rest of the app.
AI SaaS
Show tenants LLM usage, model splits, token counts, cost per user.
Developer tools
Expose API usage, endpoint latency, error rates to paying customers.
B2B platforms
Customer-facing KPIs, conversion funnels, daily active tenants.
Data-heavy products
Events at billion-row scale with tenant isolation, no per-seat tax.
Compliance-sensitive teams
Data never leaves your infra. JWT-signed sessions, audit trail, self-hosted.
Growth-stage SaaS
Ship customer analytics without a dedicated data team or an enterprise BI contract.
Ship in minutes, not weeks
Create sessions server-side, embed client-side. The tenant boundary stays in the signed session.
import { EmbanClient } from "@emban/sdk"
const client = new EmbanClient({
baseUrl: "https://emban.sidelabs.dev",
apiKey: process.env.EMBAN_ADMIN_API_KEY!,
})
const session = await client.createEmbedSession({
dashboardId: "dash_ai_usage",
tenantId: "org_k8x9m2nv",
expiresIn: 3600,
})Real docs, not a placeholder link
The landing should not just hint that docs exist. These are the real pages behind the product path: quickstart, API, tenants, and the integration guides.
Quickstart
Go from sample data to first live tenant-scoped embed.
API Reference
Events, queries, embed sessions, permissions, and payload shapes.
Tenants
How signed sessions scope each published dashboard to one tenant.
React Guide
Mount the live embed with the React wrapper and server-side session path.
Live Demo
Open a seeded tenant-scoped dashboard with no signup, no setup, and no token copy-paste.
Playground
Paste a signed embed URL, mount the iframe path, and copy helper or native snippets.
Next.js Guide
Use signed sessions and helper paths in a Next.js app.
Node + curl
Create sessions and send events from a backend without extra framework assumptions.
Analytics your customers expect
Three example surfaces that map directly to the templates and seeded dashboards inside Emban.
AI Usage Analytics
Show customers token consumption, model mix, endpoint share, and latency percentiles without handing them an internal BI surface.
SELECT model, sum(tokens), p95(latency_ms) FROM eventsAPI Usage Dashboards
Give customers a tenant-scoped view of endpoint usage, success rate, latency, and traffic trends across a published dashboard.
SELECT endpoint, count(), p95(latency_ms) FROM eventsCustomer Activity
Expose active users, plan mix, source breakdowns, and customer-specific engagement trends directly inside the SaaS product.
SELECT day, uniqHLL12(user_id) FROM events_daily_mvOther options, honest trade-offs
Emban is not the only way to ship customer-facing analytics. Here's where it wins and where each alternative is still the right call.
| Feature | Emban | Metabase | Superset | Cube |
|---|---|---|---|---|
| ClickHouse-native query planner | ||||
| HLL approximate counts | ||||
| p95 / p99 percentile queries | ||||
| Signed tenant-scoped embed sessions | ||||
| Draft / publish dashboard workflow | ||||
| Single Go binary | ||||
| No JVM / Python runtime | ||||
| No per-viewer fees | ||||
| React embed wrapper | ||||
| Self-hosted only |
Start free, upgrade when the surface grows
The free tier is intentionally useful: self-host Emban, publish one real dashboard, and validate the signed embed path before you buy. Paid plans unlock more surfaces, branding control, governance, and support.
For early-stage SaaS shipping analytics to first customers.
- 1M events/month
- 3 published dashboards
- 3 editors
- Remove Emban branding
- Basic theming
- HLL & rollup queries
- Email support
For SaaS teams turning analytics into a real product surface.
- 10M events/month
- Unlimited published dashboards
- Team management
- Full audit log
- White-label + 4 themes
- Embed permissions
- p95/p99 percentiles
- React SDK
For higher-volume products with stricter rollout, security, and support needs.
- 100M+ events/month
- Everything in Growth
- SSO + advanced permissions
- Custom themes
- Dedicated onboarding
- Priority support + Slack channel
- Architecture & security review
“Every SaaS team I worked with kept postponing customer analytics. Not because the data was hard — it was sitting in ClickHouse already — but because the path from schema to embed was a six-week detour through BI tools that didn't speak ClickHouse.”
Shipping every couple weeks
Emban is under active development. Here are the latest releases.
Signed embed permissions
Locked filter API, per-session drill-down control, React helper improvements.
ClickHouse-aware planner
Auto rollup selection, HLL uniques, percentile queries on raw events.
Draft → publish workflow
Versioned dashboards, one-click rollback, full audit log.
Common questions
Technical answers for teams evaluating a self-hosted customer analytics layer on ClickHouse.
Ready to ship?
Start free, publish one dashboard, and walk the path from sample data to a signed tenant-scoped embed before you commit to a paid plan.
Start freeMetabase is a strong internal BI tool with embedding capabilities added on top. Pricing is per user, which makes the cost grow with your customer base rather than your usage — Emban prices on tenants and events instead, with no per-viewer fees, and ships a ClickHouse-native query planner with rollup and HLL paths. If you already run Metabase internally, keep it. For customer-facing dashboards on ClickHouse, Emban is the tighter fit. Check current Metabase pricing at metabase.com/pricing to compare against your tenant count.
Emban is built specifically for ClickHouse. It does not try to be a generic BI layer across many databases. That narrow scope is what lets the planner use safe rollups, HLL paths, and percentile metrics without pretending every backend works the same.
Each embed session is a JWT signed server-side with a specific tenant_id and dashboard_id. The planner injects WHERE tenant_id = {tenant_id:String} into every query. The browser cannot choose another tenant — the token carries the scope, and Emban enforces it at the SQL level.
Emban is a single Go binary that runs next to your ClickHouse. You can deploy it inside the same VPC, behind the same VPN, or on the same bare-metal host. Your ClickHouse cluster never needs to be exposed to the internet — only the Emban API, and only if you want it public-facing.
Pull the new binary or Docker image, restart the service. Schema migrations run on startup and are backwards-compatible. Dashboard configs are stored as JSONB in PostgreSQL and versioned — upgrades don't touch your existing published versions.
Three supported paths: direct iframe with a signed embed URL, vanilla JS browser helper, or the React wrapper. The tenant boundary stays in the signed session. Filters, theme, and reload behavior can be controlled from the host app via postMessage.
Start on the Free plan. It includes one published dashboard, signed embed sessions, tenant isolation, and Emban branding. Use it to validate install, auth, and your first customer-facing analytics surface. Upgrade when you need more dashboards, branding control, team workflows, and support.
No. Emban is self-hosted only. Your ClickHouse data stays in your infrastructure. We don't want access to your customer data, and most teams prefer not to ship production analytics data to a third party anyway.