Adding embedded analytics to your product has a number of benefits for your end-users. They have more control over their data, and they can make better, more data-driven decisions. If you’re shopping for tools to embed dashboards in your product, you’ll notice that many of them use iframes as a method for embedding.
Most developers are familiar with iframes, so this should be good news. In reality, iframes are one of the least effective ways to add analytics capabilities to your website or product.
In this article, we show developers, CTOs, product managers, and everyone else which tools you can use to embed dashboards while avoiding the dreaded iframe.
We’ve already covered the main reasons why iframes are a subpar embedding method, but here is a quick recap before we look at the available tools.
TL;DR:
- iframes are easy but flawed: They limit styling, hurt accessibility, block SEO, and create a disconnected user experience.
- Modern embedding means going iframe-free: Native integration gives you full control, faster load times, and better UX.
- Top tools that don’t use iframes:
- Embeddable: Built specifically to avoid iframes, offers SDKs for React, Vue, and Web Components.
- Sisense: Offers SDKs (SisenseJS, Compose SDK) for native DOM embedding.
- Qlik Sense: Provides Qlik-embed and Capability API for embedding without iframes.
- GoodData: Uses GoodData.UI React SDK for DOM-level control.
- Tools that rely on iframes (with some SDK support):
- Looker, Tableau, Power BI, ThoughtSpot: Use iframes but offer JS APIs or SDKs for limited interaction. Domo: Still fully iframe-based with no official non-iframe option.
- Bottom line: If you care about deep customization, visual integration, and a clean developer experience, go with a platform that skips the iframe altogether.
Why are iframes a big deal, anyway?
Embedding iframes comes with a solid list of downsides, which we explained in detail before. So, here’s a quick recap:
- Poor integration with surrounding CSS and layout: iframes isolate embedded content, making styling and responsive design harder. They may break navigation or display scrollbars unpredictably.
- Accessibility issues: Keyboard navigation and screen reader support can be inconsistent inside iframes. Users might not tab into iframe content naturally, and accessible names must be manually added.
- SEO limitations: Search engines often ignore iframe content, so anything embedded may not be indexed or contribute to SEO value.
- Security and privacy risks: iframes expose your domain to third‑party content, which can bring clickjacking, credential theft, or other vulnerabilities unless strong CSP or sandboxing is carefully applied.
- Testing and maintenance complexity: Embedded content often lives in a separate document, making QA tools, debugging, and styling updates more difficult to manage.
In short, the content will look out of place and be difficult to access for humans and search engines.
Top tools that don’t use iframes as an embedding method
If you want to offer full customization options, fast loading times, and a stellar user experience for your end-users, these are the tools to consider. But if you’re a developer evaluating embedded BI tools, you’ll also want to look at tools that combine iframes with other methods, which we’ll cover in a moment.
These tools give developers full (or a good level of) freedom when embedding dashboards in different settings.
Tools that don’t use iframes
Embeddable
Embeddable is an embedded analytics tool built specifically to avoid the traditional iframe approach. Instead of placing a dashboard in an isolated <iframe>, you integrate Embeddable directly into your app’s code.
It provides native React/Vue components or Web Components that you can import and render as part of your application. This means the charts and dashboards are first-class citizens in your DOM. They can inherit your CSS styles, theme, and layout, giving a seamless “built-in” look and feel.
Because there’s no second browser context, the embedded content can communicate directly with your app (no clunky postMessage needed) and share state like any other component. Embeddable’s approach also provides faster performance, since there’s no iframe overhead or duplicate loading of assets.
In practice, embedding with Embeddable is as simple as dropping in a snippet of code and passing through simple filters to make sure your user sees only their data. Your app handles it like a native module, which makes styling, event handling, monitoring, and debugging much easier (you can even use your browser dev tools on the embedded charts).
In short, Embeddable offers a developer-friendly way to embed rich analytics without iframes, allowing your embedded dashboards to feel like an organic part of your product.
Get access to Embeddable today.
Sisense
Sisense is a general-purpose BI platform that offers several embedding options. Traditionally, Sisense supported quick embedding via iframes, but it also provides an embed SDK and a JavaScript library for more seamless integration.
With SisenseJS (their JavaScript embedding library), you can insert dashboards or even individual charts directly into your application’s DOM without using iframes. This method involves including the Sisense JS script and using it to load and render analytics content inside a container element on your page.
The benefit is that the embedded visuals will load in your application itself and allow for richer interaction. Developers can apply custom styles, listen for user actions, and control the widgets via code – things that are hard to do through a sandboxed iframe.
Sisense also introduced a Compose SDK for a code-driven approach to embedding, letting you build and assemble analytics components in a React/TypeScript application.
That said, there are trade-offs. Getting the most out of the SDK requires a solid understanding of Sisense’s APIs and embedding model, which comes with a learning curve. The SDK itself can also increase your frontend bundle size, which may be a concern for lightweight apps.
Customization and branding features are more flexible in higher-tier plans, so some limits may apply depending on your subscription level. Developers have also noted that the documentation for more complex use cases isn’t always comprehensive, which can make the initial setup slower than expected.
Qlik Sense
Qlik Sense is the embedded offering from Qlik’s general-purpose BI tool. It provides multiple ways to embed analytics, ranging from basic iframes to advanced in-app integration. The simplest method is to use Qlik’s Single Integration API to generate an embed URL for a chart or dashboard, and then drop it into an <iframe> on your page.
This requires minimal code and gets something on the screen quickly, but the trade-off is an isolated frame – it won’t naturally share styles or state with your app (beyond a few URL parameters).
For teams that need more interactive embedding, Qlik offers a JavaScript Capability API. Using this, you can render Qlik charts directly in your webpage’s DOM and hook them into Qlik’s analytics engine via JavaScript. In practice, this means your application can programmatically create charts, apply filters, and respond to user selections in the embedded Qlik visuals.
For example, a filter change in your React app could update a Qlik chart, or clicking a data point in the chart could trigger something in your app, all without an iframe barrier. More recently, Qlik introduced Qlik-embed, a set of web components (and React components) that greatly simplify this process.
With Qlik-embed, developers can use HTML tags like <qlik-embed> or equivalent React components to insert analytics, and under the hood, it handles the connectivity (using Qlik’s Nebula.js) without requiring you to manage low-level API calls.
This approach tackles many iframe pain points – the embedded content runs in the same context as your app, giving better control, no cross-origin headaches, and a more unified user experience.
Still, the no-iframe methods come with some friction. To use Qlik’s APIs effectively, you’ll need to get comfortable with its object model and authentication flows, which can take time to understand. Some developers report that setting up identity management and secure access across environments isn’t as intuitive as it could be. There’s also limited flexibility for fully custom UI components unless you dive into Nebula.js directly, which adds complexity.
GoodData
GoodData offers embedded analytics with a developer-first approach that avoids iframes entirely. Its modern stack includes a React-based SDK called GoodData.UI, which allows you to render dashboards and individual insights directly inside your application as native components. You import charts as JSX elements, passing parameters like workspace ID, measures, and filters as props.
Since everything lives inside your DOM, you can apply your own CSS, modify layout behavior, and wire up app-level interactions using standard React methods. This removes the clunky styling issues and cross-domain restrictions that come with iframe embeds.
There’s also support for:
- Token-based authentication for secure access
- Custom data filtering and drill interactions
- Event handling APIs to listen for clicks and selections
- Theming via your own design system
GoodData’s backend is built to serve multi-tenant SaaS use cases, so embedding is not just skin-deep. You can also define logical data models and user roles centrally, and then expose personalized dashboards based on the user's login credentials.
However, while the developer experience is strong, there are a few trade-offs. GoodData’s SDK is React-specific, so teams using Vue, Angular, or plain JavaScript will need workarounds or wrappers. Some core features, like advanced visual customization or specific chart behaviors, may require additional backend configuration or integration with GoodData’s logical data model.
Developers have also noted that onboarding can take time due to the level of abstraction in the SDK. Understanding how to map data models to frontend components and manage identity across tenants may take effort, especially if you're new to the platform.
Embedded analytics tools that rely on iframes
These tools support iframes for embedding, but also give developers a choice of using a software development kit or an API. If you need more flexibility and options, these should be on your shortlist.
Looker Embedded
Looker primarily uses iframe-based embedding, but it provides a JavaScript Embed SDK to offer additional control. You start by generating a secure signed URL for the content you want to embed (dashboard, tile, or explore) and insert that into an <iframe> tag.
So, while Looker reps may tell you that they don’t use iframes… That’s far from the truth.
From there, the Looker Embed SDK allows your parent app to:
- Apply filters dynamically
- Respond to user interactions (like drill-downs or selections)
- Resize the iframe container programmatically
- Control navigation between embedded views
Although the iframe sandbox still applies, the SDK uses postMessage to pass events and commands back and forth between Looker and your app. This setup lets you react to user actions without needing a full page reload or manual DOM polling.
Customization is decent, but styling is still mostly confined within Looker’s interface. While you can apply themes via Looker’s LookML or set up custom parameter passing, full DOM-level styling isn't possible due to iframe boundaries.
In short, Looker’s embedding is iframe-first. Still, its SDK gives you enough tools to make it feel connected to your app, especially if you’re building internal tools or partner portals that don’t require deep visual integration.
Tableau Embedded
Tableau’s embedding process revolves around iframes, but is supported by a mature JavaScript API that lets you interact with visualizations post-load. You can embed Tableau dashboards, stories, or views by constructing a URL and placing it inside an iframe container.
The Tableau JS API then gives you control to:
- Apply filters, parameters, and highlight actions
- Capture events like tab switches or mark selections
- Export data from the embedded viz
- Trigger external app behaviors based on user interaction
The visualization in Tableau Embedded is still rendered inside an iframe that the API wraps and manages for you, which makes it less than ideal for true customization.
Despite the iframe base, this API allows a decent level of integration and responsiveness. For example, if a user selects a data point in a chart, your app can immediately respond with new UI components, triggered via the JavaScript callbacks.
Styling, however, remains confined to Tableau’s rendering context. You cannot directly modify the look of charts using CSS; however, Tableau allows some theme customizations within the authoring tool.
For teams using Tableau Server or Tableau Cloud, SSO and token-based authentication are available to make the experience more secure. If you need rich interactions but are okay with some visual separation, Tableau’s iframe+API method works well.
Power BI Embedded
Power BI Embedded requires iframes to display reports inside external apps. Microsoft currently does not support embedding content directly into your DOM. A typical integration uses a secure, signed embed URL or token inserted into an <iframe> element, often loaded and controlled via the Power BI JavaScript client SDK or REST API methods under the “App owns data” model.
Users must authenticate through Microsoft Entra (Azure AD), and a sign‑in is required unless the browsing session is already active. Single sign-on and token renewal mechanisms are available, but there is no non-iframe embed option.
The JS SDK empowers dynamic filter application, report navigation, and resizing of the iframe container. You can respond to events like data selections or export actions. Styling remains confined to Microsoft’s rendering sandbox, and you cannot inject CSS directly into the report context.
For developers and CTOs, this means iframe constraints limit performance and control. Authentication and token lifetimes are managed via Azure settings. So, embedding is straightforward, but it doesn’t have deep visual integration into host applications.
ThoughtSpot Embedded
ThoughtSpot offers two embed approaches: the recommended Visual Embed SDK and a legacy iframe embedding method when JavaScript use is restricted. The SDK uses JavaScript (or React wrappers) to render a Liveboard or search interface inside a container element, but still places content inside a managed iframe under the hood.
This enables API‑based customization, filter control, and event coupling between the host app and analytics layer.
However, the reality is that even the Visual Embed SDK is just iframes under the hood, unless you want to forego the native UI and interactions. In this case, you’re only getting access to the data via the API, and not the dashboarding functionality.
If your platform disallows custom JS, ThoughtSpot can embed via a raw <iframe> using SSO or basic authentication. This method involves manually setting src, handling CORS/CSP allowlists, and relying on postMessage for communication. There is no DOM‑level control over styling or layout in this mode.
The SDK gives access to runtime filter updates, embed events, and host event triggers, which can respond to user actions. Authentication supports SAML SSO and trusted authentication configurations. Both options are officially supported, but SDK embedding is the better choice for richer developer integration and control.
That said, there are limitations. Even with the SDK, the analytics content still renders inside a managed iframe, which means you won’t get full DOM-level control over layout or styling. You can’t directly apply CSS to embedded elements, and branding is mostly confined to what ThoughtSpot allows through its configuration options.
In addition, while the SDK is a big step up from static iframes, developers report that working with the embed APIs involves some learning curve, especially when integrating advanced filters or authentication flows. And because the SDK is built around iframes, you still deal with context isolation and some debugging friction compared to true DOM-level embedding.
Domo (Domo Everywhere)
Domo Everywhere, also known as Domo Embed, ships analytics via iframes only. The embedding workflow uses an embed token generated server‑side, then passed into the iframe's src or srcdoc form to authorize the content.
Although a few community posts speculate about a Domo JavaScript SDK to render without an iframe, no official product support exists. The dashboard embed option remains strictly iframe‑based. Developers can interact with the embed via Domo’s JS API, which listens and posts messages for filtering or data export, but the visual content remains sandboxed.
You can embed public, private, or customer‑facing dashboards using similar iframe-driven flows. The token mechanism handles row‑level or user‑specific permissions.
From a product management perspective, this is simple to deploy and secure, but it doesn’t have the UI cohesion possible with native DOM embedding. The embedded cards or dashboards appear visually separate, and customization is limited to the host iframe wrapper and external controls.
Say goodbye to iframes, for good
Embedding with iframes is no longer the industry standard. While iframes are omnipresent and difficult to avoid, newer approaches such as web components offer more flexibility and customization, better accessibility, faster performance and ease of use for your team and your end users.
If you want the best of both worlds, you can use a tool that combines a modern approach with iframes, but you’ll only be making a compromise for everyone involved.
Try Embeddable instead.
Frequently asked questions
What is an iframe, and why is it used in embedding analytics?
An iframe is an HTML element that allows you to embed another webpage inside your own. Many BI tools use iframes to embed dashboards quickly because they’re easy to implement and isolate the embedded content from the host application.
Why are iframes considered a poor choice for embedded analytics?
Iframes isolate the embedded content, making it harder to style, interact with, or integrate smoothly into your app. They can introduce layout issues, reduce accessibility, limit SEO impact, and make event handling and testing more difficult.
Which tools let you embed analytics without using iframes?
Tools like Embeddable, Sisense (via Compose SDK or Sisense.js), Qlik Sense (via Capability API or Qlik-embed), and GoodData (via GoodData UI) allow native embedding using JavaScript or React components, avoiding iframes entirely.
Can tools that use iframes still offer interactivity?
Yes, many tools that rely on iframes, such as Looker, Tableau, and Power BI, provide SDKs or APIs that allow some interaction between the embedded content and the host app. However, the level of integration is still limited by iframe boundaries.
What’s the best approach for a seamless embedded analytics experience?
For full control over styling, interactivity, and app-level integration, using a tool that embeds natively (without iframes) is the best approach. These tools behave like part of your frontend codebase and offer a more integrated experience for users and developers.
