Qlik Embedded Analytics: The Developer's Review

Qlik Sense is a long-established business intelligence (BI) platform from a company founded in 1993 (Qlik), and Qlik was named a Leader in the 2026 Gartner Magic Quadrant for Analytics and Business Intelligence Platforms, for the 16th consecutive year (Business Wire). But does that translate to embedded analytics, too? Qlik embedded analytics means placing parts of a full BI platform (charts, sheets, AI assistants) inside your own product. Like many other BI tools, Qlik was built for internal reporting first, and embedded analytics capabilities second. That heritage limits customization, makes embedding heavier to set up, and puts a lot of small print in the pricing.

That makes Qlik a strong choice when your analysts already build in Qlik. It is a heavier choice when the main job is native, multi-tenant, customer-facing analytics that your engineers own in code. Many teams are also drawn by Qlik's newer AI-powered analytics, hoping machine-learning insights will help their users make better decisions faster.

This review covers the embedding options Qlik supports today and how far you can customize them. It then looks at what the AI and no-code features add, and at what performance, tenancy and pricing mean in practice. That should tell you whether Qlik is a good match for your product and your end users.

A brief history of Qlik Embedded

The first time you could actually embed something from Qlik was with QlikView. You mostly relied on iframes, or on QlikView Workbench and the AJAX client to drop objects into a page using div tags (Qlik Help), and the process wasn't very developer-friendly.

Qlik Sense arrived in 2014. It let businesses embed through APIs and connect directly to Qlik's associative engine, which lets users explore data relationships freely rather than following fixed drill paths. Iframe embedding also got a little better.

Qlik's SaaS platform followed, with Qlik Sense Enterprise deployable entirely on Qlik Cloud from 2019 (Qlik), alongside the open-source Nebula.js framework and improved embedding options. This is the version of Qlik we'll be talking about.

The newest layer is qlik-embed, first released in December 2023 (qlik.dev). Qlik's developer hub now calls qlik-embed its primary embedding framework, and recommends it wherever possible because it provides most of the capabilities of iframe, Capability API and nebula/enigma embedding in a single package (qlik.dev).

Here is how the options compare, with Qlik's own view of each taken from qlik.dev (read 27 October 2026):

For a new Qlik Cloud project, then, qlik-embed is the stack to evaluate first. The other frameworks remain options for particular needs, such as a quick iframe embed with little code. Let's see how each method works in practice, starting with how easy it is to embed dashboards.

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. Qlik recommends qlik-embed wherever possible, since it provides most of the Capability APIs' capabilities in one package (qlik.dev), so for new embeds that need interaction beyond just "view this chart," qlik-embed is the path to evaluate.

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.

The most developer-friendly option is qlik-embed, Qlik’s 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 (Qlik Developer).

Dashboard customization

Qlik supports custom themes (JSON-based), which let you change colors, fonts, backgrounds and more. 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.

“Design and layout flexibility can be limited although not a concern for majority of use cases” - Verified user in retail (G2 review, 2024)

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, qlik-embed and the Capability APIs 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.

“It should improve the way you can create reports and visuals, it still doesn't have the flexibility of Qlik Desktop or Power BI.” - Eduardo P., Commercial Excellence (G2 review, 2023)

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 on Qlik Sense client-managed, but in Qlik Cloud they cannot be exported to image, PDF or PowerPoint the way native charts can (Qlik Developer). They let you write your own rendering code for a custom look or integrate D3.js or other libraries, but they still run inside Qlik.

There is a limit, though. You can add your own code with extensions and restyle dashboards with custom themes (Qlik Developer), but making Qlik's own dashboards match the look and feel of your app still takes real effort, and how far you get depends on the embedding method. Going further means building your own frontend on Qlik's engine. Your options include:

• Build custom visualization extensions (HTML, JavaScript, CSS) (Qlik Help). 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.) (Qlik Help).
• 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 because Qlik is not truly headless, it doesn't let you change the code fully to make embedded 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.

AI, automations and no-code embedding in Qlik Cloud

Charts are only part of what Qlik sells. Qlik Cloud Analytics also bundles AI-powered analytics, no-code automations and a toolkit that runs from no-code to pro-code. The useful question for a product team is which of these actually reach your customers.

AI and natural language interaction. Qlik Answers is Qlik's generative AI assistant. It lets users ask questions in plain language and get answers drawn from both structured data and unstructured content such as documents. Qlik now pitches agentic "Answers Agents" built on top of it. Alongside this, Insight Advisor offers natural language interaction with Qlik apps (Qlik Help), and on the Qlik Cloud Premium and Enterprise plans, Qlik Predict adds predictive models (Qlik, Qlik pricing). The promise is actionable insights for non-technical users without analyst help.

Automations and connectors. Qlik Automate is a no-code workflow builder with pre-built connectors into business apps. It can trigger alerts when key metrics move, push data into tools like Salesforce, or schedule report distribution (Qlik). Qlik also promotes embedding insights into the apps people already use, such as CRM records and external portals. That way, real-time insights appear inside existing workflow tools at the moment someone needs them for a decision.

No-code to pro-code. At one end, business users can share a chart with a generated embed snippet. At the other, developers can use qlik-embed, the REST APIs and a local development environment to build custom web applications. Qlik's message is that one platform covers both audiences.

For internal business users, these features can deliver valuable insights with little technical expertise. For a product team, the picture is narrower. Most automations and agents are designed around workflows that run inside Qlik, owned by people with a Qlik login and a basic understanding of its apps. Some do cross over: Qlik Answers can be embedded with qlik-embed, so an AI assistant can sit inside your product.

None of this changes the core job, which is making analytics feel like a native part of your app for every customer. Qlik's AI and no-code layer adds real value for teams that work inside Qlik, but it does little to make an embedded experience feel like your own product. That native feel still depends on the embedding method, and on how fast the result loads.

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, how Qlik performs depends on your workload, embedding method and configuration.

“Qlikview can sometimes struggle under our intense data loads, but we do push the limits here” - Ash Z., IT Business Analyst (G2 review, 2023)

Qlik Sense’s performance in embedded scenarios can be viewed in two parts: initial load/render performance and interactive query performance.

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.

qlik-embed is optimized for modern embedding: Qlik says it needs fewer lines of code and less memory than nebula.js embedding (qlik.dev).

Performance also depends on deployment scale. Qlik Cloud SaaS plans differ in features, capacity and app-size limits, but Qlik states that all editions provide the same speed and performance (Qlik Help).

While interactive performance (clicking, filtering) is consistently good across tiers, organizations with a lot of data or very large apps may need Premium or Enterprise for their higher capacity and app-size limits.

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, large deployments may have to spend extra for the capacity and limits they need. 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

Before we get to the price list, one more factor shapes what you'll pay and how much work you'll take on: how you separate your customers. If you're embedding analytics into a multi-tenant SaaS product, isolating customer data and controlling access is critical.

Qlik supports this well, though the approach depends on whether you use Qlik Cloud or a self-hosted deployment.

For OEM and external deployments that serve separate customer organizations, the recommended approach in Qlik Cloud (SaaS) is simple but strict: one Qlik Cloud tenant per customer organization (Qlik Help).

This separates customers logically, because each tenant has its own users, apps, data and security boundaries (Qlik Developer). That makes it a strong fit for regulated customers in areas like healthcare, finance or enterprise whose compliance and residency needs Qlik Cloud can meet, though not for those who need full control of their own data infrastructure or are in regions Qlik Cloud does not serve.

The tradeoff is the number of tenants: in this model each customer gets its own, so 200 customers means 200 tenants. Qlik automates their provisioning through its Platform Operations APIs, where your automation creates each customer's tenant, configures its identity provider and deploys the app templates (Qlik Developer), but you’ll need DevOps to build and run that automation.

For lighter multi-tenancy, Qlik allows running multiple customers in a single tenant. But there’s a catch: when customers share a single app, Qlik's guidance calls for row-level security, which in Qlik means Section Access (Qlik Developer).

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 own data.

The shared model also asks more of your team. You need to manage and maintain the access rules, and Section Access scripts need careful testing, because one misconfigured rule can show users rows they shouldn't see.

Authentication is what makes either model work. Both approaches depend on Qlik knowing exactly who each embedded user is. In Qlik Cloud, that usually means one of two routes. The first is single sign-on (SSO) through an identity provider using SAML or OpenID Connect. The second is a backend that issues JSON Web Tokens (JWT), or uses an OAuth client to start sessions on the user's behalf, which qlik-embed then uses.

Whichever route you pick, you configure how identity claims map to a tenant, a group or a Section Access value. You also own token lifetimes, user provisioning and what happens when a customer's users change. That is ongoing configuration work, not a one-off setup.

Modern tools like Embeddable, our own product, take a simpler approach to row-level security that does not require you to manage access controls in a separate config. You simply pass through a user_id, org_id or other filter in short-lived, scoped embed tokens when you load the dashboard, and the filters apply.

For on-prem (client-managed), it’s more flexible.
You can isolate customers via:

• Streams → A stream per tenant, whose security rules limit read and publish rights to that tenant's users (Qlik Help).
• 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 + identity mapping).
• 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, which is not something that works out-of-the-box.
• Section Access rules are powerful, but brittle if not tested carefully.

So Qlik can isolate customers and authenticate embedded users. Either way, though, you take on provisioning, identity mapping and access-rule maintenance that an embedded-first tool reduces to passing a filter.

The pricing model

Tenancy model and data capacity both feed into cost. On top of that, figuring out exactly what embedding will cost can feel like a wild goose chase.

Qlik Cloud Analytics pricing has four tiers. This is how Qlik's pricing page lists them (Qlik pricing, checked 27 October 2026):

The Starter plan goes out the window immediately. It includes 10 users (more can be purchased) and comes with a fixed 10 GB of data for analysis, with no option to buy more data. For most customer-facing embedded analytics, where both data and the number of people viewing it grow with your customer base, a 10-user plan with a fixed 10 GB of data is likely to be too small.

The Standard plan seems like a better offer because it is capacity-based rather than capped at 10 users. However, you start with 25 GB of data, and more capacity costs extra. You also get managed and shared spaces, which makes it a better fit for smaller teams and internal reporting.

Premium, starting at $2,750 per month, is the lowest plan on Qlik's pricing page that lists anonymous (public) access. It comes with 50 GB of data, predictive analytics capabilities and a 10 GB maximum app size.

Premium alone is not enough to embed analytics for people who never sign in, though. Qlik's help says sharing with people who don't log in “is only available with a Qlik Anonymous Access subscription” (Qlik Help). That subscription is a tenant of its own, hosted only in Qlik's Europe (Stockholm) region (Qlik Help). If your customers won't have Qlik identities, ask Qlik for that quote early.

“Rigid pricing, it's too expensive to scale to hundreds of thousands of users, when only they have need to report or basic consume.” - Verified user in insurance (G2 review, 2020)

The Enterprise plan, which starts at 250 GB of data and adds larger apps and multi-region tenants, makes the most sense for organizations that serve many end users at scale.

Qlik calls this "capacity-based" pricing because it charges for the volume of data Qlik analyzes from your sources. In the Enterprise plan, for example, you have 250 GB of data shared across all of your users, and that's what you pay for. In theory, you know exactly what you'll pay monthly and yearly, as long as you don't exceed your limit.

Capacity isn't the only variable. Qlik used to split users on capacity-based subscriptions into Full users and Basic users, who could only view. It no longer does: in January 2026 Qlik announced it was removing the split from 2 February 2026, so that any user who signs in to a capacity-based tenant counts as a Full User (Qlik Community). What each person can do now comes from roles alone. Qlik's help puts it this way:

“In capacity-based subscriptions, user actions depend only on assigned roles and permissions.” - Qlik Help

For view-only access, Qlik points to the Has restricted view role in managed spaces, which lets a user view sheets and apps created by others there, and create personal notes and private bookmarks (Qlik Help). Older user-based subscriptions keep their predefined Professional and Analyzer entitlements instead.

When you talk to sales, ask how embedded end users are counted against capacity and which role they need. Also ask what an Anonymous Access subscription would cost for your audience, and what happens when data volume outgrows your tier.

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 embedding complexity, the customization limits and the capacity-based costs described above, then it might be a good choice. But even then, compare Qlik Embedded's pricing with other embedded BI tools before you commit.

If you need self-service analytics built specifically for embedding in your own product, Qlik may not be the best fit. It's built on top of an existing BI platform rather than purpose-built for the embedded use case, which in our view makes embedding heavier to set up, limits customization of interactive analytics and can push costs up.

Consider Embeddable as an alternative

Embeddable is our product, so read this section with that in mind. It is a customer-facing analytics platform: a third-party platform built specifically for embedding analytics in your product, rather than a BI tool with embedding added on.

If you want to embed analytical capabilities directly in your product or app but need full control of the look and feel, Embeddable is worth evaluating alongside Qlik. It's truly headless, which means you can bring in the charting libraries you prefer and extend the charts provided in code. Ultimately, you keep full control of the user experience. Dashboards embed as an HTML web component that sits in your app like any other part of your UI.

You also get row-level security, end-user self-service options, and much more. And on top of that, Embeddable's pricing is a flat monthly subscription, with unlimited usage and no usage-based pricing (Embeddable pricing).

And because Embeddable is built embedded-first, your end users get dashboards that feel like a native part of your product.

Whichever you lean towards, put the same questions to Qlik, to us, or to any embedded analytics vendor before you sign:

• How is each customer's data isolated, and who maintains the access rules as customers come and go?
• How do embedded users authenticate, and are sessions based on short-lived, scoped tokens?
• Can we theme every chart, font and spacing value to match our product, without hacks?
• How fast do dashboards load at our expected concurrency, and on which plan?
• How do we version dashboard changes, test them, and roll back a bad release?
• Can users who never log in to the vendor's platform see analytics, and what does that cost?
• How are embedded end users counted for pricing, and what happens when we outgrow our tier?

Frequently asked questions

1. Is Qlik a good choice for embedded analytics in SaaS products?

It suits teams that already run Qlik internally. For native, multi-tenant, customer-facing analytics your engineers own in code, it is a heavier and costlier choice.

2. What are the main challenges of embedding Qlik?

Challenges include managing licenses, handling authentication for multiple users, and customizing the UI to match your product. It also requires a dedicated backend setup.

3. How does Embeddable compare to Qlik for embedded use?

Embeddable, our product, is embedded-first and headless: you control the look in code, pass row-level security filters in scoped tokens, and pay a fixed monthly price.

4. What is qlik-embed?

In Qlik Cloud, qlik-embed is Qlik's primary embedding framework, offering web components and framework wrappers such as React for charts, sheets, apps and Qlik Answers (qlik.dev). It was first released in December 2023 (qlik.dev).

5. How do you authenticate users when embedding Qlik?

Use SSO through SAML or OpenID Connect, or a backend that issues JWTs or uses an OAuth client. Then map identity claims to a tenant, group or Section Access value.

6. Can Qlik embed analytics for anonymous users?

Yes, but not with Premium alone. Qlik's help says anonymous access is only available with a separate Qlik Anonymous Access subscription (Qlik Help), whose tenant is hosted only in Qlik's Europe (Stockholm) region.