Power BI Embedded Analytics
ISV & Enterprise Guide 2026: App Owns Data, F-SKU pricing, JavaScript SDK, multi-tenant security, white-labeling, and performance optimization for embedded analytics at scale.
What Is Power BI Embedded and How Does It Work?
Featured Snippet: Power BI Embedded allows ISVs and enterprises to embed interactive Power BI reports, dashboards, and visuals directly into custom applications using the JavaScript SDK and REST APIs. ISVs use the "App Owns Data" pattern with service principal authentication so end users need no Power BI licenses. Enterprises use "User Owns Data" for internal portals with Entra ID SSO. Pricing starts at F2 ($262/month) with F64 ($4,096/month reserved) as the typical enterprise starting point.
Power BI Embedded is the most cost-effective way to add enterprise-grade analytics to any application. Instead of building a custom analytics engine — which takes 6-12 months of development for features like cross-filtering, drill-down, row-level security, export, and mobile responsiveness — you embed Power BI reports that already have all of these capabilities built in. Your developers focus on integration, not reinventing the BI wheel.
The business case is compelling. ISVs that embed analytics see 15-25% higher retention rates and can charge 20-40% more for analytics-enabled tiers. Enterprises that embed Power BI in internal portals see 3x higher analytics adoption compared to forcing users to open a separate BI tool. The data is clear: analytics embedded in the workflow where decisions happen drives dramatically better outcomes than analytics as a separate destination.
This guide covers everything you need to build production-grade embedded analytics: the two embedding patterns (App Owns Data vs User Owns Data), F-SKU capacity pricing, the JavaScript SDK, row-level security for multi-tenancy, ISV deployment scenarios, white-labeling, customer-facing analytics, and performance optimization at scale. Whether you are an ISV adding analytics to your SaaS product or an enterprise embedding dashboards in SharePoint and internal portals, this is your comprehensive reference.
App Owns Data vs User Owns Data
The single most important architectural decision in Power BI Embedded is choosing your embedding pattern. This determines authentication flow, licensing costs, security model, and deployment architecture. Getting this wrong is expensive to reverse — choose carefully upfront.
App Owns Data
Also called "Embed for Your Customers"
- Service principal authenticates — not the end user
- End users need NO Power BI licenses
- Your app controls all authorization logic
- Ideal for ISV SaaS products with external customers
- Embed tokens generated server-side via REST API
- Supports multi-tenant RLS with effective identity
- You manage F-SKU capacity — users are free
User Owns Data
Also called "Embed for Your Organization"
- End user authenticates with their own Entra ID
- Each user needs Power BI Pro ($10/mo) or PPU ($20/mo)
- Power BI enforces per-user permissions natively
- Ideal for internal enterprise portals and intranets
- Uses Azure AD token — standard OAuth 2.0 flow
- RLS applied based on user identity automatically
- No F-SKU required if users have Pro licenses
EPC Group Recommendation: ISVs should always use App Owns Data. The per-user licensing cost of User Owns Data makes it economically unviable for external customers — you would need every customer to have a Power BI Pro license. For enterprises with internal users who already have M365 E5 licenses (which include Power BI Pro), User Owns Data is simpler to implement and leverages existing license investment.
F-SKU Capacity Pricing for Embedded Analytics
Power BI Embedded runs on Fabric F-SKU capacity, replacing the legacy A-SKU (Azure) pricing model. F-SKU is more cost-effective and includes the full Fabric platform — not just embedding. You provision capacity, assign workspaces to it, and all embedded content in those workspaces runs on that capacity.
| SKU | CUs | PAYG/Month | Reserved/Month | Best For |
|---|---|---|---|---|
| F2 | 2 | ~$262 | ~$157 | Dev/test, prototyping |
| F4 | 4 | ~$524 | ~$315 | Small team dev environments |
| F8 | 8 | ~$1,048 | ~$629 | Light production, small ISVs |
| F16 | 16 | ~$2,096 | ~$1,258 | Medium production workloads |
| F64 | 64 | ~$8,192 | ~$4,096 | Enterprise production (most common) |
| F128 | 128 | ~$16,384 | ~$8,192 | Large ISV, high concurrency |
| F256 | 256 | ~$32,768 | ~$16,384 | Enterprise-scale ISV (5,000+ tenants) |
The critical insight: F-SKU capacity is shared across all Fabric workloads, not just embedding. If you are already using Fabric for data engineering or real-time analytics, your embedded reports consume from the same capacity pool. This consolidation often makes F-SKU more economical than dedicated A-SKU was, because you are not paying for idle embedding capacity during non-peak hours — other workloads can use it.
Power BI JavaScript SDK Integration
The Power BI JavaScript SDK (powerbi-client npm package) is the client-side library that renders embedded Power BI content in your web application. The SDK manages the iframe lifecycle, handles authentication via embed tokens, exposes programmatic control over the report (filters, pages, bookmarks), and emits events for user interactions (data point clicks, page changes, errors).
The embedding workflow follows three steps: (1) your backend generates an embed token by calling the Power BI REST API with a service principal credential, (2) your frontend initializes the SDK with the embed token and report configuration, (3) the SDK renders the report in a designated HTML container. From there, you can programmatically apply filters, capture user interactions, and control the visual experience.
SDK Integration Best Practices
- Generate embed tokens server-side only — never expose your service principal credentials to the client.
- Cache embed tokens for their 1-hour lifetime — generating a new token per page load wastes API calls and adds latency.
- Use the powerbi-client-react wrapper for React applications — provides proper component lifecycle management.
- Implement token refresh before expiry — listen for the tokenExpired event and call your backend for a new token seamlessly.
- Set the embed container to a fixed aspect ratio (16:9 for reports) to prevent layout shift during loading.
- Use the phased embedding pattern: call powerbi.preload() on app init, then powerbi.embed() when the user navigates to analytics.
- Handle the error event to catch and display user-friendly messages instead of raw Power BI errors.
- Apply filters via the SDK setFilters() method rather than URL parameters — more reliable and supports complex filter logic.
Row-Level Security for Multi-Tenancy
Multi-tenant security is the make-or-break requirement for ISV embedded analytics. Every tenant must see only their own data — any data leakage between tenants is a catastrophic security failure. Power BI Embedded implements this through row-level security (RLS) with effective identity, enforced at the Fabric engine level so it cannot be bypassed by client-side manipulation.
The pattern works as follows: you define RLS roles in your Power BI semantic model with DAX filter expressions (e.g., [TenantID] = USERNAME()). When your backend generates an embed token, it includes the effective identity — the tenant ID for the current user. Power BI receives this identity, matches it against the RLS role, and returns only rows where the filter evaluates to true. The filtering happens inside the Fabric engine, not in your application code. This means even if an attacker modifies client-side JavaScript, they cannot access another tenant's data because the token is cryptographically bound to a specific tenant identity.
Engine-Level Enforcement
RLS is evaluated inside the Fabric query engine. No client-side filtering that could be bypassed. Data never leaves the engine for unauthorized tenants.
Single Model, Many Tenants
One semantic model serves all tenants — no per-tenant model proliferation. Simpler management, lower capacity consumption, easier updates.
Effective Identity Tokens
Each embed token is bound to a specific tenant identity. Tokens are short-lived (1 hour) and generated server-side with your service principal.
Audit Trail
Power BI logs every embed token generation and report render with the effective identity. Full auditability for compliance requirements.
ISV Scenarios and Customer-Facing Analytics
ISVs embed Power BI to transform their SaaS products from data-collecting applications into analytics-driven platforms. The embedded analytics become a core value proposition — customers pay more for products that help them understand their data, not just store it. Common ISV scenarios include: operational dashboards (real-time metrics within the app), self-service exploration (letting customers build their own views), automated reporting (scheduled PDF exports), and embedded Q&A (natural language queries against customer data).
The most successful ISV implementations treat embedded analytics as a premium tier feature. Offer a basic tier with pre-built dashboards and a premium tier with self-service exploration, custom report building, and export capabilities. This tier structure aligns cost (F-SKU capacity) with revenue (premium subscription pricing) and creates a natural upsell path for your sales team.
ISV Deployment Patterns
Single-Tenant Model with RLS
One semantic model, one set of reports, RLS filters per tenant. Best for: 90% of ISVs. Simplest to manage, lowest capacity cost, easiest to update. Supports 1,000+ tenants on F64.
Workspace-per-Tenant Isolation
Separate Power BI workspace per tenant with dedicated models. Best for: regulated industries (healthcare, finance) where data isolation requirements prohibit shared models. Higher capacity cost — each model consumes memory independently.
Hybrid Model
Shared model for standard tenants, dedicated workspaces for enterprise customers. Best for: ISVs serving both SMB and enterprise segments. Enterprise customers get isolation guarantees, SMB customers share efficiently.
White-Labeling Embedded Analytics
White-labeling is essential for ISVs — your customers should experience embedded analytics as a native feature of your product, not as "Power BI inside your app." Fabric and the JavaScript SDK provide comprehensive white-labeling controls that let you match your brand identity completely.
Start with Power BI themes — JSON-based theme files that control colors, fonts, visual styles, and background patterns across all report visuals. Create a theme that matches your SaaS product design system. Then use SDK embedding settings to hide the Power BI navigation bar, action bar, filter pane, and page navigation. Apply your own CSS to the embedding container for border radius, shadows, and spacing that match your UI framework. The result is seamless — users interact with charts and tables that look identical to every other element in your application.
White-Label Checklist
- Create a custom Power BI theme JSON matching your brand colors, fonts, and visual styles.
- Hide the filter pane, navigation pane, and action bar via SDK settings (layoutType: models.LayoutType.Custom).
- Disable the "Powered by Power BI" footer by using the hideFooter SDK setting.
- Apply CSS styling to the embedding container to match your UI framework (border-radius, shadows, padding).
- Use the SDK to build custom filter controls in your own UI — replace the native Power BI filter pane entirely.
- Implement custom export buttons that call the SDK exportData() method — replace native Power BI export.
- Build your own page navigation using getPages() and setPage() — replace the native Power BI page tabs.
Performance Optimization at Scale
Embedded analytics performance directly impacts user experience and product perception. A report that takes 5+ seconds to render feels broken. A report that renders in under 2 seconds feels native. The difference is capacity sizing, semantic model optimization, and SDK integration patterns — all controllable by your engineering team.
The most impactful optimization is capacity right-sizing. Under-provisioned capacity causes throttling — report renders queue instead of executing immediately. Monitor your Capacity Metrics app and scale before sustained utilization exceeds 70%. The second most impactful optimization is semantic model design — star schema models with proper aggregations render 5-10x faster than flat tables with complex DAX calculations.
Capacity Monitoring
Use the Fabric Capacity Metrics app to track CU utilization, throttling events, and query durations. Scale proactively when sustained usage exceeds 70%.
Model Optimization
Use star schema design, pre-calculated measures, aggregation tables, and incremental refresh. Keep models under the capacity memory limit (25 GB for F64).
SDK Preloading
Call powerbi.preload() on app initialization to cache the Power BI JavaScript bundle. Reduces first render time by 2-3 seconds for subsequent embeds.
Token Management
Cache embed tokens for their 1-hour lifetime. Implement proactive token refresh at 50 minutes to prevent expired-token errors during active user sessions.
Frequently Asked Questions: Power BI Embedded
How does Power BI Embedded work for ISVs and enterprises?
Power BI Embedded allows you to embed interactive Power BI reports, dashboards, and visuals directly into your own applications using the Power BI JavaScript SDK and REST APIs. For ISVs, this means adding rich analytics to your SaaS product without building a BI engine from scratch. For enterprises, it means delivering governed, interactive dashboards within internal portals, SharePoint, or custom web applications. The embedded content runs on dedicated F-SKU capacity that you provision and manage, separate from your users Power BI Pro licenses.
What is the difference between App Owns Data and User Owns Data?
App Owns Data (also called "embed for your customers") uses a service principal to authenticate — your end users do not need Power BI licenses. Your application controls authentication and authorization, making it ideal for ISV scenarios where external customers access embedded reports. User Owns Data (also called "embed for your organization") uses the end user own Entra ID credentials — each user needs a Power BI Pro or PPU license. This pattern is best for internal enterprise portals where users already have M365 licenses.
How much does Power BI Embedded cost in 2026?
Power BI Embedded uses F-SKU (Fabric) capacity pricing. F2 starts at approximately $262/month (PAYG) for light workloads. F64 costs approximately $4,096/month reserved and is the most common enterprise starting point. F128 ($8,192/month reserved) and F256 ($16,384/month reserved) serve high-scale ISV deployments. Reserved pricing saves 40% vs pay-as-you-go. Unlike the legacy A-SKU (Azure) pricing, F-SKU includes all Fabric capabilities — not just embedding. You also need a Power BI Pro license ($10/user/month) for report authors, but end users in App Owns Data scenarios need no licenses.
How do I implement row-level security for multi-tenant embedded analytics?
Row-level security (RLS) in Power BI Embedded ensures each tenant sees only their own data. Define RLS roles in your Power BI semantic model with DAX filter expressions (e.g., [TenantID] = USERNAME()). When generating an embed token via the REST API, pass the effective identity with the tenant identifier — Power BI enforces the filter server-side. For ISVs, this means a single semantic model and report can serve thousands of tenants securely. Each embed token request includes the tenant context, and Power BI returns only the rows matching that tenant. No data leakage between tenants is possible because filtering happens at the engine level, not the application level.
What is the Power BI JavaScript SDK and how do I use it?
The Power BI JavaScript SDK (powerbi-client) is the client-side library for embedding Power BI content in web applications. It provides methods to embed reports, dashboards, tiles, and Q&A visuals into HTML containers. The SDK handles authentication (via embed tokens), rendering, and user interaction events. Key SDK operations include: powerbi.embed() to render content, report.setFilters() to apply dynamic filters, report.getPages() to navigate programmatically, and event handlers for loaded, rendered, dataSelected, and buttonClicked events. The SDK supports React, Angular, and vanilla JavaScript frameworks.
Can I white-label Power BI Embedded reports?
Yes. Power BI Embedded supports full white-labeling — your users never see the Power BI brand. You control the container styling, hide the Power BI navigation pane and filter pane, apply your own CSS to the embedding container, and use custom themes to match your brand colors and fonts. The JavaScript SDK settings object allows you to hide toolbars, disable export options, and control which interactive features are available. For ISVs, this means embedded analytics look and feel like a native feature of your application rather than an external BI tool.
What are the performance considerations for Power BI Embedded at scale?
Key performance factors include: (1) Capacity sizing — under-provisioned F-SKU leads to throttling and slow renders. Monitor CU utilization and scale before sustained usage exceeds 70%. (2) Semantic model size — keep models under the capacity memory limit (F64 supports 25 GB models). Use incremental refresh for large datasets. (3) Query optimization — optimize DAX measures, reduce calculated columns, use aggregations. (4) Embed token caching — tokens are valid for 1 hour; cache and reuse rather than generating per-request. (5) Preloading — use the SDK preload feature to initialize the Power BI iframe before the user navigates to the analytics page, reducing perceived load time by 2-3 seconds.
How does Power BI Embedded compare to building custom analytics?
Building custom analytics (Chart.js, D3.js, Apache Superset) gives complete control but requires 6-12 months of development for enterprise-grade features: data modeling, caching, drill-down, cross-filtering, export, RLS, and mobile responsiveness. Power BI Embedded provides all of these out of the box with 2-4 weeks of integration effort. The tradeoff is flexibility — custom solutions can render any visualization imaginable, while Power BI is constrained to its visual library (though custom visuals extend this significantly). For 90% of ISV and enterprise analytics requirements, Power BI Embedded delivers faster time-to-value at lower total cost of ownership.
What capacity do I need for an ISV serving 1,000+ tenants?
For 1,000+ tenants with concurrent usage of 10-15%, start with F64 capacity and monitor. F64 supports approximately 150 concurrent report renders with sub-3-second load times for typical semantic models (under 5 GB). If you see throttling, scale to F128. Critical factors: (1) use a single multi-tenant semantic model with RLS rather than per-tenant models, (2) enable query caching, (3) implement embed token pooling, and (4) use aggregations for large datasets. EPC Group has deployed Power BI Embedded solutions serving 5,000+ tenants on F128 capacity with consistent sub-2-second render times.
Related Resources
Power BI Consulting Services
Enterprise Power BI dashboard development, governance, and managed analytics from EPC Group.
Read moreEmbedded Analytics Integration Guide
Deep dive into application integration patterns for Power BI embedded analytics.
Read morePower BI Performance Optimization
Optimize Power BI performance for enterprise-scale deployments and large semantic models.
Read moreReady to Embed Analytics in Your Application?
EPC Group has deployed Power BI Embedded solutions for ISVs serving 5,000+ tenants and enterprises with 50,000+ internal users. From architecture design to production deployment, our certified Power BI engineers deliver embedded analytics that scale. Schedule a free embedded analytics assessment today.