What is Embedded Analytics? Definition for B2B SaaS

Embedded analytics is the integration of data visualizations and reporting directly into a software product. Instead of sending users to a separate BI tool, charts and metrics appear inside the application they already use. For B2B SaaS, this means your customers see their data without leaving your product.

Common examples: usage dashboards in developer tools, spend breakdowns in procurement platforms, campaign performance views in marketing software, API analytics in integration products. The alternative is exporting CSVs or linking out to Looker, which fragments the user experience and makes your product feel incomplete.

Embedded analytics has evolved significantly in the last few years. What started as iframe-embedded dashboards has expanded to include native SDK components, REST APIs, AI-powered natural language queries, and now AI agent access via MCP. The surface area has grown from "show a chart" to "let customers interact with their data however they want."

Why do B2B products embed analytics?

Customer retention. Users who rely on your analytics to make decisions are harder to churn. The data becomes part of their workflow, not an afterthought they check in a separate tool. The switching cost includes losing visibility into their own data.

Upsell opportunity. Analytics features are a natural premium tier. Basic plans get summary metrics. Enterprise plans get full dashboards, custom reports, and API access. The data is already there; the packaging drives revenue.

Competitive differentiation. Two products with identical core features? The one with built-in analytics wins. Customers prefer products that show them their data without requiring a separate BI subscription and ETL pipeline.

Reduced support load. Every "can you pull this report for me?" ticket goes away when customers can answer the question themselves. Self-serve analytics scales in a way that your support team doesn't.

Types of embedded analytics

Iframe embedding

The simplest approach: embed a BI tool's dashboard in an iframe inside your product. Metabase, Looker, Power BI, and Tableau all support this. Fast to set up. The tradeoffs show up quickly:

• Styling limitations. The iframe is a foreign element. Matching your brand's fonts, colors, and interaction patterns is difficult to impossible.
• Performance. The embedded dashboard loads the BI tool's full frontend, adding latency.
• Multi-tenancy. Requires the BI tool to support per-tenant filtering, which is often a paid feature.
• Limited to dashboards. You get whatever the BI tool provides. No custom visualizations, no API access from the same definitions.

Iframe embedding works for internal tools and MVPs. For customer-facing products where UX matters, it's a compromise.

SDK-based embedding

A step up: use a vendor's SDK to render charts natively in your frontend. The charts are React (or Vue, Angular) components that query the vendor's API. You control the layout and styling. The data comes from the vendor's query engine.

Tools in this category: Explo, Luzmo, Reveal, Holistics, GoodData. Each provides SDKs and APIs for embedding analytics into your product. The experience is more native than iframe embedding, but you're still dependent on the vendor's query layer and data model.

Semantic layer approach

Define metrics once in a semantic layer, scope them per tenant, and serve them through native SDK components, REST APIs, AI agents, and any other surface. The key difference: the semantic layer is infrastructure you control. Metrics are defined in YAML, version-controlled in Git, and served through your own API. You're not dependent on a vendor's query model.

This is the approach that supports multiple surfaces from one definition: React charts, MCP for AI agents, REST APIs for customer integrations, markdown dashboards for simpler use cases. One metric definition, every consumer, same governed data.

Build from scratch

Custom SQL queries, custom API endpoints, custom chart components using D3, Chart.js, or Recharts. Maximum control. Maximum maintenance burden. Every new metric is a new endpoint, a new component, and a new set of tests. Works for the first dashboard. Becomes an engineering bottleneck by the tenth.

What's needed for production embedded analytics?

Multi-tenancy

Each customer sees only their data. This requires row-level security that filters every query by tenant. Not application-level filtering bolted on as middleware. Structural enforcement at the data layer where it can't be bypassed.

The most common failure mode in embedded analytics: Customer A sees Customer B's data because a filter was missed on one query path. Structural multi-tenancy (security context in the semantic layer, publishable keys per tenant) eliminates this class of bug.

Access control

Different users within the same tenant need different visibility. An admin sees everything. A team lead sees their department. RBAC at the data layer handles this without custom code per role.

Governed metrics

Every chart in your product should show the same number as your API response and your AI agent's answer. A semantic layer ensures this by defining metrics once and serving them to every surface. Without this, metrics drift between surfaces: the dashboard shows one number, the API returns a different one, the export uses yet another query.

Performance

Customers expect dashboards to load in under 2 seconds. At month-end, when data volumes spike and everyone checks their analytics simultaneously, performance matters most. Pre-aggregation caching pre-computes common rollups so queries return in milliseconds instead of seconds. Without caching, your warehouse becomes the bottleneck.

Customization

Your embedded analytics should look like part of your product, not a third-party widget. This means: your fonts, your colors, your spacing, your interaction patterns. Iframe embedding makes this hard. Native SDK components with CSS custom property theming (--bon-bg, --bon-text, --bon-border, --bon-radius) and built-in color palettes make it straightforward.

Embedded analytics tools compared

Tool	Approach	Multi-tenancy	AI/Agent support	Open source	Best for
Metabase	Iframe or full-app embed	Enterprise only ($500+/mo)	None	Yes (AGPL)	Internal dashboards, MVPs
Holistics	SDK + iframe	Built-in	None	No	Self-service BI embedding
Explo	SDK components	Built-in	None	No	Customer-facing dashboards
Luzmo	SDK components	Built-in	Limited	No	Product analytics embedding
Reveal	SDK components	Built-in	None	No	.NET and Java applications
GoodData	SDK + API	Built-in	Limited	No	Enterprise embedded BI
Looker	Iframe embed	Manual or enterprise	None	No	Google Cloud ecosystem
Power BI Embedded	Iframe embed	Capacity-based	Copilot (limited)	No	Microsoft ecosystem
Tableau Embedded	Iframe embed	Enterprise	None	No	Salesforce ecosystem
Bonnard	Semantic layer + React SDK + MCP	Structural (publishable keys)	MCP native	Yes (Apache 2.0)	Multi-surface B2B analytics

The tools above fall into two categories: dashboard embedding tools (Metabase, Holistics, Explo, Luzmo, Reveal, GoodData, Looker, Power BI, Tableau) and semantic layer approaches (Bonnard, and to some extent Cube as infrastructure). Dashboard embedding tools give you charts inside your product. Semantic layer approaches give you governed metrics across every surface: charts, APIs, AI agents, exports.

If your customers only need dashboards, a dashboard embedding tool is likely sufficient. If they also need API access, AI agent connectivity, or you need consistent metrics across internal and customer-facing surfaces, the semantic layer approach provides that from a single set of definitions.

How the semantic layer approach works

Define your metrics once in YAML. Scope them per tenant with publishable keys. Serve them through React SDK components, REST API, MCP for AI agents, and markdown dashboards.

cubes:
  - name: usage_events
    sql_table: public.events
    measures:
      - name: total_events
        type: count
      - name: unique_users
        sql: user_id
        type: count_distinct
    dimensions:
      - name: event_type
        sql: event_type
        type: string
      - name: tenant_id
        sql: tenant_id
        type: string
      - name: created_at
        sql: created_at
        type: time
    security_context:
      - name: tenant_filter
        sql: "{SECURITY_CONTEXT.tenant_id} = tenant_id"

The SDK (@bonnard/sdk) creates a client, and the React SDK (@bonnard/react) provides pre-built components that query the semantic layer directly:

import { BonnardProvider, BarChart, useBonnardQuery } from "@bonnard/react";
import "@bonnard/react/styles.css";

function App() {
  return (
    <BonnardProvider config={{ apiKey: "bon_pk_..." }}>
      <Dashboard />
    </BonnardProvider>
  );
}

function Dashboard() {
  const { data, loading } = useBonnardQuery({
    query: {
      measures: ["usage_events.total_events"],
      dimensions: ["usage_events.event_type"],
    },
  });
  if (loading || !data) return null;
  return <BarChart data={data} x="usage_events.event_type" y="usage_events.total_events" />;
}

No iframe. No separate BI tool. Native React components styled with your design system. The API key (created in Settings > API Keys in the Bonnard dashboard) scopes queries to the customer's data automatically. Available components: BigValue, BarChart, LineChart, AreaChart, PieChart, DataTable, DashboardViewer (for embedding full markdown dashboards in React), BonnardChart (a universal renderer that takes a spec object and renders any chart type), and the useBonnardQuery hook. The pre-aggregation cache serves frequent queries in single-digit milliseconds.

Theming uses CSS custom properties (--bon-bg, --bon-text, --bon-border, --bon-radius) so charts match your product's look without overriding component internals. Pass a palette prop on BonnardProvider to set chart colors: built-in palettes include default, tableau, observable, and metabase, or pass a custom array of hex values.

The same metric definitions also power MCP for AI agents, REST API for customer integrations, and TypeScript SDK for backend services. One schema, every surface. Read the full architecture at How to Build Customer-Facing Analytics for B2B SaaS.

Frequently asked questions

What is the difference between embedded analytics and business intelligence?

Business intelligence (BI) is for your internal team: analysts, executives, operations. Embedded analytics is for your customers: analytics integrated into your product for end users. The technical requirements are different. BI needs flexibility and ad-hoc exploration. Embedded analytics needs multi-tenancy, performance, and consistent UX across tenants.

What is white-label embedded analytics?

White-label means your customers see your brand, not a third-party tool's brand. No "Powered by Metabase" footer. No foreign-looking iframe. With iframe embedding, white-labeling is difficult. With native SDK components styled through CSS custom properties and configurable color palettes, there's nothing to white-label because the charts are your own React components.

How much does embedded analytics cost?

Ranges from free (Metabase open source, Bonnard self-hosted) to enterprise pricing (Looker, Tableau, Power BI Embedded). Most SaaS-oriented tools (Explo, Luzmo, Holistics) charge based on users, events, or queries. Bonnard Cloud is usage-based starting at $149/month with no per-user pricing.

Is Metabase good for embedded analytics?

Metabase is good for internal dashboards and MVPs. For production customer-facing analytics, limitations show up: multi-tenancy requires the Enterprise license ($500+/month), iframe embedding has styling constraints, and there's no API serving or AI agent support. See Bonnard vs Metabase for a detailed comparison.

What is the best embedded analytics tool for SaaS?

It depends on your requirements. For dashboard-only embedding: Explo, Luzmo, or Holistics. For enterprise BI embedding: Looker or Power BI. For multi-surface analytics with AI agent support: Bonnard. The right choice depends on whether you need just charts or governed metrics across multiple surfaces.

Can embedded analytics work with AI agents?

Traditional embedded analytics tools (Metabase, Holistics, Explo, etc.) don't support AI agent access. A semantic layer approach with MCP support lets customers connect AI agents to their analytics using publishable keys. The agent queries the same governed metrics as the dashboard, with the same tenant isolation.

Related terms

• Semantic Layer
• RBAC
• MCP
• Pre-Aggregation
• Text-to-SQL
• Metric Governance