Semaphor vs Looker
Looker-grade governance without the LookML tax: native embedding, flat pricing with no per-user fees, full-featured self-hosting, and agents included.
Last verified July 2026 · Based on publicly available documentation. Spot an error? Email hello@semaphor.cloud.
One governed model can serve internal BI and embedded analytics alike; Looker helped establish that pattern. Semaphor delivers the same outcome without the parts that hurt: no LookML specialists on the critical path, no per-user licensing stacked by role, and no second-class self-hosting. Then it goes further, with a Data App SDK, briefings, and agents that build. One governed core serves your analysts, your customers, and your agents.
- You want governed analytics without hiring for a modeling language
- You want to go past dashboards, with a Data App SDK and briefings that deliver what changed
- You want flat pricing with no per-user fees, and AI included instead of metered
- You need self-hosting with the full feature set, not a second-class tier
- You want the dashboards themselves version-controlled, not just the model
- You want agents building and maintaining dashboards through MCP
- You are a large enterprise on Google Cloud and BigQuery with a dedicated data engineering team
- You want a long-established governed semantic layer and will invest in LookML to get it
- You are embedding at very high scale and the Embed edition quotas fit your traffic
- Signed iframe embedding with user attributes covers your product needs
- Six-figure-adjacent, sales-negotiated contracts are normal procurement for you
At a glance
| Dimension | Semaphor | Looker |
|---|---|---|
| Primary focus | Embedded analytics and internal BI from one governed, agent-native core | Enterprise governed BI on Google Cloud, with a dedicated Embed edition |
| Pricing model | Flat platform pricing, free tier to start, no per-user fees | Edition contracts on annual commitments, per-user tiers by role, and AI metered by data tokens |
| Embedding | JWT-signed iframe embedding in any framework, fully white-labeled, on all paid tiers | Signed iframe embedding with the Embed SDK and a cookieless mode |
| Beyond dashboards | Data App SDK for building complete governed data apps; briefings deliver what changed, why, and where to look, on a schedule | Dashboards and Looks with scheduled deliveries of existing content |
| Semantic layer | Semantic Domains: relationships, auto-join, calculated fields, AI-assisted setup in the UI | LookML: capable, but authored by Developer-licensed users in an IDE plus git |
| Multi-tenancy | First-class tenants with their own users, roles, and groups, plus three isolation levels, on all paid tiers | User attributes plus access_filter row security in LookML; no tenant object |
| Version control | GitHub integration for dashboards: commit, history, restore, promotion | Git-native LookML models; UI-built dashboards are not version-controlled |
| AI and agents | Agent-native: MCP server, agents build governed dashboards verified live | Gemini in Looker (conversational analytics), metered by data tokens, Google-hosted only |
| Self-hosting | Docker-based self-hosting on paid tiers, full feature set | Customer-hosted exists but lacks Gemini, Looker reports, and the managed MCP server |
What Looker got right, and what it costs
Looker’s core idea is right: define business logic once, in a governed model, instead of scattering it across a thousand workbooks. LookML plus signed embedding plus user attributes is a widely deployed pattern for multi-tenant embedded analytics.
The cost is structural. Every governed change flows through LookML, written by Developer-licensed specialists in an IDE with a git workflow. The platform is also split into Looker (original) and Looker (Google Cloud core), with the newest capabilities, Gemini, Looker reports, and the managed MCP server, gated to Google-hosted instances. Semaphor aims at the same governance outcome with a fraction of the ceremony: Semantic Domains are defined in the UI with AI assistance, and the same model serves dashboards, self-service exploration, agents, and briefings.
Pricing
Looker is licensed by platform edition (Standard, Enterprise, Embed) on annual commitments of one to three years, with per-user pricing tiered by role (Viewer, Standard, Developer) layered on top. Gemini features add a third, usage-metered dimension: data tokens, with overage billing beginning October 2026. The costs stack, and every new analyst, viewer, and AI question moves the number.
Semaphor uses flat platform pricing with no per-user fees, and AI and agent capabilities are included rather than metered. The free tier includes embedding, so you can validate the integration before any procurement conversation starts.
Embedding
Looker embeds through cryptographically signed iframe URLs carrying the user identity, permissions, and user attributes, with an Embed SDK managing frame creation and messaging, and a cookieless mode for modern browser constraints. It is proven infrastructure, and it presumes the LookML model and Developer-licensed authors already exist before the first dashboard renders.
Semaphor embeds the same way, minus the prerequisites: sign a JWT server-side, drop in the URL, fully white-labeled in any framework. Then it goes further than the dashboard: the Data App SDK builds complete governed data apps in your own React code, agents build dashboards and data apps over MCP, custom visuals plug in as React components, and briefings deliver what changed, why, and where to look next, on a schedule.
Multi-tenancy and security
Looker’s pattern is well established: user attributes set per embed user in the signed URL, and access_filter in LookML injecting row-level security into every query. It works, with the operational details documented in Looker’s row-level segmentation guide: every user needs attribute values, user-editable attributes cannot be used, and isolation depends on disciplined closed-system configuration.
Semaphor implements the same row-level pattern without the modeling-language prerequisite, and adds schema-level and connection-level isolation for tenants that need harder walls. Policies attach at query build time on every query path, including agent-generated queries.
The bigger structural difference is that Semaphor has a tenant model, not just tenant filters. Organizations, tenants, and tenant users are first-class objects: each tenant carries its own users, roles, groups, sharing boundaries, and defaults, down to per-tenant fiscal calendars and number formats, and organization-level appearance controls white-label the whole surface. Tenant users build and share dashboards strictly inside their tenant, enforced server-side. In Looker, the tenant exists only as attribute values on embed users; the administrative shell around them lives in your own code.
Version control
LookML is where Looker’s git story begins and ends. Models get real branches, dev mode, and deploy-to-production. Dashboards split in two: LookML dashboards defined as YAML are version-controlled, but the dashboards users actually build in the UI live in folders with no version control at all.
Semaphor version-controls what your team actually edits. Dashboards, models, and configs commit to GitHub from the toolbar, with full history, diffs, restore, and environment promotion via the API.
AI and agents
Gemini in Looker brings conversational analytics, a visualization assistant, and natural-language-to-Python analysis, grounded in the LookML model. It requires admin enablement, per-feature permissions, and Google-hosted instances, and it is metered by data tokens with overage billing from October 2026.
Semaphor treats agents as builders, not just question-answerers. Through MCP, Claude or Codex discover your semantic model, execute governed queries, and create dashboards and data apps verified against live results, on cloud or self-hosted, with changes committed to GitHub. Briefings close the loop by delivering what changed without anyone asking.
Where Looker still has the edge
Credit where it is due. Looker keeps the edge in these areas:
- Semantic-layer maturity: LookML has years of production hardening, dialect abstraction, and DRY discipline.
- High-volume embedded deployments: the Embed edition ships 500K API calls per month.
- Git-native model development with real branch and deploy workflows for the modeling layer.
- Deep BigQuery and Google Cloud integration, including GA conversational analytics grounded in the model.
- Enterprise governance surface: content validation, audit, and admin controls built for thousand-user deployments.
Those advantages come with prerequisites: a LookML team, a Google-hosted deployment, and an enterprise procurement cycle. If you have all three and BigQuery at the center of your world, Looker earns its keep. If what you actually need is governed analytics for your team and your product this quarter, Semaphor gets you the same guarantees with a UI-defined semantic layer, a React component, and pricing that does not grow with your seat count.
Migrating from Looker
Teams usually consider a move when LookML maintenance outgrows its value, when embed pricing resets at renewal, or when they need full-featured self-hosting, data apps, or briefings.
- 1Connect Semaphor to the same warehouse and databases
- 2Recreate the explores your embedded product uses as a Semantic Domain (AI-assisted setup proposes fields, joins, and metrics)
- 3Rebuild key dashboards, or have your coding agent port them via MCP
- 4Point your embed at Semaphor’s signed URL, validate with a pilot tenant, then migrate the rest
Sources
- Looker pricing
- Looker signed (SSO) embedding
- Looker Embed SDK introduction
- What is LookML
- Looker access_filter (row-level security)
- Row-level segmentation in embeds
- Types of dashboards (version-control split)
- Choosing a hosting option (customer-hosted limitations)
- Gemini in Looker overview
All third-party pricing and feature claims reflect public documentation as of July 2026 and may have changed since.