QueryPanel is the embedded analytics platform for multi-tenant SaaS. Primary product: a headful React SDK (Notion-like dashboards and AI assistant). Secondary: a headless Node SDK for zero-trust custom UI. Searches that look like “fury query panel” almost always mean QueryPanel.

Is this another BI tool?

QueryPanel is infrastructure for embedding analytics and generating safe SQL, built for product surfaces, not standalone analyst workspaces.

How do you handle tenant isolation?

Tenant context is part of generation and execution, not something you toggle later in a dashboard filter.

What does implementation look like?

Attach your database with the SDK, wire auth claims, and embed UI where customers already work. Scope follows your surfaces, not building a query engine from scratch.

How do you keep AI SQL accurate as schemas evolve?

Ground generation in synced schema metadata and your knowledge base (annotations, glossaries, and examples) so retrieval and SQL stay aligned with how your data model actually works.

How are tenants counted?

A tenant represents a distinct customer or organization within your SaaS product. We count the number of unique tenants that access or generate analytics in a given billing month.

What counts as an AI chart?

An AI chart is generated whenever an end-user asks a natural language question that results in a new chart, or when an editor uses AI to create or modify a dashboard block.

What happens when limits are exceeded?

You can purchase overage credits for AI charts. For tenant limits, we'll notify you when you approach your plan's limit and help you upgrade to the next tier. We never cut off access for your end-users without warning.

How are AI models selected?

We support OpenAI, Gemini, Anthropic, and even OpenRouter. Bring-your-own-key is available from Starter and above (including Growth and Scale). Custom plans also support bring-your-own-model setups. If you want a specific provider or model path, ping us at csaba.ivancza@querypanel.io.

Embeddable vs Luzmo (and where QueryPanel fits)

Code-owned web components versus a hosted editor with in-page embeds, compared for React SaaS teams.

Embeddable and Luzmo both put customer-facing dashboards inside your product without a classic BI rollout, but they split on who builds the UI. With Embeddable, your developers write chart components in React, register them in code, and the dashboard mounts as an `<em-beddable>` web component with no iframe. With Luzmo, you design dashboards in a hosted editor and embed them through `@luzmo/react-embed` or its Vue, Angular, and web component packages; since October 2026 view mode renders in the page, while the embedded editor still uses an iframe. QueryPanel is the third option for React and Postgres multi-tenant SaaS that wants a finished, AI-assisted workspace tenants customize themselves.

Last reviewed October 19, 2026. Vendor facts are checked against public docs and pricing pages on that date.

Start building Read the docs

Comparison at a glance

This table summarizes typical positioning. Every vendor changes over time—validate details against current documentation and your security review.

Dimension	Embeddable	Luzmo	QueryPanel
Embed model	`<em-beddable>` web component in your DOM, authorized by a short-lived token from the Tokens API; no iframe.	In-page rendering by default since October 2026 (opt back into `embedMode: "iframe"`); the embedded editor still uses an iframe.	First-class `@querypanel/react-sdk` components—`QuerypanelEmbedded` for a full dashboard, or `QueryPanelProvider` with `QueryInput` / `QueryResult` for a bespoke flow. They render in your React tree like any other product screen (layout, router, modals, tokens)—not a separate iframe "mini app" on another origin. Mint short-lived JWTs on your server; never ship your workspace private key to the browser.
React SDK	No React wrapper; render the custom element in JSX. Chart components themselves are React you write and register with `defineComponent`.	`@luzmo/react-embed`, plus Vue, Angular, and web component packages for finished dashboards and single charts.	`@querypanel/react-sdk` with `QuerypanelEmbedded` for the full workspace, plus provider and query components for custom flows.
Who builds the charts	Your developers build chart components in code; product people arrange them in a no-code builder or as YAML dashboards as code.	Luzmo's chart library and hosted editor; your team or customers design dashboards without writing chart code.	The AI assistant generates charts from questions; tenants pin and arrange them in a Notion-like workspace.
Multi-tenancy mechanism	Security context in the server-issued token drives row-level security or access policies; environments can route customers to their own databases.	Authorization token with a suborganization per customer, parameter overrides for tenant filters, and connection overrides for per-tenant databases.	Tenant column declared at database attach; RS256 JWT minted by `@querypanel/node-sdk` carries the tenant ID; tenant filter applied at SQL generation and checked before execution.
AI / natural language	AI endpoints let an agent query data models and add charts to Custom Canvas; requires Custom Canvas and only queries datasets enabled for it.	Luzmo IQ: chat and prompt-to-chart in the embedded experience, included in the current published plan with AI usage metered.	Natural language to SQL and chart generation are the main path; the assistant edits tenant dashboards.
End-user dashboard editing	Custom Canvas: end users build and save dashboards from datasets and chart templates you enable, in the same web component.	Embedded editor for designer or owner roles; viewers with use rights can duplicate dashboards or create variants.	Tenants fork shared dashboards and customize their own copy with AI help.
Semantic layer / modeling	Data models and datasets defined in code alongside your components.	Datasets and formulas configured in Luzmo, including parameterized SQL datasets.	Gold SQL queries (curated examples the model prioritizes), database annotations (business context on tables/columns, re-embedded with schema), glossary (domain terms and definitions), and tenant-level definitions (isolation field, enforcement, and per-tenant sync context so every ask() is grounded in the right customer slice—not a one-size global prompt).
Data plane & credentials	Embeddable connects to your database and runs queries through its hosted service; the API key stays on your server.	Luzmo connects to your database or stores data in Luzmo; queries run through Luzmo's hosted service.	Headless Node path runs SQL with your own drivers, so credentials and rows stay on your servers.
Deployment	Embeddable-hosted service.	Luzmo-hosted in EU or US multi-tenant regions, with dedicated VPC environments on custom contracts.	Hosted service with React and Node SDKs; zero-trust headless mode keeps execution in your environment.
Pricing shape	No public prices; flat monthly subscription quoted after a scoping call, with unlimited usage and white-label included.	From €1,995 per month (USD list $2,495) billed annually, plus AI and usage; enterprise terms custom.	Counts unique tenants per billing month, not seats or sessions; AI chart generation metered separately; free tier.
Time to first embed	Longer up front: build and publish chart components, define models, then embed.	Short: design a dashboard in the editor, generate a token server-side, drop in the component.	Short: attach a database, mint a JWT, render `QuerypanelEmbedded`; customers can ask questions immediately.

Who builds the charts decides most of this choice

Embeddable's model is bring your own components. Each chart is a React component with a companion `.emb.ts` file that calls `defineComponent` to declare inputs and load data; once published, product people arrange those components in Embeddable's builder. That gives you exact control and costs a sprint or two of chart, theming, and empty-state work before customers see anything. Luzmo ships the charts. Your team or customers design dashboards in its editor and you embed them. If your design system team wants control, lean Embeddable. If you want dashboards this month without front-end work, lean Luzmo.

Iframes: closer than it used to be

Embeddable has always rendered in your DOM through the `<em-beddable>` web component, including Custom Canvas, where end users build dashboards. Luzmo's October 2026 release made in-page rendering the default for its embed libraries, and you can opt back into `embedMode: "iframe"`. The new mode needs `wss://` access to Luzmo's API host. Luzmo's docs note that when `editMode` is anything other than view, the embedded editor still renders in an iframe. If customers will edit dashboards, open DevTools in both proofs of concept and search the DOM for `<iframe`.

AI: product feature versus building block

Luzmo IQ is a product feature: chat and prompt-to-chart inside the embedded experience, included in Luzmo's current published plan. Embeddable's AI is more of a building block. Its AI endpoints let an agent query data models, read a user's Custom Canvas, and add charts, but they require Custom Canvas on the dashboard and only query datasets enabled for it. If AI is a launch requirement, Luzmo is further along of the two. QueryPanel puts the AI assistant at the center of the workspace.

When Embeddable or Luzmo is the better fit

Honest tradeoffs help your team pick faster—and match how buyers actually decide.

Choose Embeddable when your design system is strict and your developers want to own every chart as a React component, with a no-code builder layered on top for product people.
Choose Embeddable when no iframe anywhere is a hard requirement, including the surface where customers build their own dashboards (Custom Canvas).
Choose Embeddable when you want one flat, quoted subscription with unlimited usage and white-labelling included, rather than a platform fee plus metered AI usage.
Choose Luzmo when you want designers or analysts to build dashboards in a hosted editor without writing chart components, and want a large chart library on day one.
Choose Luzmo when you need a dedicated React package plus Vue and Angular packages across several front ends, and want Luzmo IQ for chat and prompt-to-chart in the same contract.
Choose Luzmo when per-tenant database connections matter: embed tokens can override a connection so each customer queries its own database.

When QueryPanel is the better fit

Pick Embeddable for code-owned charts and Luzmo for a hosted editor. Pick QueryPanel when your product is React on Postgres, many tenants each want to customize dashboards, and an AI assistant should do most of that work inside your own UI.

You want a trainable knowledge system—gold queries, DB annotations, glossary, and tenant-aware definitions—so NL→SQL and charts reflect your business, not generic schema-only guesses.
You want a finished dashboard workspace on day one: render `QuerypanelEmbedded` and customers can ask questions and build dashboards before your team writes a single chart component.
AI questions are a launch requirement, not a roadmap item: QueryPanel's assistant writes SQL for your schema, renders a chart, and edits the tenant's dashboard.
Tenants should fork shared dashboards and customize their own copy inside your React app, with no iframe for viewing or editing.
You need a headless zero-trust Node path where database credentials and query results stay on your servers.
You want pricing that counts tenants per month, not dashboard sessions or platform fees plus usage.

Pricing notes

Checked October 19, 2026. Pricing changes; confirm on the vendor pages before you budget.

Embeddable and Luzmo

Embeddable: as checked October 19, 2026, its pricing page publishes no prices. It sells a flat monthly subscription with unlimited usage and white-labelling included, quoted after a short scoping call, and says MAUs, dashboard views, and query volume are not the main pricing driver. Luzmo: from €1,995 per month billed annually (USD list $2,495) as a platform fee, plus AI and data usage; enterprise contracts are custom. Confirm both pages before you budget.

QueryPanel

QueryPanel pricing is tenant-based: plans count unique tenants per billing month, not end-user seats or dashboard sessions. AI chart generation is metered separately, and a free tier is available. See the pricing section for current plans.

Sources: Embeddable pricing, Luzmo pricing, QueryPanel pricing

Migrating from Embeddable or Luzmo to QueryPanel

1. Inventory dashboards, components, and tokens
From Embeddable, list published dashboards, custom components, and Custom Canvas datasets. From Luzmo, list dashboards, variants customers created, and datasets. In both cases record which customers open which dashboard, and where your backend issues tokens.
2. Map the tenant mechanism to a tenant column
Embeddable's security context and Luzmo's suborganization and parameter overrides usually point at the same column, such as `account_id`. Declare it as the QueryPanel tenant field and mint RS256 JWTs with `@querypanel/node-sdk` from the endpoint that issues Embeddable or Luzmo tokens today. Tenants on their own database need a separate connection.
3. Turn models and datasets into trainable knowledge
Sync the schema, then convert Embeddable data models or Luzmo dataset formulas into gold SQL queries, annotations, and glossary terms. Add tenant-level definitions where customers compute a metric differently.
4. Embed QuerypanelEmbedded on one route behind a flag
Render `QuerypanelEmbedded` from `@querypanel/react-sdk` on one analytics route for internal users and a few pilot tenants. Recreate the most-used dashboards as shared templates tenants can fork. Leave the `<em-beddable>` element or Luzmo component in place elsewhere.
5. Compare numbers and customer edits per tenant
For each pilot tenant, compare totals and trends against the existing dashboard. Rebuild a few customer-created Custom Canvas boards or Luzmo variants with the AI assistant to check that tenants can still make the changes they rely on.
6. Cut over and remove the old token service
Move remaining tenants, then remove the old components, the token endpoint, and API keys. Export customer-created dashboards first if customers will want a reference copy.

Comparison FAQ

Is Embeddable or Luzmo better for React?

It depends on who builds the UI. Luzmo has a dedicated `@luzmo/react-embed` package and a hosted editor, so React teams embed finished dashboards quickly. Embeddable has no React wrapper, but its chart components are plain React that your developers write, mounted through a web component. QueryPanel ships a full React workspace, `QuerypanelEmbedded`, with an AI assistant built in.

Which is cheaper, Embeddable or Luzmo?

Neither is cheap by default, and only Luzmo publishes a number: it starts at €1,995 per month billed annually, plus AI and usage. Embeddable publishes no prices; it quotes a flat monthly subscription with unlimited usage after a scoping call. Get both quotes in writing. QueryPanel counts tenants per month and has a free tier.

Do either Embeddable or Luzmo use iframes?

Embeddable does not; dashboards and Custom Canvas mount as a web component in your DOM. Luzmo's view mode renders in the page by default since October 2026, with an optional iframe mode, but its embedded dashboard editor still uses an iframe. QueryPanel renders both viewing and editing as React components in your app.

How do Embeddable and Luzmo isolate tenant data?

Embeddable's server calls its Tokens API with a security context that drives row-level security or access policies, and environments can map customers to their own databases. Luzmo's authorization token sets a suborganization per customer, parameter overrides for tenant filters, and optional connection overrides. QueryPanel declares a tenant column and carries the tenant ID in a server-minted RS256 JWT.

Can customers build their own dashboards in Embeddable or Luzmo?

Yes in both. Embeddable's Custom Canvas lets end users build and save dashboards from datasets and chart templates you enable. Luzmo's embedded editor opens for tokens with a designer or owner role, and viewers can create variants of dashboards. QueryPanel lets tenants fork shared dashboards and change them by asking the AI assistant.

When is QueryPanel a better choice than both?

When the product is React on Postgres, ClickHouse, or BigQuery, many tenants each want different dashboards, and AI questions must work at launch. QueryPanel is not a full BI suite and has a smaller chart catalog than Luzmo, so test it against your must-have chart types and your own schema before deciding.

Still evaluating Embeddable, Luzmo and QueryPanel?

Start on the free tier, embed one dashboard, and compare implementation time against your current shortlist.

Start free All comparisons