Dec 18, 2025

Semaphor vs Metabase: Which Embedded Analytics Platform is Right for You?

A technical comparison of Semaphor and Metabase for customer-facing embedded analytics, covering embedding, multi-tenancy, custom visuals, version control, pricing, and maintenance.

Last updated: February 2026

Shipping analytics to your customers is a different problem than building dashboards for your own team. Multi-tenancy, white-labeling, native embedding, custom visualizations: these requirements don't show up in internal BI, but they define the experience for customer-facing analytics.

Metabase is a common starting point for teams exploring this space. This comparison breaks down where the tools overlap, where they diverge, and what the trade-offs look like for each.

Quick Comparison

Where the Tools Diverge

Metabase started as an internal BI tool and has added embedded analytics capabilities over time. Semaphor was built for customer-facing embedding from the start. That difference in origin shows up across the product.

Multi-Tenancy

Metabase added a Tenants feature on Pro and Enterprise plans. It supports JWT-based tenant assignment, tenant-specific collections, and row/column security (formerly "data sandboxing").

One limitation to be aware of: Metabase's row-level security only applies to queries made through the query builder. Users with native SQL editor access can bypass it. This means you need to carefully manage which users get SQL access in a multi-tenant setup.

Semaphor provides three levels of tenant isolation: row-level (filter by tenant ID), schema-level (separate schemas per tenant), and connection-level (separate database connections). Security policies are enforced at query build time, before SQL reaches the database, regardless of how the query was constructed. This is available on all paid tiers.

White-Labeling

On the free and Starter tiers, Metabase branding is fully visible with no customization options. On Pro and Enterprise, you can replace the logo, change the application name, customize colors and fonts, and control loading messages. Some Metabase references persist in admin-facing settings.

Semaphor provides full white-label control on all paid tiers: fonts, colors, layouts, URLs, error states. No third-party branding surfaces anywhere in the end-user experience.

Embedding

Metabase originally embedded via iframes (signed/static embeds). They've since added a React SDK (@metabase/embedding-sdk-react) that provides component-level embedding without iframes:

import {
  MetabaseProvider,
  InteractiveQuestion,
} from '@metabase/embedding-sdk-react';

<MetabaseProvider config={config}>
  <InteractiveQuestion questionId={42} />
</MetabaseProvider>;

The SDK requires Pro or Enterprise, supports React 18/19 only, and has some constraints (no SSR, no multiple interactive dashboards on the same page). Guest embeds (available on all plans) remain iframe-based.

Semaphor supports iframe embedding for quick integration and native SDKs for React and Vue:

// Iframe: works with any framework
<iframe src="https://app.semaphor.cloud/embed/dashboard/xyz?token=..." />;

// React SDK: drop-in component
import { Surfboard } from 'react-semaphor';

<Surfboard token={jwtToken} />;

The Surfboard component handles dashboard rendering, state management, theming, and filter interactions. It behaves as a native component in your app rather than a separate application in a frame. Iframe and SDK embedding are available on all paid tiers.

Custom Visuals

Metabase ships with 15+ built-in chart types (line, bar, pie, funnel, gauge, map, pivot table, and others). There is no plugin system for adding custom visualization types. A community feature request for this has been open since 2016.

This is a significant architectural difference. If you need a domain-specific visualization (trade flow diagrams, clinical timelines, fleet maps, branded KPI cards), Metabase can't accommodate it without forking the source code.

Semaphor uses a micro-frontend plugin architecture. You write a standard React component, and Semaphor handles data fetching, security, multi-tenancy, theming, and state management. Your component receives query results as props:

type SingleInputVisualProps = {
  data: Record<string, string | number | boolean>[];
  settings?: Record<string, string | number | boolean>;
  theme?: { colors?: string[]; mode?: 'light' | 'dark' };
  cardMetadata?: CardMetadata;
};

The workflow: clone the plugin quickstart, build your component, preview it locally, then publish with semaphor publish. Your custom visual appears in the dashboard editor alongside the built-in chart types. You can also use Claude Code to generate components from a description or a screenshot.

Multi-input visuals are supported too, combining data from multiple queries into a single component (e.g., a KPI card with a sparkline pulling from two different data sources).

Version Control

Metabase stores the last 15 revisions of each dashboard and allows reverting to previous versions. On Pro/Enterprise, serialization exports dashboards as YAML files that can be checked into git for staging-to-production workflows.

Semaphor takes a different approach: direct GitHub integration. Connect a repository once via a GitHub App install, and a Commit button appears in the dashboard toolbar. Every change is tracked with author attribution, timestamps, and commit messages. To restore a previous version, open the history, pick the commit, and click Restore. There's no version limit, and you get full diffs in GitHub's interface.

This also supports environment promotion. Dashboards can be duplicated across projects via the API, so teams can maintain separate dev, staging, and production projects and promote dashboards between them. Combined with GitHub version control, you get a full audit trail of what was deployed, when, and by whom.

Filters and Interactions

Metabase supports dashboard filters (dropdowns, date pickers, text inputs) with card-level wiring, cascading filters (requires foreign key metadata), and cross-filtering. The constraints show up in embedded contexts: cascading only works with database columns and explicit FK relationships, locked parameters accept a single value when linked to SQL questions, and filter values can't be updated programmatically after initialization.

Semaphor's filter system is built around hierarchical scoping. A single filter can be scoped to specific sheets (include or exclude) and independently to specific cards within those sheets. A date filter can affect three cards on one sheet and two on another, while skipping everything else. This matters when your dashboards have multiple contexts on the same page.

Inline filters add another layer: card-scoped, ad-hoc filters that don't affect other cards. Your customers can drill into a specific chart without resetting the rest of the dashboard.

Interactions go beyond filtering: click-to-filter across cards, drill-down through hierarchies, drill-through to other dashboards, and drill-to-detail popups. Each interaction type supports the same include/exclude card scoping. Custom filter components are supported through the plugin architecture.

Semantic Layer

Metabase has a model layer that lets you define curated datasets with descriptions and field types. Models act as saved questions that can be used as starting points for further exploration.

Semaphor has Semantic Domains: a full semantic layer that defines datasets, fields, relationships, calculated metrics, and calculated dimensions. Once an admin configures a domain, users can drag and drop fields from any dataset and Semaphor automatically resolves the joins based on defined relationships, including multi-hop joins across intermediate tables.

This matters for embedded analytics because your customers don't write SQL. They select fields, and the system figures out which tables to join and how. Calculated metrics (computed after aggregation, like profit margin) and calculated dimensions (computed at row level, like customer segment) are defined once in the domain and available to every dashboard that uses it. The domain setup is AI-assisted: Semaphor generates field labels, suggests aggregation functions, classifies dimensions vs. measures, and discovers relationships automatically.

Self-Service Analytics and Collaboration

Metabase supports self-service exploration in embedded mode on Pro/Enterprise plans with SSO authentication. End users can create questions using the query builder, build dashboards, and use drill-through. On the free tier, embedding is view-only: static iframes with basic filter interaction, no query builder, no creation.

Semaphor supports self-service on all paid tiers. End users can explore data through an interface built on Semantic Domains, create their own dashboards, and share them within their tenant. Security policies (row-level, schema-level, connection-level) are enforced at query construction regardless of how the query originates, so there's no equivalent of the Metabase SQL-editor bypass.

Semaphor also provides a granular sharing model for embedded contexts. Dashboards can be shared with specific users, groups, or entire tenants, each with a distinct access level (Viewer, Editor, Contributor, Owner). A tenant user with a Power User role can create their own dashboards and share them with colleagues, while reference dashboards from your team can be locked to view-only. Groups make this manageable at scale: create a group per department or team, share once, and new members inherit access automatically.

Pricing

Metabase

The React SDK, multi-tenancy, row-level security, and white-labeling all require Pro or Enterprise. Basic guest embedding (iframe, view-only) is available on all plans.

Prices as of February 2026.

Semaphor

No per-user fees. Embedding, multi-tenancy, and white-labeling are included in all paid tiers. Your cost doesn't increase as you add more of your customers to the platform.

When to Choose What

Metabase is the stronger choice if:

• You need internal dashboards for your own team
• Your embedding is single-tenant or you're on Pro/Enterprise and the built-in tenant model fits
• You want to self-host and modify the source code
• Your visualization needs are covered by the 15+ built-in chart types
• You're comfortable with per-user pricing

Semaphor is the stronger choice if:

• You're embedding analytics for multiple customers and need tenant isolation on all paid tiers
• You need custom visualizations beyond standard chart types
• You need a semantic layer with auto-join resolution and calculated fields
• You want version-controlled dashboards with GitHub integration and environment promotion
• You prefer flat pricing that doesn't scale with user count
• You need fine-grained filter scoping (sheet-level, card-level, inline) and custom filter plugins
• White-labeling and native SDK embedding matter and you don't want to pay for an Enterprise tier to get them

Migration

Teams that move from Metabase to Semaphor typically follow this path:

1. Run Semaphor in parallel with the existing setup
2. Recreate key dashboards in Semaphor
3. Embed Semaphor for a subset of customers to validate
4. Migrate remaining customers
5. Decommission Metabase

Most migrations take 2-4 weeks depending on dashboard complexity.

Next Steps

• Try it: The free tier includes embedding. Connect your data, build a dashboard, embed it. No credit card required.
• See it: Book a 15-minute demo to see multi-tenancy, custom visuals, and GitHub integration in action.

Questions about migrating from Metabase? Reach out at hello@semaphor.cloud.