Approximate U.S. planning cost (indicative)

The link itself is low-friction, but raw export and query costs become meaningful with scale. Use this as a planning guide, not a fixed quote.

  • PoC phase: usually low spend if you stay within small query windows and free tiers.
  • Small-to-medium analytics: expect BigQuery storage and query usage to become your primary cost center.
  • Mature reporting: monitoring, scheduled queries, and transformed summary tables usually dominate recurring spend.

Cost breakdown

  • BigQuery ingestion and storage: daily event tables and retention policy.
  • BigQuery query processing: larger date ranges and joins cost more than schema design.
  • GA4 export overhead: operational cost of keeping daily and intraday outputs in sync.
  • Connector/dashboard tools: Looker Studio or other consumers, depending on refresh strategy.
  • Governance and controls: validation jobs, alerting, and access reviews.

Validation and rollback guidance

Validation flow:

  1. Confirm project and BigQuery dataset permissions before enabling the link.
  2. Verify at least one daily table appears after export window.
  3. Run a small events_* query for count and schema sanity.
  4. Compare one KPI with GA4 UI to confirm baseline alignment.
  5. Add budget alerts before exposing production reports.

Rollback guidance:

  • Keep exports in a dedicated dataset that can be detached from dashboards.
  • If costs spike, disable nonessential downstream scheduled queries first.
  • Preserve old SQL in version control so dashboard queries can be rolled back quickly.
  • Keep a temporary read-only reporting path so business monitoring continues during incident recovery.

Questions to ask

  • What retention is required and who owns archival policy?
  • Which BI users can afford delayed or transformed reporting?
  • What is the monthly cost target for scanned bytes?
  • Which metrics can tolerate intraday data, and which must use finalized daily tables?
  • Who approves schema updates and dataset-level access changes?

Red flags

  • Running broad SELECT * queries across long date ranges in production schedules.
  • Mixing intraday and daily tables without clear reporting grain.
  • Missing budget and job failure alerts for scheduled queries.
  • Not testing GA4-to-BQ row-level changes across property reconfiguration events.
  • Granting overly broad service-account roles to analysts and scripts.

The GA4 interface is useful for exploration, but BigQuery is better when you need durable raw event data and repeatable SQL.

BigQuery helps with:

  • Raw event analysis
  • Custom attribution models
  • Landing page reporting
  • Joining GA4 with CRM or revenue data
  • Long-term retention
  • Scheduled reporting queries
  • Looker Studio dashboards
  • Data quality auditing
  • Custom conversion analysis
  • Exporting data to internal tools

GA4 UI reports can be affected by interface limits, modeled reporting, thresholding, sampling-like behavior in explorations, or aggregation choices. BigQuery gives analysts a lower-level event export so they can define the logic themselves.

What you need before linking

Prepare:

  • A GA4 property
  • Editor or Administrator access in GA4
  • A Google Cloud project
  • BigQuery enabled in that project
  • Permission to create or select a BigQuery link
  • A region choice for the export dataset
  • A basic plan for cost control

The region matters. Choose it carefully because moving exported datasets later is not as simple as changing a setting.

For many sites, the BigQuery sandbox or free usage tier may be enough for early testing. Serious reporting should still use billing, budgets, and alerts so exports do not stop unexpectedly and query costs do not surprise the team.

Step 1: Create or choose a Google Cloud project

Open Google Cloud Console and create a project with a clear name:

client-ga4-bigquery
useful-atlas-analytics
site-name-raw-ga4

Enable BigQuery if it is not already available.

Then confirm:

  • You are in the correct project.
  • You have permission to use BigQuery.
  • Billing or sandbox status matches your plan.
  • The project belongs to the organization that should own the analytics data.

Do not link a business-critical GA4 property to a personal test project unless the data really belongs there.

In Google Analytics:

  1. Open Admin.
  2. Select the correct GA4 property.
  3. Open Product Links.
  4. Open BigQuery Links.
  5. Create a new link.
  6. Choose the Google Cloud project.
  7. Select the data location.
  8. Choose the data streams to export.
  9. Choose daily export, streaming export, or both.
  10. Review and submit.

After setup, BigQuery creates a dataset named similar to:

analytics_123456789

The number is the GA4 property ID.

Daily export vs streaming export

Daily export

Daily export writes completed daily tables after processing. These tables are the foundation for most stable reporting.

Use daily export for:

  • Core reporting
  • Historical analysis
  • Scheduled dashboards
  • Data warehouse joins
  • Lower-maintenance workflows

The daily table name looks like:

events_20260520

Streaming export

Streaming export writes intraday tables closer to real time. These tables are useful for fresh monitoring, but they are less stable than final daily tables.

Use streaming export for:

  • Near-real-time dashboards
  • Launch monitoring
  • QA after a release
  • Same-day alerting

The intraday table name looks like:

events_intraday_20260520

Intraday data can change, and the final daily table is the better source for official reporting.

Understand the GA4 BigQuery schema

GA4 exports event rows. Each row is one event.

Common top-level fields include:

  • event_date
  • event_timestamp
  • event_name
  • user_pseudo_id
  • user_id
  • platform
  • device
  • geo
  • traffic_source
  • event_params
  • user_properties
  • items

The field that surprises most people is:

event_params

It is a repeated record. That means one event can contain many key-value parameters.

Example event parameters:

  • page_location
  • page_title
  • page_referrer
  • ga_session_id
  • engagement_time_msec
  • Custom event parameters from GTM or your app

To read them, use UNNEST.

First SQL query: count events by day

Replace the project ID and property ID:

SELECT
  event_date,
  event_name,
  COUNT(*) AS event_count
FROM `your-project.analytics_123456789.events_*`
WHERE _TABLE_SUFFIX BETWEEN '20260501' AND '20260507'
GROUP BY event_date, event_name
ORDER BY event_date, event_count DESC;

This query scans only the tables in the selected suffix range.

Query page views with page URL

Use a scalar subquery to extract a parameter:

SELECT
  event_date,
  (SELECT value.string_value
   FROM UNNEST(event_params)
   WHERE key = 'page_location') AS page_location,
  COUNT(*) AS page_views
FROM `your-project.analytics_123456789.events_*`
WHERE _TABLE_SUFFIX BETWEEN '20260501' AND '20260507'
  AND event_name = 'page_view'
GROUP BY event_date, page_location
ORDER BY page_views DESC;

This is the basic pattern analysts use constantly in GA4 BigQuery work.

Query users and sessions

GA4 session logic can be nuanced, but a basic local query can start like this:

SELECT
  event_date,
  COUNT(DISTINCT user_pseudo_id) AS users,
  COUNT(DISTINCT CONCAT(
    user_pseudo_id,
    CAST((SELECT value.int_value
          FROM UNNEST(event_params)
          WHERE key = 'ga_session_id') AS STRING)
  )) AS sessions
FROM `your-project.analytics_123456789.events_*`
WHERE _TABLE_SUFFIX BETWEEN '20260501' AND '20260507'
GROUP BY event_date
ORDER BY event_date;

Use this as a working query pattern, not as a universal replacement for every GA4 UI metric. GA4 UI definitions and BigQuery SQL definitions can differ if filters, identity settings, consent, or modeling are involved.

Query a custom event parameter

Example custom event:

lead_submit

Parameter:

form_id

Query:

SELECT
  event_date,
  (SELECT value.string_value
   FROM UNNEST(event_params)
   WHERE key = 'form_id') AS form_id,
  COUNT(*) AS submissions
FROM `your-project.analytics_123456789.events_*`
WHERE _TABLE_SUFFIX BETWEEN '20260501' AND '20260531'
  AND event_name = 'lead_submit'
GROUP BY event_date, form_id
ORDER BY submissions DESC;

If the result is empty, check whether the parameter is actually sent by GTM or the site code.

Cost and safety controls

BigQuery is powerful because it scans large data quickly. That also means careless queries can scan more than intended.

Use these habits:

  • Select only needed columns.
  • Filter _TABLE_SUFFIX.
  • Avoid SELECT * in dashboards.
  • Start with a short date range.
  • Use scheduled queries carefully.
  • Use partitioned or summary tables for dashboards.
  • Set budgets and alerts in Google Cloud.
  • Monitor BigQuery job history.
  • Keep raw tables separate from modeled reporting tables.

For Looker Studio dashboards, consider summary tables when raw event queries become slow or expensive.

Troubleshooting

No tables appear

Check:

  • The link was created in the correct GA4 property.
  • The correct Google Cloud project was selected.
  • The selected data stream is receiving events.
  • Enough processing time has passed for daily export.
  • The dataset region is visible in BigQuery.

Daily export is not instant.

events_intraday exists but events_ does not

Streaming export may appear before the daily table is finalized. Use intraday for monitoring and daily tables for stable reporting.

Query returns no page_location

Check whether the event is a page_view and whether page_location exists in event_params:

SELECT
  key,
  COUNT(*) AS rows
FROM `your-project.analytics_123456789.events_*`,
UNNEST(event_params)
WHERE _TABLE_SUFFIX = '20260520'
GROUP BY key
ORDER BY rows DESC;

Query cost is too high

Reduce scanned data:

  • Narrow the _TABLE_SUFFIX.
  • Select fewer columns.
  • Avoid joining raw tables without filters.
  • Create daily summary tables.
  • Cache dashboard outputs where practical.

BigQuery numbers do not match GA4 UI exactly

Common reasons include:

  • Different date ranges or time zones
  • Different filters
  • Consent and privacy modeling
  • Identity settings
  • Late-arriving events
  • Intraday vs finalized data
  • SQL definition differs from GA4 UI definition

Treat BigQuery as the source for your custom logic, not a pixel-perfect clone of every GA4 interface card.

Bottom line

GA4 to BigQuery is one of the strongest upgrades for serious analytics work. The link gives you raw event data, flexible SQL, long-term storage, and cleaner joins with business data.

Set up the link from GA4 Admin, start with daily export, learn the event_params schema, and build small, tested SQL queries before powering dashboards from raw tables.

Sources