Conversational Analytics in Data Studio: build a BigQuery data agent for your GA4 data

To use Conversational Analytics in Data Studio with GA4 data, you build a data agent in BigQuery, not in Data Studio: get GA4 into BigQuery (the free GA4 Data Transfer is the easier start, the raw event export the alternative), point an agent at a clean table, teach it your metric definitions, cap what it can spend, then publish it to Data Studio, where anyone you share it with can ask it questions. You don’t need Data Studio Pro, but you do need a Google Cloud project with billing turned on.

Conversational Analytics is the one AI feature in Data Studio open to every user, but it’s really a BigQuery product with a Data Studio front door. The work, and the bill, sit in getting GA4 into a table an agent can read and teaching it what your marketing words mean. This post covers:

• what you need and what it costs, including the token billing that starts in January
• GA4 into BigQuery, two ways, and the table to give the agent
• building the agent and teaching it your GA4 definitions
• cost guardrails, sharing to Data Studio, and fixing “I can’t see the agent”
• checking its answers, its limits, privacy, and when an MCP route fits better

My evidence: Google’s Data Studio, BigQuery, Cloud Billing and GA4 docs as they read on 14 October 2026, plus Google’s forum and Stack Overflow. I haven’t built a data agent for this post (no billed BigQuery project to test with yet), so the BigQuery screens come from Google’s docs, every SQL block is marked untested, and screenshots follow once I’ve run it. (Data Studio was called Looker Studio until April 2026, so older guides say “Conversational Analytics in Looker Studio”; most show the legacy, Pro-only version that used Sheets.)

What you need before you start, and what it will cost

Google’s overview says the new experience is available to all Data Studio users and doesn’t need Gemini in Data Studio. Only its Code Interpreter still needs Pro with Gemini (what Pro does add). What you do need is on the BigQuery side:

Why not the free BigQuery sandbox? It has no billing account, and Google’s agent setup asks for billing to be enabled. It also lacks the Data Transfer Service, and its tables expire after 60 days (Google’s sandbox page).

Then the bill. There are three meters, plus storage:

Prices from Google’s BigQuery pricing, data agent pricing and GA4 export pages, checked 14 October 2026; USD list prices.

Google’s pages don’t fully agree. BigQuery’s conversational analytics page mentions only compute pricing, then links to the agent pricing page for the tokens. The data insights date is also in Google’s Knowledge Catalog FAQ, whose own note says the rollout “begins on November 2, 2027”, likely a typo. And Google doesn’t publish how many bytes or tokens a question uses, so there’s no honest per-question price.

Decide whose project pays, the agency’s or the client’s, before you link anything; it’s easier than moving an export later. If you’re still deciding whether BigQuery is worth it at all, extract vs cache vs BigQuery lays out when it is.

Step 1: Get GA4 into BigQuery: the GA4 transfer or the event export

There are two ways in, and they give the agent very different tables.

For everyday marketing questions, the transfer is the easier start: its tables speak GA4’s report language, include the default channel group, and backfill on day one. The export is the alternative for event-level questions or custom dimensions.

Set up the GA4 transfer

From Google’s GA4 transfer page. You need BigQuery Admin on the project and viewer access to the GA4 property:

1. Create a BigQuery dataset for the GA4 tables, in the region you want the agent to live in.
2. In the Cloud console, open BigQuery › Data transfers and click Create transfer.
3. For Source, choose Google Analytics 4, and enter your GA4 Property ID.
4. Optionally, list the tables you want in Table Filter and set a Refresh window (4 days by default, up to 30).
5. Pick your dataset as the destination, name the transfer, set the schedule, and save.
6. Run a backfill for the months you want the agent to know about.

Or link the raw event export

From Google’s export setup page. You need Editor on the GA4 property and Owner on the BigQuery project:

1. In GA4, go to Admin › Product links › BigQuery links and click Link.
2. Choose the project and the data location.
3. Pick the streams and any events to exclude, then Daily and/or Streaming.
4. Submit. Data starts arriving within 24 hours.

Google’s catch: the export needs a valid payment method, and data interrupted by a billing problem can’t be re-exported. Keep the GA4 connector you already use in Data Studio (connecting GA4 to Data Studio): it’s how you’ll check the agent later.

To practise SQL while you wait, query Google’s public GA4 sample dataset (bigquery-public-data.ga4_obfuscated_sample_ecommerce, November 2020 to January 2021) free in the sandbox. It’s obfuscated: SQL practice, not a stand-in for your data.

Step 2: Give the agent one clean table, not the raw events

Google’s own best practice is to clean your tables first and “join related tables in a view” rather than leave the joins to the agent. With the transfer, that’s mostly done: point the agent at ga4_TrafficAcquisition (channel, source/medium, campaign, sessions, engaged sessions, key events, revenue) and, if you need pages, ga4_LandingPage. Skip ahead to Step 3.

With the raw export, page and campaign details sit inside nested event_params, and sessions must be counted from ga_session_id: exactly where a model goes wrong. One flat daily view fixes it, and scans far less:

-- A flat GA4 view for your agent (raw export route).
-- Written from Google's docs, not tested here.
-- Replace my-project, analytics_123456789, reporting and the key-event names.
CREATE OR REPLACE VIEW `my-project.reporting.ga4_sessions_daily` AS
WITH ev AS (
  SELECT
    PARSE_DATE('%Y%m%d', event_date) AS event_day,
    CONCAT(user_pseudo_id, '.', CAST((SELECT value.int_value FROM UNNEST(event_params)
      WHERE key = 'ga_session_id') AS STRING)) AS session_key,
    event_name,
    event_timestamp,
    (SELECT value.string_value FROM UNNEST(event_params) WHERE key = 'page_location') AS page_location,
    -- session_engaged isn't on Google's schema page; check how your property sends it.
    (SELECT COALESCE(value.string_value, CAST(value.int_value AS STRING))
       FROM UNNEST(event_params) WHERE key = 'session_engaged') AS session_engaged,
    session_traffic_source_last_click.cross_channel_campaign.source AS source,
    session_traffic_source_last_click.cross_channel_campaign.medium AS medium,
    session_traffic_source_last_click.cross_channel_campaign.campaign_name AS campaign,
    device.category AS device,
    geo.country AS country,
    ecommerce.purchase_revenue AS revenue
  FROM `my-project.analytics_123456789.events_*`
  WHERE _TABLE_SUFFIX NOT LIKE 'intraday%'   -- stable daily tables only
    AND _TABLE_SUFFIX >= FORMAT_DATE('%Y%m%d', DATE_SUB(CURRENT_DATE(), INTERVAL 13 MONTH))
),
sessions AS (
  SELECT
    session_key,
    MIN(event_day) AS date,
    ANY_VALUE(source) AS source,
    ANY_VALUE(medium) AS medium,
    ANY_VALUE(campaign) AS campaign,
    ANY_VALUE(device) AS device,
    ANY_VALUE(country) AS country,
    ARRAY_AGG(page_location IGNORE NULLS ORDER BY event_timestamp LIMIT 1)[SAFE_OFFSET(0)] AS landing_page,
    MAX(IF(session_engaged = '1', 1, 0)) AS engaged,
    COUNTIF(event_name IN ('purchase', 'generate_lead')) AS key_events,  -- your key events
    SUM(IFNULL(revenue, 0)) AS revenue
  FROM ev
  WHERE session_key IS NOT NULL
  GROUP BY session_key
)
SELECT
  date, source, medium, campaign,
  -- An approximation of GA4's default channel group, not Google's definition.
  CASE
    WHEN source = '(direct)' AND medium IN ('(none)', '(not set)') THEN 'Direct'
    WHEN REGEXP_CONTAINS(medium, r'^(cpc|ppc|paid)') AND REGEXP_CONTAINS(source,
         r'facebook|instagram|linkedin|tiktok|pinterest|reddit') THEN 'Paid Social'
    WHEN REGEXP_CONTAINS(medium, r'^(cpc|ppc|paid)') THEN 'Paid Search'
    WHEN medium = 'social' OR REGEXP_CONTAINS(source,
         r'facebook|instagram|linkedin|tiktok|pinterest|reddit') THEN 'Organic Social'
    WHEN medium = 'organic' THEN 'Organic Search'
    WHEN medium = 'email' THEN 'Email'
    WHEN medium = 'referral' THEN 'Referral'
    ELSE 'Other'
  END AS channel,
  landing_page, device, country,
  COUNT(*) AS sessions,
  SUM(engaged) AS engaged_sessions,
  SUM(key_events) AS key_events,
  SUM(revenue) AS revenue
FROM sessions
GROUP BY date, source, medium, campaign, channel, landing_page, device, country;

Three deliberate choices: daily tables only, because Google calls them the stable dataset; a rolling 13 months, so no question scans your whole history; and a channel grouping labelled as an approximation (for GA4’s own, use the transfer). Check that your property sends session_engaged, and swap in your own key events. (Another BigQuery view: row-level security in BigQuery.)

Step 3: Create the data agent in BigQuery

From Google’s create data agents page:

1. Look at the sample first: every project has a read-only one under “Sample agents by Google”.
2. In BigQuery, open Agents › Agent catalog and click New agent.
3. Name and description. Write the description for the people who’ll chat with it; they see it in Data Studio’s list.
4. Knowledge sources › Add source. Add the one table or view from Step 2.
5. Customise. Accept, fix or reject Gemini’s suggested field descriptions; they don’t change your table.
6. Check the location. Agents live in the US, the EU or Global, default to your sources’ region, and can’t move after saving.

Test in the preview pane, then Save as a draft until Step 5 is done.

Step 4: Teach it your marketing definitions

This step makes “sessions from paid social last month” match your report. Google ranks the context you add in this order: verified queries first, then the glossary, then instructions, with table and column descriptions underneath.

A verified query (formerly “golden query”) is SQL you’ve checked: when one answers the question, the agent runs it exactly as written. The glossary holds terms and synonyms; instructions change behaviour.

Make your five monthly numbers verified queries, and parameterise them. Google supports @name placeholders, so one query answers “last month”, “Q3” and “September” alike. Against the transfer table, the first one looks like this:

-- Verified query: "What were sessions and key events by channel between two dates?"
-- Parameters: @start_date (DATE), @end_date (DATE).
-- Written from Google's docs, not tested here. Google's table reference doesn't list the
-- date column: open the table's Schema tab and use the name you see there.
SELECT
  sessionDefaultChannelGroup AS channel,
  SUM(sessions) AS sessions,
  SUM(keyEvents) AS key_events
FROM `my-project.ga4_transfer.ga4_TrafficAcquisition`
WHERE date BETWEEN @start_date AND @end_date
GROUP BY channel
ORDER BY sessions DESC;

In the editor, that’s Add query, type the question, Generate SQL, replace it with yours, Run, Add. Don’t define the same term in the agent’s glossary and in a Knowledge Catalog business glossary: Google says to pick one.

The kit has it all ready to paste: instructions, about 25 glossary terms and eight verified queries for both table types. (Data Studio’s own calculated fields are where the same metrics get defined on the report side. )

Step 5: Set the cost guardrails before anyone asks a question

Each question becomes a BigQuery job billed by the bytes it scans. Set three limits, then watch.

1. Maximum bytes billed on the agent. In the agent’s settings, set it to at least 10,485,760 bytes (10 MiB, the minimum). Over the cap, the query fails before it runs, without charge (per the API docs). Left blank, it falls back to the project’s daily quota.
2. Daily quotas. In IAM & Admin › Quotas, filter to the BigQuery API and set Query usage per day and Query usage per day per user. Google suggests a dedicated project for agents. Don’t rely on the default: one Google page says it’s unlimited, another says 200 TiB a day per project.
3. A budget alert on the billing account. Useful, but Google is plain that alert budgets “don’t cap usage or spending”.
4. Watch the jobs. Agent jobs carry the labels ca-bq-job and data-agent-id, so you can count what each agent ran and scanned:

-- Google's job-count query, extended to bytes per day and per agent.
-- Google's base query plus my additions; not tested here.
-- Needs bigquery.jobs.listAll. Use your region: region-us or region-eu.
SELECT
  DATE(creation_time) AS day,
  (SELECT value FROM UNNEST(labels) WHERE key = 'data-agent-id') AS agent_id,
  COUNT(*) AS jobs,
  ROUND(SUM(total_bytes_billed) / POW(1024, 3), 2) AS gib_billed
FROM `my-project`.`region-us`.INFORMATION_SCHEMA.JOBS
WHERE creation_time >= TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 30 DAY)
  AND EXISTS (SELECT 1 FROM UNNEST(labels) AS label
              WHERE label.key = 'ca-bq-job' AND label.value = 'true')
GROUP BY day, agent_id
ORDER BY day DESC, gib_billed DESC;

Beyond the free TiB, each GiB scanned costs about $0.0061 ($6.25 ÷ 1,024). On per-agent billing, Google’s docs disagree: BigQuery’s page says labels let you filter the billing report per agent; the API’s cost page says tracking individual agents by label “isn’t supported”. So count jobs and bytes with the query above, and don’t promise a client a per-agent invoice line. Token use shows in the agent’s Monitoring tab (Preview, off by default). For keeping BigQuery-backed reports cheap generally: extracting data in Data Studio.

Step 6: Publish it to Data Studio, share it, and fix “I can’t see the agent”

1. Publish the agent and choose Data Studio as the publishing option. Drafts can’t be shared.
2. Share › Add principal, role Data Agent User for people who’ll chat.
3. Give them a project-level role (BigQuery Studio User or Gemini for Google Cloud User), Data Studio Asset Viewer, and BigQuery read access to the data.
4. Tick Send email, or copy the agent’s link (catalog › ⋮ › Copy link › Data Studio).
5. In Data Studio, they open Conversational Analytics › Chat with your data, where shared agents appear automatically.

“I shared it and they can’t see it” came up in four threads I read (three on Google’s forum, one on Stack Overflow). Google’s setup page explains most of it (for report sharing itself, see sharing Data Studio reports):

Step 7: Ask questions you can check

Name the metric, the date range and the breakdown, one thing at a time. Follow-ups only use the active conversation.

Then check before a number leaves the building (a method; I haven’t run it yet):

1. Read the method. Open How was this calculated? The Code tab shows the BigQuery SQL it ran: table, filters, dates.
2. Rebuild one number in Data Studio for the same dates, with the GA4 connector or a BigQuery chart on the same table.
3. Log it in the kit’s test-questions tab: question, agent’s answer, report’s number, match.

Charts from a conversation can’t be added to a report; recreate the good ones (maps and heatmaps may misbehave).

What it answers well, and where GA4 data trips it up

Per Google’s known limitations, it answers what a single visualisation can.

The API caps a query at 500 GB processed and a project at 30 chat requests a minute. And Google warns it “can generate output that seems plausible but is factually incorrect”. For the “why”, see AI commentary for client reports. If an agent’s answer ends up in a client’s commentary, Chapter 24 of my ebook, Data Storytelling in Data Studio, covers the guardrails I use for AI-drafted commentary and how to say whether a claim is measured, inferred or assumed.

Privacy settings to check before client data goes in

Not legal advice, but Google’s documented defaults, one with a deadline:

• ☐ Prompt analytics is on by default (anonymised; Google says not used to train its foundation models). Opt out by form before 23 November 2026, or with the org-policy constraint constraints/gcp.disablePromptAnalytics after.
• ☐ The agent reads only what the asker can, can’t write, and uses only the sources you picked.
• ☐ Conversation history is private to each user.
• ☐ Retention: conversations are deleted after 180 days without activity.
• ☐ The client’s contract allows AI processing of their analytics data.

The agency side of this is in client data and AI assistants.

When an MCP route is the better choice

Data Studio has no MCP server, but GA4 does:

The setup for the MCP routes is in connecting GA4 to Claude or ChatGPT, and the connectors are weighed in marketing data MCP servers compared.

Templates that run on GA4 data in BigQuery

A report on the same BigQuery data is the best check on the agent:

Where to go next

• AI in Data Studio: what Gemini does, what’s free, and what to use instead
• Connect GA4 to Claude or ChatGPT, the no-BigQuery route
• Data Studio free vs Pro
• Connect GA4 to Data Studio, for checking the agent
• Extract data in Data Studio

Frequently asked questions

Do I need Data Studio Pro for Conversational Analytics?

No. The new experience is available to all Data Studio users. Only its Code Interpreter, for forecasts and advanced statistics, needs Pro with Gemini.

Can I use the free BigQuery sandbox?

No. Google’s agent setup asks for billing to be enabled, and the sandbox has no billing account.

How much does it cost?

BigQuery queries after the free 1 TiB a month ($6.25 per TiB, USD list), data insights tokens from 27 October 2026, and agent data tokens ($3 / $20 per million input / output) after the free trial ends on 31 December 2026. Google publishes no per-question figure.

Does it work with Google Sheets or GA4 directly?

Not in the current experience: only BigQuery data agents. Sheets was the legacy, Pro-only version.

Why can’t my client see the agent?

Usually a missing role, or the project isn’t in their recent Cloud projects. Have them open it once in the Cloud console.

Some links in this post are affiliate links: if you sign up through one, I may earn a commission at no extra cost to you. How I work with partners.