ServicesAboutNotesContact Get in touch →
EN FR
Note

Looker Studio: Extract vs. Live Connection

When to use Looker Studio's extract mode versus live BigQuery connections, the 100 MB limit that catches teams off guard, and how to combine both in the same report.

Planted
bigqueryanalyticscost optimization

Looker Studio offers two connection modes for BigQuery: live connections (real-time queries on every interaction) and extract mode (a static snapshot queried locally). Most reports benefit from combining both.

Live Connections

A live connection queries BigQuery in real-time on every interaction. When a viewer opens the dashboard, Looker Studio fires one query per chart. When they change a date filter, all the charts reload with fresh queries. Data is always current.

The costs add up fast. A 10-chart dashboard opened by 30 team members every morning is 300 page loads, or 3,000 BigQuery queries before 9 AM. If a single chart query scans 10 GB, that’s 30,000 GB processed before lunch. At $6.25 per TB on on-demand pricing, you’re looking at real money for a dashboard people assumed was “free.”

Live connections are the right choice when:

  • Data freshness matters (operational monitoring, near-real-time reporting)
  • Users need to drill into detail with arbitrary filters
  • The underlying data is too large or varied for extract mode

Extract Mode

Extract mode creates a static snapshot stored in Google’s infrastructure. Looker Studio runs one query to pull the data, stores it, and then all subsequent interactions query the stored extract rather than BigQuery. After the initial extraction, interactions are free and near-instant.

The economics flip completely. Instead of paying for every user interaction, you pay once per refresh cycle. A report refreshed daily incurs one BigQuery query per day regardless of how many people view it or how many filter combinations they explore.

The constraints are strict:

  • 100 MB hard limit per extract. If your query returns more than 100 MB of data, the extraction fails. There’s no partial extraction or automatic truncation.
  • Refresh schedules are daily, weekly, or monthly. No hourly option. If your data changes more frequently than daily and viewers need current data, extract mode isn’t appropriate.
  • Only preselected dimensions and metrics are available. Users can’t add new fields or explore beyond what was included in the extract. This is often acceptable for fixed KPI dashboards, but it breaks exploratory use cases.

The 100 MB Limit in Practice

The 100 MB limit is smaller than it sounds when you’re extracting dimensional data. A table with 50 columns and 200,000 rows of mixed data types can easily exceed it. The workaround is to pre-aggregate before extracting: instead of pulling row-level data, pull a daily summary that fits comfortably within the limit.

This is another reason why pre-aggregated tables are the right foundation for dashboard data regardless of connection mode. With a properly pre-aggregated source, even a year of daily data by 5-10 dimensions typically fits well under 100 MB.

If your pre-aggregated data genuinely exceeds 100 MB and you still want extract-like economics, consider configuring aggressive caching on your live connection instead. A 12-hour cache on a dashboard that refreshes every morning gives you similar cost characteristics to an extract without the size constraint.

Combining Both in the Same Report

The practical approach for most reports is to mix connection types:

Use extract mode for:

  • KPI scorecards showing last month’s performance
  • Trend charts that update once a day
  • Any chart where users don’t need to filter beyond a fixed set of dimensions

Use live connections for:

  • Tables where users drill into row-level detail
  • Any chart with complex filter interactions
  • Data that changes throughout the day

Looker Studio supports multiple data sources within a single report. A report can have some charts pointing to an extract and others pointing to a live BigQuery connection. The viewer doesn’t notice the difference — they see the same interface either way.

The tradeoff to be aware of: charts from different data sources can’t share filters automatically. A date range control on an extract chart won’t filter a live connection chart unless you explicitly set up the cross-filtering. Plan your report architecture accordingly.

Cost Implications

When using live connections, consider setting maximum bytes billed in the BigQuery connection configuration. Looker Studio applies it to every query, so a misconfigured explore that would scan a full multi-TB table fails with an error instead of generating a surprise bill.

The INFORMATION_SCHEMA.JOBS table lets you track Looker Studio’s contribution to your BigQuery spend specifically, since Looker Studio labels its queries with a requestor: looker_studio label. If you’re seeing unexpected costs, run:

SELECT
  user_email,
  COUNT(*) AS query_count,
  SUM(total_bytes_processed) / POW(1024, 4) AS total_tb_processed
FROM `region-us`.INFORMATION_SCHEMA.JOBS
WHERE creation_time > TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 7 DAY)
  AND (
    SELECT l.value
    FROM UNNEST(labels) l
    WHERE l.key = 'requestor'
  ) = 'looker_studio'
GROUP BY 1
ORDER BY total_tb_processed DESC;

This tells you which report owners (identified by their credential email) are driving the most BigQuery spend from Looker Studio. Usually one or two reports account for the majority of cost — and they’re almost always candidates for extract mode or pre-aggregation.