GoodData.AI Pricing 2026: MCP + Agent Builder + Alternatives

By Vishnupriya B, Data Analyst at Databrain. Data Analyst specializing in data visualization, SQL, Python, and data modeling.

Published May 7, 2026 · Updated May 20, 2026 (post-GoodData.AI rebrand + Agent Builder + MCP Server 27-tool refresh) · For: SaaS PMs, engineers, and CTOs evaluating GoodData.AI pricing for AI-native embedded analytics.

2026-05-20 refresh - three material changes since the prior version of this page. First, GoodData rebranded to GoodData.AI on April 30, 2026 - the rebrand signals the AI-native repositioning is now the primary product story, not a sub-narrative. Second, the Agent Builder launched April 22, 2026 as a multi-agent enterprise platform layered on top of the MCP Server, with 5 configuration surfaces (agents, tools, knowledge resources, evaluations, deployments) and A2A (Agent-to-Agent) protocol support added in May 2026. Third, the MCP Server expanded from 24 → 27 tools with three new Knowledge Tools added to the workspace + analytics-model tool cluster. The pricing structure itself (custom-quote across Cloud / CN) is unchanged, but the AI-tier conversation has materially expanded.

At a Glance

GoodData.AI pricing in 2026 is custom-quote across GoodData Cloud (managed SaaS) and GoodData CN (containerized self-hosted on Kubernetes), with the MCP Server (27 tools, beta), Agent Builder (multi-agent enterprise platform with A2A), and FlexConnect (Python custom data sources via Arrow Flight RPC) positioned as higher-tier AI capabilities rather than included in the base subscription. The April 30, 2026 GoodData.AI rebrand signals the AI-tier is now the primary product narrative.

What GoodData Costs (the public posture)

GoodData's official pricing page does not publish dollar figures. Pricing is custom-quote across the product surface - GoodData Cloud (managed SaaS), GoodData CN (containerized self-hosted), GoodData Free (limited free tier for individual developers), and the various enterprise editions.

The shape of a 2026 quote breaks down as follows.

The credible year-1 floor for a SaaS embedded deployment with multi-tenant + semantic-layer modeling + AI tier sits between $60K and $250K. Treat the table as orientation, not a price book.

What the line items look like in a real GoodData quote

A typical embedded-analytics deal package from GoodData in 2026 contains:

1. Annual subscription fee - covers the platform, a baseline tenant count (workspaces), baseline data volume, and a baseline of named users.
2. Professional services package - almost always required for the first deployment. Typically scoped at $30K–$80K depending on semantic-layer (LDM + MAQL) complexity and integration depth.
3. Tenant / workspace overages - most quotes include a workspace cap. Crossing it triggers tier-up pricing or per-workspace overage.
4. AI / MCP tier upgrade - the 2026 MCP Server + decision intelligence capabilities are positioned as a higher-tier add-on rather than included in the base subscription.
5. Premium support - named technical-account-manager, sub-24-hour response SLAs add 15–30% to the subscription.
6. GoodData CN infra (if self-hosted) - Kubernetes cluster + persistent storage + your DevOps engineer time. Add $40K–$120K/year in ops cost depending on team scale.

GoodData.AI 2026: MCP Server + Agent Builder + A2A + Decision Intelligence

The April 2026 MCP Server launch + the April 30 GoodData.AI rebrand + the Agent Builder + A2A protocol additions together reset the pricing conversation. Five implications worth budgeting against.

1. The MCP Server (27 tools, beta) is positioned as an AI-tier capability

The MCP Server exposes 27 tools to MCP clients (Claude, ChatGPT, Cursor, custom agents) under the standard MCP protocol - clustered into seven categories: workspace + analytics model, metadata browsing, AI-powered search/chat, AFM execution, automations, datasources/modeling, plus three new Knowledge Tools (added since the 24-tool launch) that expose Knowledge Resource URIs like gdc-analytics-rules://maql for in-context LLM reasoning. In typical GoodData.AI quotes, MCP Server capability lives in higher-tier packages rather than the base subscription. Teams whose 2026 roadmap requires MCP support should expect a tier upgrade negotiation.

2. The Agent Builder (April 22, 2026) is a separately tiered multi-agent enterprise platform

Agent Builder is the layer above the MCP Server - a multi-agent orchestration platform with 5 configuration surfaces: agents, tools, knowledge resources, evaluations, and deployments. It's GoodData.AI's pitch for production-grade enterprise agent workflows (vs. ad-hoc Claude-Desktop-style MCP usage). The Agent Builder is its own tier conversation - distinct from "we have MCP enabled, you can plug Claude in." If your roadmap includes multi-agent workflows with eval pipelines and managed deployments, factor in Agent Builder as a separate line item.

3. A2A (Agent-to-Agent) protocol support (May 2026) opens the cross-vendor agent surface

GoodData.AI added support for the A2A standard in May 2026 - letting GoodData.AI agents call out to and be called by agents from other vendors that implement A2A. The pricing implication is small near-term (A2A is nascent), but strategically meaningful: A2A support means GoodData.AI is investing in an open multi-vendor agent surface, not a closed Salesforce-bundle-style stack.

4. Decision Intelligence framing changes the buyer profile

The April 30, 2026 GoodData.AI rebrand cements the brand positioning around "AI-native decision intelligence" rather than "embedded analytics." Pitched at enterprise data leaders and CIOs, not just SaaS PMs. This shifts the procurement model toward longer enterprise sales cycles and higher deal sizes - a SaaS team that wanted a quick OEM Embedded quote in 2024 will increasingly find themselves in a Decision Intelligence platform conversation in 2026.

5. Major enterprise wins anchor the proof points

The April 2026 announcement called out major enterprise customer wins. For SaaS teams evaluating GoodData.AI against developer-first alternatives, the enterprise-anchor pattern is a credibility signal - but also a procurement-cycle signal (enterprise wins typically come with enterprise-shaped contract terms, 60+ day procurement cycles, and security-review gating).

The Hidden Costs

Five hidden costs land hardest in the first 12 months.

1. Professional services + LDM modeling time

GoodData's strength is the LDM (Logical Data Model) + MAQL (Multi-Dimensional Analytical Query Language) semantic layer - one of the most mature in the embedded analytics category. The trade-off is that productionizing LDM requires real engineering investment. Most first deployments scope $30K–$80K of professional services from GoodData or a partner to model the semantic layer well.

2. MAQL learning curve

MAQL is GoodData's analytical query language - powerful but idiosyncratic. New teams typically lose 1–3 weeks of analyst onboarding time learning MAQL well enough to be productive. For teams comfortable with SQL-shaped metric definitions, vendors like DataBrain remove this learning curve.

3. AI / MCP tier upgrade

Per the 2026 product positioning, MCP Server + agentic capabilities are higher-tier. If MCP support is in your evaluation criteria from day one, factor in the tier upgrade as a budget line.

4. GoodData CN infrastructure (if self-hosted)

GoodData CN is excellent for regulated buyers and teams with strong Kubernetes capacity, but the infra footprint isn't zero - Kubernetes cluster, persistent storage, monitoring, backups, GoodData CN upgrades. Total realistic year-1 ops cost on top of license: $40K–$120K depending on team scale.

5. Workspace / tenant overage

Most GoodData quotes include a workspace cap (each customer-tenant typically maps to a workspace). Crossing the cap triggers tier-up pricing or per-workspace overage. SaaS teams scaling from 50 to 500 tenants frequently re-quote.

TCO at 10 / 100 / 1,000 Users (Year 1, Year 3)

Two caveats. First, GoodData is custom-quoted - figures below are directional benchmarks reconstructed from public customer reports. Second, "users" in a SaaS embedded context typically maps to workspaces (one per customer) and named users within workspaces - not seat-based.

Assumptions: US-only deployment, mid-range data volumes, Cloud tier (CN adds infra ops cost), standard support upgraded to premium at 100+ end-users. The 50-tenant row is where most SaaS companies reading this guide will land.

The relevant comparison number for that row, against developer-first embedded analytics platforms with transparent pricing: typically 50–70% of the GoodData year-1 TCO for the equivalent footprint, with multi-tenant + white-label included as defaults.

5 Best GoodData Alternatives in 2026

1. DataBrain - developer-first MCP-ready embedded analytics

DataBrain is purpose-built for SaaS teams embedding analytics in their own product. Multi-tenant + RLS + white-label as defaults, SDK for React / Angular / Vue / vanilla JS, MCP-compatible server in 2026, published per-tenant pricing.

• Best for: SaaS teams that want MCP-ready agentic plus developer-first SDK and published pricing.
• GoodData-vs-DataBrain on the axes that matter: both ship MCP servers; DataBrain wins on developer-experience, procurement velocity, pricing transparency. GoodData wins on semantic-layer (MAQL + LDM) maturity and enterprise brand positioning. See DataBrain vs GoodData.
• Pricing: Published per-tenant + per-deployment.

2. Cube - semantic-layer-first

Cube positions its semantic layer as the foundation for embedded analytics. Closest peer to GoodData on the semantic-layer architecture axis with transparent pricing.

• Best for: Teams with strong dimensional modeling who want semantic-layer-first plus published pricing.
• Where Cube wins vs GoodData: Pricing transparency; faster onboarding; modeled-as-code Cube definitions vs GoodData's LDM + MAQL.

3. Embeddable - component-driven embedded

Embeddable focuses on developer-friendly embedding with React / Vue components and transparent pricing.

• Best for: Product teams that want component-level embedding without GoodData's platform overhead.
• Where Embeddable wins vs GoodData: Component-first SDK; transparent pricing; faster ramp.

4. ThoughtSpot Embedded

ThoughtSpot leads search-first conversational analytics - Spotter and Sage as the agentic story.

• Best for: Teams whose end-users prefer conversational search-first AI vs GoodData's structured-dashboard + MCP-via-agent-clients model.
• Where ThoughtSpot wins vs GoodData: Conversational AI maturity (Spotter + Sage are end-user-facing); search-first end-user UX.
• Where GoodData still wins: MCP Server (ThoughtSpot has not announced); semantic-layer depth.

5. Sisense - broader BI platform with Compose AI

Sisense Compose SDK is the developer-facing track of Sisense; Fusion is the all-in-one platform; Compose AI + Notebook agent are the AI positioning. See Sisense pricing.

• Best for: Teams that want both internal-analyst BI (Fusion) and embedded developer toolkit (Compose SDK) plus broader visualization breadth.
• Where Sisense wins vs GoodData: Broader BI platform; Notebook agent for analyst workflows.
• Where GoodData still wins: MCP Server; cleaner semantic-layer architecture; vendor-neutral cloud.

Who GoodData Is For - and Who It's Not For

GoodData is a strong fit if

• AI-native enterprise embedded analytics with strong semantic-layer modeling is the primary requirement.
• You have meaningful budget ($80K+/year embedded) and procurement runway.
• Your buying organization values the "decision intelligence" framing and is comfortable with custom-quote procurement.
• MAQL + LDM modeling discipline fits your team's preferences.
• MCP Server support is in your near-term roadmap (and you can absorb the tier upgrade).

GoodData is the wrong tool if

• You're a Series A SaaS that needs to embed analytics in 6–12 weeks. The procurement cycle alone is often longer than that.
• Pricing transparency matters to your team's procurement model.
• Your buyer is a SaaS PM/engineer who wants component-SDK integration with published rates.
• You don't want to learn MAQL - your team prefers SQL-shaped metric definitions.

How GoodData.AI Compares on 2026 AI Capability

GoodData.AI's 2026 AI story now has five pillars: the MCP Server (27 tools, beta) with Knowledge Resources, the Agent Builder multi-agent platform with 5 config surfaces, A2A protocol support (May 2026), the GoodData.AI brand reframe around decision intelligence, and the existing MAQL + LDM semantic-layer-aware analytics workflows that the agents reason against.

How that compares to peers across the embedded-analytics MCP race as of May 2026:

• DataBrain ships an MCP-compatible server in the same Express app as the embedded analytics product, with the same auth / RLS / semantic layer the embedded dashboards use - no separate-process local server, no MAQL learning curve, published per-tenant pricing. The two vendors are the most aligned on MCP-protocol AI in the embedded analytics category; the differentiation is GoodData.AI's depth (Agent Builder + Knowledge Tools + A2A) vs DataBrain's simplicity (one product, one auth, one published rate).
• Tableau Next is now part of the broader Agentic Analytics Platform reframed at TC 2026 (May 6, 2026) - Tableau Agent GA in Cloud+ Edition, MCP Voice, Agent Actions, Tableau Semantics on Data 360, plus the open-source @tableau/mcp-server (~9.7K weekly npm downloads). Tableau Next now has standalone published per-user pricing at $40/user/month - see Tableau Embedded pricing.
• Sisense launched @sisense/mcp-server (v0.4.1, April 30, 2026) - among the early MCP Apps protocol implementations alongside the Compose AI tier and the Notebook agent. AI-tier-gated; MCP server is OSS / npm-free but inherits Sisense license permits.
• Power BI has the Microsoft Fabric Copilot stack plus remote + local Power BI MCP server previews - bundled with the Microsoft AI tier.
• Looker is now anchored on Conversational Analytics + Gemini-in-Looker integrated through Vertex AI, on the Google Cloud agentic stack.
• ThoughtSpot has Spotter + Sage (conversational AI) - search-first agentic positioning, distinct from MCP-server-protocol AI. Different shape of AI; no first-party MCP server announced in our latest dossier refresh.
• Metabase has the Metabot AI surface but no documented MCP server at last dossier snapshot.
• Amazon Quick Sight (rebranded from QuickSight) has Q + Generative BI but no MCP server announced.

The GoodData.AI-specific differentiation in mid-2026 is the Agent Builder + A2A + Knowledge Tools triad - depth on the multi-agent enterprise-platform axis that no other vendor in the embedded-analytics category has shipped yet. Whether that depth justifies the AI-tier upgrade is the central pricing-conversation question for buyers.

For a deeper evaluation across the AI dimension, best AI-first embedded analytics 2026 compares all the AI-first vendors on agentic, MCP, semantic-layer, and CLI axes.

What You're Actually Buying at the API Level

GoodData's published pricing page is custom-quote across the board, but the developer documentation makes the tier shape concrete. Here's what each line in a GoodData quote actually unlocks at the API + capability level.

GoodData Cloud subscription - managed SaaS + GoodData.UI React SDK + REST APIs

The Cloud subscription unlocks the full GoodData embed surface: the GoodData.UI React SDK (InsightView, Dashboard, programmatic chart primitives), Web Components (<gd-dashboard> / <gd-insight>), and the underlying /api/v1/entities/... REST APIs - all authenticated against the same Authorization: Bearer surface. From GoodData's embed-visualizations docs, the typical React mount looks like:

// from https://www.gooddata.com/docs/cloud/embed-visualizations/
import React from "react";
import { InsightView } from "@gooddata/sdk-ui-ext";

export function MyComponent() {
    return (
        <div style={{ height: 300 }}>
            <InsightView insight="<visualization_id>" showTitle="Demo Column Chart" />
        </div>
    );
}

The managed SaaS subscription is what removes the Kubernetes ops investment - GoodData operates the infrastructure; you consume the API surface and pay per workspace.

GoodData CN (self-hosted) - containerized Kubernetes-operated, you own the ops cost

GoodData CN (Cloud Native) is the same product surface packaged as a containerized self-hosted distribution that runs on Kubernetes. Per the GoodData embed documentation, GoodData CN shares the same Authorization: Bearer API surface as Cloud and is internally referenced as "Tiger" in the SDK. You own the Kubernetes cluster, persistent storage, monitoring, backups, and CN version upgrades. The license is typically lower per unit; the realistic year-1 ops cost on top is $40K–$120K depending on team scale.

Semantic-layer modeling (MAQL + LDM) - the hidden DSL learning curve

The semantic layer is two paired pieces: LDM (Logical Data Model) for datasets, attributes, facts, and directional relationships, and MAQL (Multi-Dimensional Analytical Query Language) for defining metrics. MAQL is not SQL - it uses SELECT … BY … to set granularity floors and references attributes/metrics via {type/id} tokens. From GoodData's MAQL docs:

# from https://gooddata.com/docs/cloud/create-metrics/maql/filters/overriding-attribute-filters/by
SELECT {metric/Payment} BY {label/date.year}
SELECT {metric/Payment} / (SELECT {metric/Payment} BY {label/date.year})
SELECT {metric/Payment} BY {label/date.quarter}, {attribute/department}

MAQL is sticky for two reasons. First, every metric in the system is expressed in it - there is no escape hatch to raw SQL for metric logic. Second, User Data Filters (UDFs - GoodData's row-level-security primitive) are written in MAQL too, e.g. {label/CUSTOMER_COUNTRY} = "Canada" from GoodData's UDF docs, and ride the LDM's directional relationships to constrain every downstream fact table. New teams typically lose 1–3 weeks of analyst onboarding time learning MAQL well enough to be productive - the hidden cost embedded in every Cloud or CN tier.

MCP Server (27 tools, beta) + Agent Builder + A2A - the 2026 AI-tier stack

GoodData.AI's MCP Server launched publicly on January 21, 2026 and is currently documented as a beta feature exposing 27 tools (up from 24 at launch - three new Knowledge Tools added) to MCP clients (Claude, ChatGPT, Cursor, custom agents) under the standard MCP protocol. Tools cluster into seven categories - workspace + analytics model, metadata browsing, AI-powered search/chat, AFM execution, automations, datasources/modeling, plus the new Knowledge Tools cluster. Per the MCP Server documentation, tools are invoked with RSQL filters and include for related entities:

# from https://www.gooddata.ai/docs/cloud/ai/use-ai_assistant/mcp-server/
list_workspace_metrics(rsql_filter="id==revenue_total")
list_workspace_dashboards(rsql_filter="id==sales_dashboard", include=["visualizations"])
list_workspace_attributes(include=["labels", "datasets"])

The MCP Server also exposes Knowledge Resource URIs (gdc-analytics-rules://maql, gdc-analytics-rules://ldm-schema, etc.) so the LLM has GoodData.AI's reference material in-context when reasoning - including, notably, a dedicated MAQL guide because even the agent has to be taught the dialect. MCP Server capability is positioned as a higher-tier add-on rather than included in the base subscription.

Agent Builder (April 22, 2026) layers on top - a multi-agent enterprise platform with five configuration surfaces (agents, tools, knowledge resources, evaluations, deployments). This is GoodData.AI's pitch for production-grade multi-agent workflows with managed deployments and eval pipelines, distinct from ad-hoc Claude-Desktop-style MCP usage. Agent Builder is its own tier conversation - separate from "MCP enabled."

A2A (Agent-to-Agent) protocol support (May 2026) lets GoodData.AI agents talk to and be called by agents from other vendors that implement A2A - strategically meaningful even if commercially nascent. If your 2026 evaluation criteria include MCP support, Agent Builder, or A2A, all three are tier-gated and should be factored into the budget as separate line items, not assumed-included.

FlexConnect (formerly FlexFun) + decision intelligence - custom Python data sources

FlexConnect extends the semantic layer with custom Python functions exposed as data sources via Apache Arrow Flight RPC. A FlexConnect function implements FlexConnectFunction, declares an Arrow Schema, and is then registered as a dataset in the LDM and queryable like any other table. From the GoodData FlexConnect template:

# from https://github.com/gooddata/gooddata-flexconnect-template/blob/master/src/flexconnect/sample_function.py
import pyarrow
from gooddata_flexconnect import ExecutionContext, FlexConnectFunction

class SampleFlexConnectFunction(FlexConnectFunction):
    Name = "SampleFlexConnectFunction"
    Schema = pyarrow.schema([
        pyarrow.field("attribute1", pyarrow.string()),
        pyarrow.field("fact1", pyarrow.float64()),
    ])

    def call(self, parameters, columns, headers):
        execution_context = ExecutionContext.from_parameters(parameters)
        return self._StaticData

Together with the AI-Driven BI Modernization launch and the Context Management layer called out in the April 2026 announcement, this is the "decision intelligence" tier - pitched at enterprise data leaders, not just SaaS PMs, and contractually shaped that way.

How this maps to DataBrain (multi-tenant + MCP + published pricing as defaults)

DataBrain ships each of these capabilities as a default in the same deployment, at one published per-tenant rate, rather than as tier-gated upgrades:

• One embed surface, no Cloud-vs-CN SKU decision. The same React component is wrapped into a Shadow-DOM Web Component for non-React hosts via @r2wc/react-to-web-component - Angular, Vue, vanilla, Webflow, server-rendered Rails all drop in the same <dbn-dashboard> element:

frontend-mono/packages/@databrainhq/plugin/src/webcomponents.ts (lines 22–60)

const DbnDashboard = r2wc(Dashboard, {
  props: {
    token: 'string',
    dashboardId: 'string',
    options: 'json',
    theme: 'json',
    ...
  },
  shadow: 'open',
});
if (!customElements.get('dbn-dashboard'))
  customElements.define('dbn-dashboard', DbnDashboard);

• No MAQL learning curve and no MAQL-shaped RLS rules. Row-level security is enforced at the query layer via a deploy-time companyTenancyLevel on the data source; the host SaaS issues opaque per-session guest tokens (revocable from the server with a single row update), not MAQL expressions bound to GoodData userIds:

backend/serverless/express/src/externalApis/guestToken.ts (lines 237–272)

export const getToken = async ({
  clientId,
  companyId,
  expire,
  params,
}: {
  clientId: string;
  companyId: string;
  params: Record<string, any>;
  expire: string | null;
}) => {
  try {
    const { insert_guestTokens_one: data } = await client(MUTATION)({
      insert_guestTokens_one: [
        {
          object: {
            clientId,
            companyId,
            params: JSON.stringify(params),
            expire,
          },
        },

• MCP is a default control plane, not a higher-tier upgrade. DataBrain's MCP server is mounted in the same Express app as the rest of the product, with the same service-token auth, rate limiter, and RBAC plumbing - Claude / ChatGPT / custom-agent queries inherit the same tenant scoping the embedded dashboards inherit, by construction:

backend/serverless/express/src/index.ts (lines 147–155)

app.use(
  '/api/mcp',
  isPrivateApp([]),
  MCPRateLimiter,
  resolveOperatorEmail,
  MCPRouter,
);

• Semantic layer is declarative JSON, not a Turing-complete DSL. DataBrain's semantic layer is schema-shape JSON with descriptions, synonyms, and column-type hints - shaped explicitly so the LLM and agentic layer have grounding to reason against without a dedicated MAQL reference resource:

backend/serverless/express/src/externalApis/semanticLayer.ts (lines 40–58)

interface SemanticLayerTable {
  name: string;
  schemaName?: string;
  description?: string;
  synonyms?: string[];
  miscellaneousInfo?: string;
  columns?: SemanticLayerColumn[];
}

interface SemanticLayerColumn {
  name: string;
  description?: string;
  synonyms?: string[];
  miscellaneousInfo?: string;
  columnType?: string;
  columnTypeConfig?: any;
  isIdentifier?: boolean;
  isNotIndexed?: boolean;
}

Net: where GoodData splits the pricing conversation across Cloud vs CN, MAQL fluency, and a higher-tier MCP upgrade, DataBrain folds the equivalent capability into one published per-tenant rate with multi-tenant + white-label + MCP as defaults.

Where to Go Next

If you're still in evaluation and want to see what a published-price, MCP-ready alternative looks like end-to-end, the DataBrain vs GoodData head-to-head walks through MCP, agentic, multi-tenancy, and pricing. For broader market context, the GoodData alternatives shortlist compares GoodData against the full set of 7 AI-native alternatives.

For a strategic AI-first look at the embedded analytics market in 2026, the 2026 AI-first vendor buyer's guide is the companion to this pricing-focused page.

Builder reader (SaaS PM / engineer)

If your job is to ship customer-facing analytics inside your SaaS product in the next quarter, GoodData's procurement-cycle math typically rules it out - not because the platform can't do the job, but because the negotiation timeline alone is longer than your shipping window.

→ See how DataBrain embeds analytics in your product - multi-tenant, white-label, MCP-ready, with published pricing.

Analyst reader (BI / data team buyer)

If you're shortlisting AI-native embedded analytics platforms for a mixed internal-BI-plus-embedded use case and you have the procurement runway, GoodData is a credible candidate. The negotiation playbook in this article - services minimum, MAQL learning, AI tier upgrade, workspace overages, support gating - is the punch list to bring into your sales conversations.

→ Explore live sample dashboards to see what a published-price embedded experience looks like before your next vendor call.