Connector, data source, report: the three layers
A connector is the piece of code that talks to a product's API or file store and returns rows and columns. Google maintains connectors for its own products — Google Analytics, Google Ads, Search Console, BigQuery, Sheets, YouTube Analytics and the rest of the Marketing Platform — and third parties publish connectors for everything else. The connector decides which fields exist, what their raw types are and which combinations of dimensions and metrics the underlying product will answer.
A data source sits on top of a connector. It holds the credentials used to fetch data, the chosen account or property, the schema as you have edited it (renamed fields, changed types, default aggregations, calculated fields) and the freshnessWhether a table, feed or report holds data as recent as it should; a freshness check fails when the latest date is older than the source's expected arrival. setting. A data source can be reusable, meaning it appears in your data sources list and can be attached to many reports, or embedded, meaning it was created inside one report and lives only there. Google documents both kinds, and the difference matters the moment you want to share or copy your work.
A report is the set of pages, charts and controls that query one or more data sources. Charts inherit the fields of their source; they can add chart-level calculated fields and filters, but they cannot change what the source returns. When a field is missing, check the connector first (does the product expose it?), then the source (has it been hidden or renamed?), then the chart (is it filtered out?). The Looker Studio hub places this inside the wider reporting stack; this page stays on the first two layers. When a question has so far been answered in a GA4 exploration, the comparison of GA4 explorations and Looker Studio explains when it is worth rebuilding as a report on these layers.
Native vs partner connectors
Looker Studio groups connectors into those built by Google and those built by partners. The distinction is not only about who wrote the code; it changes support, cost, field coverage and what happens when the connector stops working.
| Aspect | Google connectors | Partner connectors |
|---|---|---|
| Built and maintained by | A third-party company or an individual developer | |
| Cost | Included with Looker Studio (the product queried may bill separately, as BigQuery does) | A large share are paid subscriptions; some are free with limits |
| Coverage | Google products plus generic sources such as Sheets, file upload and SQL databases | Advertising platforms, CRMs, e-commerce stores, social networks, finance tools |
| Authentication | Your Google account's access to the product | Usually a separate login to the partner, which stores your platform tokens |
| Field names and types | Follow the product's own API | Chosen by the partner; two connectors for the same platform can differ |
| When it breaks | Google fixes it on its own schedule | Depends on the partner's support; a defunct partner means a dead report |
| Data handling | Stays inside Google's infrastructure | Passes through the partner's servers; read their privacy terms |
| Best use | Google-side data, warehouses, spreadsheets | Platforms with no Google connector, or pre-modelled marketing data |
Two practical points follow. First, when a partner connector exists for a platform that also offers a scheduled export, the export into Sheets or BigQuery usually outlives the connector. Second, partner connectors often pre-aggregate or rename metrics; a "conversions" field from one vendor may not be the count another vendor returns for the same platform, so the definitions you record in the metrics layer should name the connector as well as the metric.
Community connectors — the ones anyone can build with Apps Script — form a third category. They are the right tool for an internal API that nothing else reaches, and they carry the same support risk as a partner connector with no company behind it. Treat one as a project you own, not a product you bought.
Credentials, ownership and sharing
Every data source carries credentials, and Looker Studio offers two modes. With owner's credentials, data is fetched using the access of the person who set up the source; anyone who can view the report sees whatever that person can see. With viewer's credentials, each viewer must themselves have access to the underlying product, and the connector fetches data as them. The switch sits in the data source's settings and is documented in the help centre.
Owner's credentials are convenient and risky in equal measure. They let a marketing lead publish a Google Ads dashboard to a sales team that has no Ads access, which is usually the point. They also mean that a report shared too widely exposes the owner's view of the data to everyone with the link, and that the data stops flowing when the owner leaves and their account is suspended. Viewer's credentials avoid both problems at the cost of giving every viewer product access, which for an analytics property or an ad account is often not what the business wants.
Ownership is separate from credentials. The data source owner can edit its schema and change its credentials; they can share the source with others as viewers or editors, and ownership can be transferred. A reusable source shared with view-only rights lets colleagues build reports on it without altering fields, which is the right default for a governed KPIA metric tied directly to an objective. set. The sharing and embedding guide covers how source credentials interact with report access. The short version: report access controls who can open the charts, and source credentials control whose data fills them.
Editing fields and types at the source
The data source editor is where you shape fields before any chart sees them. For each field you can change the display name, the data type (number, text, date and the date-and-time variants, boolean, geographic, URL, currency), the default aggregation (sum, average, count, count distinct, minimum, maximum, or auto for fields the connector already aggregates) and whether the field is visible at all. Calculated fields and parameters are also created here; they are a subject of their own, covered in the calculated fields tutorial.
Type changes matter more than they look. A campaign ID stored as a number will be summed in tables and formatted with thousands separators; set it to text. A date that the connector returns as text cannot drive a date-range control until its type is set to date in a format Looker Studio recognises. A currency field typed as a plain number loses its symbol; a count typed as currency gains one it does not deserve. Geographic types unlock map charts only when the sub-type (country, region, city) matches the values. A UTMURL tags identifying traffic source. field such as sessionCampaignName is text whatever the connector claims, and the only sensible aggregation for it is count distinct.
Edits made at the source apply to every report built on it, which is the whole point of reusable sources: rename sessionDefaultChannelGroup to "Channel" once and every chart agrees. The report-level setting that allows field editing in reports lets editors override types inside a chart. It is useful for a quick fix and a reliable way to end up with two reports that disagree. For the fields behind a headline metric, make the change at the source and keep the report setting off.
One schema fix, four reports repaired
A B2B lead-generation team runs four reports on one reusable GA4Google's event-based analytics platform. data source. The "Leads" scorecard reads 1,284 for the quarter in the executive report and 2,061 in the campaign report, and nobody can explain the gap. The campaign report's editor had switched the conversions field to sum at chart level and added a filter on eventName that matched both generate_lead and form_start. The fix is made at the source: a calculated field named Leads counts only generate_lead, the raw conversions field is hidden, and field editing in reports is switched off. All four reports now show 1,284 leads for the quarter, and the 777 extra "leads" in the campaign report are understood to be form starts, which get their own scorecard labelled as such.
Freshness and quotas
Looker Studio caches query results so that opening a report does not hit the product afresh for every chart. How long cached data counts as fresh is set per data source; the options depend on the connector, and the help centre lists the defaults and the available ranges. A viewer who needs the newest numbers can use the refresh action, which bypasses the cache for that session. The performance and caching guide explains how cache, extracts and query counts interact; the point here is that freshness is a source setting, not a report setting, and two sources on the same page can refresh on different schedules.
Quotas are the other side of freshness. Connectors that use product APIs — Google Analytics and Google Ads above all — are bound by those APIs' documented request limits, and a busy report with many charts, many viewers and a short freshness window can exhaust them. When that happens, charts fail with a configuration or quota error instead of showing stale data. Spreadsheet sources have their own ceiling in rows and query time; warehouse sources bill per query rather than refusing it. Google does not publish one table of limits covering every connector, so read the help page for the connector you depend on and design as if the limit were lower than you would like. When a chart already shows an error or nothing at all, the diagnosis for a Looker Studio chart showing no data separates quota from credentials, changed fields and the other usual causes.
Partner connectors add a third constraint: the vendor's own sync schedule. Many partner sources copy the platform on a timetable and serve Looker Studio from that copy, so "fresh" in Looker Studio means fresh since the vendor last synced, which can be a different thing from fresh in the platform.
Direct vs warehouse sources
A direct source queries the product live through its connector. A warehouse source queries a copy of the data that you, or a scheduled export, loaded into BigQuery or another database. Both are legitimate; the right choice depends on the question, the audience and how much modelling the data needs before it can be trusted.
| If… | Choose | Because |
|---|---|---|
| One platform, standard metrics, a small team | Direct connector | Fastest to build, nothing to maintain |
| Several platforms whose metrics must sit side by side | Warehouse, with a modelled table | Blends across live connectors grow slow and fragile |
| Metrics need business logic (margins, lead quality, deduplication) | Warehouse | The logic lives in one query, not in every report's calculated fields |
| Analytics data is sampled or thresholded in the connector | Warehouse via the BigQuery export | The event-level export is unsampled; aggregation is yours to define |
| The report has many viewers or refreshes often | Warehouse or an extract | Avoids API quotas; table scans are predictable |
| History beyond the product's retention window matters | Warehouse | The product forgets; the export remembers |
| Nobody on the team writes SQL yet | Direct connector now, warehouse later | A warehouse without an owner goes stale |
| The data is a spreadsheet someone maintains by hand | Sheets connector with a locked header row | A warehouse adds ceremony without adding trust |
In practice most marketing teams start direct and move the handful of metrics that cause arguments into a warehouse table. The blending tutorial shows how far you can get combining direct sources before that move pays off, and the metrics layer guide describes what the modelled table should contain so that every report reads the same definition. The tutorial on moving a Looker Studio report onto a warehouse walks through that move for an existing report, from inventory to retiring the old sources.
When a report built on a GA4 source disagrees with the interface, the diagnosis page for Looker Studio not matching GA4 lines the two up like for like and names the cause.
Common mistakes
- Building on an embedded source by accident. The source cannot be reused, and copying the report copies the schema edits into a second, drifting version.
- Owner's credentials plus open link sharing. Everyone with the link sees the owner's data; check the pairing before publishing.
- Fixing field types in the chart. The fix lives in one chart; the next report repeats the bug.
- Treating a partner's "conversions" as the platform's. Vendors pre-aggregate and rename; record which connector a metric came from.
- Short freshness on a quota-bound connector. Every viewer's every chart becomes an API call, and the quota runs out at the worst moment.
- Blending many live sources when one warehouse table would do. Slow pages and fragile joins are a sign the modelling belongs upstream.
- Letting a leaver own the sources. Transfer ownership before the account is suspended, not after the dashboards go blank.
Once the sources are sound, the next questions are how to combine them, which the blending tutorial answers, and how to keep them fast, which the performance guide covers.
