QlikSense is one of the best business intelligence tools in the game. But does that translate to embedded analytics, too? Like many other BI tools, Qlik was built for internal reporting first, and embedded analytics capabilities second. This means it's not very customizable, the embedding experience is not the greatest, and there is a lot of small print when it comes to pricing.
However, many customers prefer Qlik because of its new AI powered analytics functionality, hoping they can make better decisions faster thanks to Qlik's insights based on machine learning.
Here's a full breakdown of Qlik Embedded, showing you if it's a good match for your business and your end users.
A brief history of Qlik Embedded
The core Qlik product for data analysis was launched way back in 1993, and the first time you could actually embed something was with Qlik View. You were limited to embedding through iframes only and the entire process wasn't very developer-friendly.
Then came Qlik Sense in 2014, allowing businesses to embed through APIs, and embedding with iframes became a little better.
They most recently launched Qlik Cloud in 2020, with support for the Nebula.js open-source framework, better multi-tenancy, and improved embedding options. This is the version of Qlik we'll be talking about today.
Let's explore everything from how easy it is to embed dashboards, how fast they load (and for how many users) and how much all of this will cost you.
The ease of embedding dashboards in Qlik
At the most basic level, you can embed individual Qlik charts or entire dashboards via iframes. Using Qlik’s Single Integration API, you generate a URL for the object you want and drop it into an iframe on your page. This requires minimal code, works immediately, and is a decent starting point for quick wins or MVPs.
The tradeoff? It’s isolated. You can’t easily pass data in or out, hook into events, or customize much beyond basic parameters – and you’ll have to handle access management with some workarounds.
When you need real integration, Qlik’s Capability APIs (JavaScript) are the next step. These let you embed charts directly into your app’s DOM and hook into Qlik’s associative engine. You can trigger selections, listen to events, and synchronize app state.
For example, your frontend filters can drive embedded Qlik charts, and selections made inside charts can push back to your application’s logic. This is the typical choice for serious embedded use cases that need interaction beyond just "view this chart."
For advanced control, Qlik exposes its engine directly via Enigma.js. This library gives you a low-level WebSocket connection to Qlik’s calculation engine. With it, you can fetch data programmatically, execute expressions, and drive your own UI components (even non-Qlik visualizations).
While powerful, Enigma.js requires a deeper understanding of Qlik’s data model and is best suited for scenarios where Qlik is purely a backend calculation service.
A more developer-friendly solution came in 2024 with the release of qlik-embed, Qlik’s new web components library. This is likely the go-to Qlik offering for most modern SaaS applications. Using standard HTML or frameworks like React, you can easily drop in tags like <qlik-embed> or <qlik-visual>, passing in configuration via attributes or JS.
Qlik-embed solves major pain points of iframe embeds: better control, fewer cross-origin issues, and direct API access for interaction. Behind the scenes, it leverages Nebula.js and removes much of the boilerplate developers used to write manually.
Finally, for custom visualizations, Qlik supports extensions. These are essentially pluggable chart components written in standard web tech (HTML, JS, CSS). Extensions behave like native Qlik objects but allow a little more flexibility in visualization logic and rendering. If Qlik’s built-in charts don’t cut it, extensions let you bring in libraries like D3 or Chart.js and still connect them to Qlik’s associative engine - however, doing this does create some limitations for you on the off-the-shelf features of Qlik.
Dashboard customization
Qlik supports custom themes (JSON-based), which let you change colors, fonts, backgrounds, etc.. You can apply themes at the app level so embedded charts will inherit some hallmarks of your product’s brand. This works well for general styling, but not for pixel-perfect design.
For example, developers often complain that tweaking font size, axis styling, and spacing is more complicated without hacks.
When embedding charts with iframe or Single API, your customization options are limited to URL parameters. This is fast to set up, but you get mostly Qlik’s default UI wrapped in your app. Good for quick wins, but not ideal if you want deep integration and a native-feeling user experience.
For tighter control, Capability APIs and qlik-embed are much better. These let you insert charts into your DOM directly, resize them, add your own page controls, and hook into selection events. You can create interactions where your app filters Qlik or Qlik filters your app.
qlik-embed in particular is very developer-friendly — it lets you use web components or React with simple config, without having to build everything with Enigma.js or Capability API.
If none of this gives you the control you want, you can go custom. Qlik supports extensions, which are custom visuals built in HTML, JS, and CSS. These behave like native charts but give you total freedom to design your own look or even integrate D3.js or other libraries.
However...
You cannot add your own code and fully customize the dashboards to match the look and feel of your app. You can do the following:
- Build custom visualization extensions (HTML, JavaScript, CSS). These run inside Qlik and render like any other chart. This lets you add your own visualization logic or integrate external libraries (D3.js, Chart.js, etc.).
- Use Enigma.js (Engine API) to talk directly to Qlik’s engine and fetch raw data. You can then do whatever you want with the data, render it in your own UI, process it, etc.
- Use Nebula.js to create your own visualizations and embed them without using Qlik’s native sheet UI. This is more streamlined than extensions and better for fully custom embedded experiences.
- Use qlik-embed + callbacks/APIs to react to events and control embedded objects from your app.
But once again, since Qlik is not truly headless, and doesn't let you tweak the code fully to make the embedded analytics dashboards feel native. You can achieve something that feels more custom than a standard off-the-shelf tool, but it will require deep Qlik expertise and quite a bit of work.
The visualizations
This part of the platform translates well from Qlik Sense. There is a rich variety of visualization types that help users get data-driven insights directly in their business applications.
Out of the box, Qlik supports most common chart types — bar, line, pie, scatter plots, pivot tables, KPIs, and more, along with more advanced options like maps, Sankey diagrams, and waterfall charts. These visuals are interactive by nature, meaning users can click, filter, and drill into data directly within the embedded views.
The performance
Your end users expect dashboards to load quickly to make data-driven decisions. Unlike internal reporting, embedded use cases typically require real-time data with fast response times. In this regard, Qlik does okay, but it's far from spectacular.
Qlik Sense’s performance in embedded scenarios can be viewed in two parts: initial load/render performance and interactive query performance. Overall, Qlik is known for reasonably fast in-memory analytics, but embedding introduces some overhead and considerations.
Iframe embedding is quick to set up but can introduce overhead, particularly when embedding many objects at once. Each iframe runs independently, which can slow page load times. More efficient approaches use Qlik’s JavaScript APIs or the newer qlik-embed web components, which share sessions and reduce resource usage.
The qlik-embed method, introduced in 2024, is especially optimized for modern embedding, reducing both code complexity and loading time.
Performance also depends on deployment scale. Qlik Cloud SaaS plans include different resource allocations, and higher-tier (Enterprise) plans reportedly deliver faster performance thanks to more powerful infrastructure.
While interactive performance (clicking, filtering) is consistently good across tiers, organizations with many concurrent users or very large apps may find Premium or Enterprise tiers necessary for optimal speed.
For best results, developers often preload apps or load charts on demand to avoid delays. Qlik can also dynamically optimize processes, determining how much data is sent to the client, helping maintain responsiveness even with large datasets.
In short, you may have to spend extra to get better performance. This probably makes you wonder how cost effective Qlik Embedded is compared to some other tools, so let's tackle that next.
Multi-tenancy in Qlik Embedded
If you're embedding analytics into a multi-tenant SaaS product, isolating customer data and controlling access is critical.
Qlik Sense supports this well, though the approach depends on whether you use Qlik Cloud or a self-hosted deployment.
The recommended approach in Qlik Cloud (SaaS) is simple but strict: One tenant per customer organization.
This gives full isolation — users, apps, data, and compute are completely separated. There is no chance of cross-tenant data leakage.
This is the safest approach for regulated industries and fits scenarios like healthcare, finance, or enterprise customers.
The tradeoff? It’s operationally heavy. If you have 200 customers, that’s 200 Qlik tenants to manage. Qlik provides APIs and automation tools to help with tenant provisioning and app deployment, but make no mistake — you’ll need DevOps to keep things smooth.
For lighter multi-tenancy, Qlik allows running multiple customers in a single tenant. But there’s a catch: Section Access (row-level security) becomes mandatory.
Section Access reduces data on load and dynamically filters what each user can see. You can map identities (like JWT claims or SAML attributes) to tenant IDs, ensuring each user only sees their data.
This works, but has risks and requires you to manage/maintain an access log. A misconfigured Section Access script can lead to data leakage. Qlik itself warns that single-tenant, multi-customer setups are only recommended for simpler scenarios (internal apps, smaller scale SaaS). For large external audiences, isolated tenants are the safer bet.
Modern tools like Embeddable take a simpler, more-logical approach to row-level security that does not require you to manage access controls in a separate config. You can simply pass through a user_id, org_id or other filter when you load the dashboard, and the filters will apply.
For on-prem (client-managed), it’s more flexible.
You can isolate customers via:
- Streams and Spaces → Separate app containers for each tenant.
- Section Access → Apply row-level data restrictions.
- Dedicated Qlik servers → Some OEMs run multiple Qlik servers for complete hard isolation.
Overall:
- Qlik gives you everything needed for multi-tenancy (tenant isolation + row-level security + content segmentation).
- Section Access + single app model is viable for smaller apps or when isolation requirements are relaxed.
- Multiple tenants (Qlik Cloud) gives isolation, but adds ops overhead.
Managing multiple tenants at scale requires automation — not something that works out-of-the-box. - Section Access rules are powerful, but brittle if not tested carefully.
The pricing model
Qlik markets itself as a premium product, which is reflected in its products' pricing. In addition to the high prices, figuring out exactly how much Qlik Embedded costs can seem like a wild goose chase.
Qlik SaaS/Cloud pricing has four tiers:
- Starter ($200/month for 10 users)
- Standard ($825/month)
- Premium ($2,750/month)
- Enterprise (Custom pricing)
The Starter plan goes out the window immediately, as it's for 10 users only and allows for up to 25GB of relevant data, which is simply not enough for any production-ready embedded analytics setup.
The Standard plan seems like a better offer as it has no user cap. However, you are still limited to 25GB of space, which you can upgrade for extra cost. You also get managed and shared spaces, which makes this a better choice for smaller teams and internal reporting.
The Premium plan is the least you would realistically need for embedded analytics use cases and it comes in at a starting price of $2,750 per month. It comes with 50GB of data, predictive analytics capabilities, 10GB of maximum app size, and guided onboarding.
The Enterprise plan makes the most sense for organizations that want to give seamless access to data insights to their end users and feel the benefits of the performance improvements offered on this higher plan. With 250GB of data and multi-region tenancy, it's built for larger teams from various industries.
Qlik calls this "capacity-based" pricing because it charges you for the volume of data that Qlik analyzes from your data sources. In the Enterprise plan, for example, you have 250GB of data spread across all of your users, and that's what you pay for. In theory, this sounds great because you know how much you pay monthly and yearly - assuming you don’t exceed your limit.
Qlik doesn't mention that it differentiates between Full and Basic users, who have different levels of access. Here's how they describe the differences in one of their help center pages:
Full users have access to:
- Creating shared spaces
- Creating, editing and publishing sheets and apps
- Working with Data integration
Basic users have access to:
- Viewing app content
- Creating notes
- Creating private bookmarks
The information isn't publicly available, but our research suggests that the Premium plan has 10 Full seats while the number of Basic seats is unlimited. Presumably, those 10 are intended for the people in your team, while the unlimited users can view the dashboards.
In other words, say goodbye to true self-service analytics and giving users the ability to create their own dashboards, change visualization types, slice and dice data and more.
Should you get Qlik embedded analytics?
If you already use the core Qlik product for internal reporting and data analytics, and you don't mind the subpar performance, embedding complications, and the lack of proper customization then it might be a good choice. But even then, Qlik Embedded is expensive and gives you less value for money compared to most other embedded BI tools.
If you need a dedicated tool for self service analytics, Qlik is not a good choice. It's built on top of an existing BI tool - and not built specifically for the embedded use case - which means the embedding is clunky, the customization options for interactive analytics are not that great and the pricing can be prohibitive.
Most importantly, you get a very limited number of users who can create their own dashboards, while the viewers are unlimited.
Consider Embeddable as an alternative
If you want to embed analytical capabilities directly in your product or app but need full control of the look and feel, Embeddable is the superior choice. It's truly headless, which means that you can import any charting library you like, infinitely extend the charts provided (in code) and ultimately,have full control of the user experience.
Dashboards load lightning fast, you get row-level security, end-user self-service options, and much more. And on top of that, you get a fixed, monthly subscription, and you'll always know how you're paying (no seat costs, usage costs or unexpected bills).
Last but not least, Embeddable is built embedded-first and it gives your end-users a truly native dashboarding experience, allowing them full access to their data insights.
Get access to Embeddable today to discover how Embeddable can help you deliver a truly remarkable, fast-loading and native-feeling experience for your customers without the complexity.
