This is an overview of the Core Reporting capabilities of the Google Analytics Data API v1.
Core Reporting functionality of the Data API v1 is comprised of methods that return a customized report of your Google Analytics event data.
The term Core Reporting is used to distinguish the general purpose reporting functionality of the Data API v1 from a specialized Realtime reporting feature of the API.
runReport is the preferred method for simple report queries, and is used in all examples throughout this guide. See advanced features for an overview of other Core Reporting methods.
Reports
Reports returned by the Data API v1 reporting methods are tables of event data for a Google Analytics 4 property. A report table is made up of dimensions and metrics specified in the report's API request, with report data returned in individual rows. Use Filters to only return rows matching a certain condition and Pagination to navigate through results.
The following is an example report table that shows one dimension (Country) and one metric (Active Users).
| Country | Active Users |
|---|---|
| Japan | 2541 |
| France | 12 |
Selecting a Reporting Entity
All methods of the Data API v1 require the Google Analytics 4 property identifier
to be specified inside a URL request path in the form of
properties/GA4_PROPERTY_ID, such as:
POST https://analyticsdata.googleapis.com/v1beta/properties/GA4_PROPERTY_ID:runReport
The resulting report will be generated based on the Google Analytics event data collected in the specified Google Analytics 4 property.
If you are using one of the Data API client libraries, there
is no need to manipulate the request URL path manually. Most API clients
provide a property parameter that expects a string in the form of
properties/GA4_PROPERTY_ID. See Quick start guide
for examples of using the client libraries.
Report Request
To use the Analytics Data API v1 to request data, you can construct a RunReportRequest object. We recommend starting with these request parameters:
- A valid entry in the dateRanges field.
- At least one valid entry in the dimensions field.
- At least one valid entry in the metrics field.
Here is a sample request with the recommended fields:
HTTP
POST https://analyticsdata.googleapis.com/v1beta/properties/GA4_PROPERTY_ID:runReport
{
"dateRanges": [{ "startDate": "2020-09-01", "endDate": "2020-09-15" }],
"dimensions": [{ "name": "country" }],
"metrics": [{ "name": "activeUsers" }]
}
Python
from google.analytics.data_v1beta import BetaAnalyticsDataClient
from google.analytics.data_v1beta.types import DateRange
from google.analytics.data_v1beta.types import Dimension
from google.analytics.data_v1beta.types import Metric
from google.analytics.data_v1beta.types import MetricType
from google.analytics.data_v1beta.types import RunReportRequest
def run_sample():
"""Runs the sample."""
# TODO(developer): Replace this variable with your Google Analytics 4
# property ID before running the sample.
property_id = "YOUR-GA4-PROPERTY-ID"
run_report(property_id)
def run_report(property_id="YOUR-GA4-PROPERTY-ID"):
"""Runs a report of active users grouped by country."""
client = BetaAnalyticsDataClient()
request = RunReportRequest(
property=f"properties/{property_id}",
dimensions=[Dimension(name="country")],
metrics=[Metric(name="activeUsers")],
date_ranges=[DateRange(start_date="2020-09-01", end_date="2020-09-15")],
)
response = client.run_report(request)
print_run_report_response(response)
def print_run_report_response(response):
"""Prints results of a runReport call."""
print(f"{response.row_count} rows received")
for dimensionHeader in response.dimension_headers:
print(f"Dimension header name: {dimensionHeader.name}")
for metricHeader in response.metric_headers:
metric_type = MetricType(metricHeader.type_).name
print(f"Metric header name: {metricHeader.name} ({metric_type})")
print("Report result:")
for row in response.rows:
for dimension_value in row.dimension_values:
print(dimension_value.value)
for metric_value in row.metric_values:
print(metric_value.value)
Report Response
The Report Response of the API request is primarily a header and rows. The header consists of DimensionHeaders and MetricHeaders which list the columns in the Report. Each row consists of DimensionValues and MetricValues for the columns in the report. The ordering of columns is consistent in the request, the header, and every row.
Here is a sample response for the sample request above:
{
"dimensionHeaders": [
{
"name": "country"
}
],
"metricHeaders": [
{
"name": "activeUsers",
"type": "TYPE_INTEGER"
}
],
"rows": [
{
"dimensionValues": [
{
"value": "Japan"
}
],
"metricValues": [
{
"value": "2541"
}
]
},
{
"dimensionValues": [
{
"value": "France"
}
],
"metricValues": [
{
"value": "12"
}
]
}
],
"metadata": {},
"rowCount": 2
}
Dimensions
Dimensions describe and group event data for your
website or app. The city dimension, for example, indicates the city ("Paris"
or "New York") from which each event originated. In a report request, you can
specify zero or more dimensions. Requests are allowed up to 9 dimensions.
See the API Dimensions
for a full list of API Dimension names available to be specified in requests.
For example, this request groups Active Users in three dimension columns:
HTTP
POST https://analyticsdata.googleapis.com/v1beta/properties/GA4_PROPERTY_ID:runReport
{
"dateRanges": [{ "startDate": "7daysAgo", "endDate": "yesterday" }],
"dimensions": [
{
"name": "country"
},
{
"name": "region"
},
{
"name": "city"
}
],
"metrics": [{ "name": "activeUsers" }]
}
Python
from google.analytics.data_v1beta import BetaAnalyticsDataClient
from google.analytics.data_v1beta.types import DateRange
from google.analytics.data_v1beta.types import Dimension
from google.analytics.data_v1beta.types import Metric
from google.analytics.data_v1beta.types import RunReportRequest
from run_report import print_run_report_response
def run_sample():
"""Runs the sample."""
# TODO(developer): Replace this variable with your Google Analytics 4
# property ID before running the sample.
property_id = "YOUR-GA4-PROPERTY-ID"
run_report_with_multiple_dimensions(property_id)
def run_report_with_multiple_dimensions(property_id="YOUR-GA4-PROPERTY-ID"):
"""Runs a report of active users grouped by three dimensions."""
client = BetaAnalyticsDataClient()
request = RunReportRequest(
property=f"properties/{property_id}",
dimensions=[
Dimension(name="country"),
Dimension(name="region"),
Dimension(name="city"),
],
metrics=[Metric(name="activeUsers")],
date_ranges=[DateRange(start_date="7daysAgo", end_date="today")],
)
response = client.run_report(request)
print_run_report_response(response)
As a sample, a row in the report response could contain the following. This row means there are 47 Active Users for your website or app for the date range with events from Cape Town, South Africa.
"rows": [
...
{
"dimensionValues": [
{
"value": "South Africa"
},
{
"value": "Western Cape"
},
{
"value": "Cape Town"
}
],
"metricValues": [
{
"value": "47"
}
]
},
...
],
Metrics
Metrics are quantitative measurements of event data for your website or app. In a report request, you can specify one or more metrics. See the API Metrics for a full list of API Metric names available to be specified in requests.
For example, this request will show the three metrics grouped by the dimension
date:
HTTP
POST https://analyticsdata.googleapis.com/v1beta/properties/GA4_PROPERTY_ID:runReport
{
"dateRanges": [{ "startDate": "7daysAgo", "endDate": "yesterday" }],
"dimensions": [{ "name": "date" }],
"metrics": [
{
"name": "activeUsers"
},
{
"name": "newUsers"
},
{
"name": "totalRevenue"
}
],
}
Python
from google.analytics.data_v1beta import BetaAnalyticsDataClient
from google.analytics.data_v1beta.types import DateRange
from google.analytics.data_v1beta.types import Dimension
from google.analytics.data_v1beta.types import Metric
from google.analytics.data_v1beta.types import RunReportRequest
from run_report import print_run_report_response
def run_sample():
"""Runs the sample."""
# TODO(developer): Replace this variable with your Google Analytics 4
# property ID before running the sample.
property_id = "YOUR-GA4-PROPERTY-ID"
run_report_with_multiple_metrics(property_id)
def run_report_with_multiple_metrics(property_id="YOUR-GA4-PROPERTY-ID"):
"""Runs a report of active users, new users and total revenue grouped by
date dimension."""
client = BetaAnalyticsDataClient()
# Runs a report of active users grouped by three dimensions.
request = RunReportRequest(
property=f"properties/{property_id}",
dimensions=[Dimension(name="date")],
metrics=[
Metric(name="activeUsers"),
Metric(name="newUsers"),
Metric(name="totalRevenue"),
],
date_ranges=[DateRange(start_date="7daysAgo", end_date="today")],
)
response = client.run_report(request)
print_run_report_response(response)
As a sample, a row in report response could contain the following. This row
means that for the date 20201025 (October 25, 2020), there are 1135 Active
Users, 512 New Users, and 73.0841 Total Revenue in your Analytics property's
currency.
"rows": [
...
{
"dimensionValues": [
{
"value": "20201025"
}
],
"metricValues": [
{
"value": "1135"
},
{
"value": "512"
},
{
"value": "73.0841"
}
]
},
...
],
Pagination
By default, the report response contains at most the first 10,000 rows of event
data. For reports with 10,000 to 100,000 rows, you can include "limit": 100000
in the RunReportRequest
to retrieve up to 100,000 rows.
For reports with more than 100,000 rows, it is necessary to send a sequence of requests paging through the rows. For example, this request is for the first 100,000 rows:
HTTP
POST https://analyticsdata.googleapis.com/v1beta/properties/GA4_PROPERTY_ID:runReport
{
...
"limit": 100000,
"offset": 0
}
Python
request = RunReportRequest(
property=f"properties/{property_id}",
date_ranges=[DateRange(start_date="365daysAgo", end_date="yesterday")],
dimensions=[
Dimension(name="firstUserSource"),
Dimension(name="firstUserMedium"),
Dimension(name="firstUserCampaignName"),
],
metrics=[
Metric(name="sessions"),
Metric(name="conversions"),
Metric(name="totalRevenue"),
],
limit=100000,
offset=0,
)
response = client.run_report(request)
The rowCount parameter in the report response is independent of the
pagination parameters limit and offset in the request. If the report
response for example contains "rowCount": 272345, three requests of 100,000
rows each will retrieve all the data.
This request is for the second 100,000 rows. All other parameters such as
dateRange, dimensions, and metrics should be the same as the first
request.
HTTP
POST https://analyticsdata.googleapis.com/v1beta/properties/GA4_PROPERTY_ID:runReport
{
...
"limit": 100000,
"offset": 100000
}
Python
request = RunReportRequest(
property=f"properties/{property_id}",
date_ranges=[DateRange(start_date="365daysAgo", end_date="yesterday")],
dimensions=[
Dimension(name="firstUserSource"),
Dimension(name="firstUserMedium"),
Dimension(name="firstUserCampaignName"),
],
metrics=[
Metric(name="sessions"),
Metric(name="conversions"),
Metric(name="totalRevenue"),
],
limit=100000,
offset=100000,
)
response = client.run_report(request)
Use offset values of 200000, 300000, etc to retrieve subsequent results in
this example. All other parameters such as dateRange, dimensions,
and metrics should be the same as the first request.
Dimension Filters
When submitting a report request, you can ask it to only return data for
specific dimension values. To filter dimensions, in the request body, specify a
FilterExpression in the dimensionFilter
field. For example, this request returns a time series report of eventCount
when eventName is first_open for each date :
HTTP
POST https://analyticsdata.googleapis.com/v1beta/properties/GA4_PROPERTY_ID:runReport
{
"dateRanges": [{ "startDate": "7daysAgo", "endDate": "yesterday" }],
"dimensions": [{ "name": "date" }],
"metrics": [{ "name": "eventCount" }],
"dimensionFilter": {
"filter": {
"fieldName": "eventName",
"stringFilter": {
"value": "first_open"
}
}
},
}
Python
from google.analytics.data_v1beta import BetaAnalyticsDataClient
from google.analytics.data_v1beta.types import DateRange
from google.analytics.data_v1beta.types import Dimension
from google.analytics.data_v1beta.types import Filter
from google.analytics.data_v1beta.types import FilterExpression
from google.analytics.data_v1beta.types import Metric
from google.analytics.data_v1beta.types import RunReportRequest
from run_report import print_run_report_response
def run_sample():
"""Runs the sample."""
# TODO(developer): Replace this variable with your Google Analytics 4
# property ID before running the sample.
property_id = "YOUR-GA4-PROPERTY-ID"
run_report_with_dimension_filter(property_id)
def run_report_with_dimension_filter(property_id="YOUR-GA4-PROPERTY-ID"):
"""Runs a report using a dimension filter. The call returns a time series
report of `eventCount` when `eventName` is `first_open` for each date.
This sample uses relative date range values. See https://developers.google.com/analytics/devguides/reporting/data/v1/rest/v1beta/DateRange
for more information.
"""
client = BetaAnalyticsDataClient()
request = RunReportRequest(
property=f"properties/{property_id}",
dimensions=[Dimension(name="date")],
metrics=[Metric(name="eventCount")],
date_ranges=[DateRange(start_date="7daysAgo", end_date="yesterday")],
dimension_filter=FilterExpression(
filter=Filter(
field_name="eventName",
string_filter=Filter.StringFilter(value="first_open"),
)
),
)
response = client.run_report(request)
print_run_report_response(response)
The FilterExpression can specify filtering
criteria for many use cases. For example, an andGroup includes only data that
meets all criteria in the expressions list. This dimensionFilter selects for
when both browser is Chrome and countryId is US:
HTTP
...
"dimensionFilter": {
"andGroup": {
"expressions": [
{
"filter": {
"fieldName": "browser",
"stringFilter": {
"value": "Chrome"
}
}
},
{
"filter": {
"fieldName": "countryId",
"stringFilter": {
"value": "US"
}
}
}
]
}
},
...
Python
from google.analytics.data_v1beta import BetaAnalyticsDataClient
from google.analytics.data_v1beta.types import DateRange
from google.analytics.data_v1beta.types import Dimension
from google.analytics.data_v1beta.types import Filter
from google.analytics.data_v1beta.types import FilterExpression
from google.analytics.data_v1beta.types import FilterExpressionList
from google.analytics.data_v1beta.types import Metric
from google.analytics.data_v1beta.types import RunReportRequest
from run_report import print_run_report_response
def run_sample():
"""Runs the sample."""
# TODO(developer): Replace this variable with your Google Analytics 4
# property ID before running the sample.
property_id = "YOUR-GA4-PROPERTY-ID"
run_report_with_multiple_dimension_filters(property_id)
def run_report_with_multiple_dimension_filters(property_id="YOUR-GA4-PROPERTY-ID"):
"""Runs a report using multiple dimension filters joined as `and_group`
expression. The filter selects for when both `browser` is `Chrome` and
`countryId` is `US`.
This sample uses relative date range values. See https://developers.google.com/analytics/devguides/reporting/data/v1/rest/v1beta/DateRange
for more information.
"""
client = BetaAnalyticsDataClient()
request = RunReportRequest(
property=f"properties/{property_id}",
dimensions=[Dimension(name="browser")],
metrics=[Metric(name="activeUsers")],
date_ranges=[DateRange(start_date="7daysAgo", end_date="yesterday")],
dimension_filter=FilterExpression(
and_group=FilterExpressionList(
expressions=[
FilterExpression(
filter=Filter(
field_name="browser",
string_filter=Filter.StringFilter(value="Chrome"),
)
),
FilterExpression(
filter=Filter(
field_name="countryId",
string_filter=Filter.StringFilter(value="US"),
)
),
]
)
),
)
response = client.run_report(request)
print_run_report_response(response)
An orGroup includes data that meets any of the criteria in the expressions
list.
A notExpression excludes data that matches its inner expression. This
dimensionFilter selects for when pageTitle is not My Homepage. The report
will show event data for every pageTitle other than My Homepage:
HTTP
...
"dimensionFilter": {
"notExpression": {
"filter": {
"fieldName": "pageTitle",
"stringFilter": {
"value": "My Homepage"
}
}
}
},
...
Python
from google.analytics.data_v1beta import BetaAnalyticsDataClient
from google.analytics.data_v1beta.types import DateRange
from google.analytics.data_v1beta.types import Dimension
from google.analytics.data_v1beta.types import Filter
from google.analytics.data_v1beta.types import FilterExpression
from google.analytics.data_v1beta.types import Metric
from google.analytics.data_v1beta.types import RunReportRequest
from run_report import print_run_report_response
def run_sample():
"""Runs the sample."""
# TODO(developer): Replace this variable with your Google Analytics 4
# property ID before running the sample.
property_id = "YOUR-GA4-PROPERTY-ID"
run_report_with_dimension_exclude_filter(property_id)
def run_report_with_dimension_exclude_filter(property_id="YOUR-GA4-PROPERTY-ID"):
"""Runs a report using a filter with `not_expression`. The dimension filter
selects for when `pageTitle` is not `My Homepage`.
This sample uses relative date range values. See https://developers.google.com/analytics/devguides/reporting/data/v1/rest/v1beta/DateRange
for more information.
"""
client = BetaAnalyticsDataClient()
request = RunReportRequest(
property=f"properties/{property_id}",
dimensions=[Dimension(name="pageTitle")],
metrics=[Metric(name="sessions")],
date_ranges=[DateRange(start_date="7daysAgo", end_date="yesterday")],
dimension_filter=FilterExpression(
not_expression=FilterExpression(
filter=Filter(
field_name="pageTitle",
string_filter=Filter.StringFilter(value="My Homepage"),
)
)
),
)
response = client.run_report(request)
print_run_report_response(response)
An inListFilter matches data for any of the values in the list. This
dimensionFilter selects for event data where eventName is any of the three
purchase, in_app_purchase, and app_store_subscription_renew:
HTTP
...
"dimensionFilter": {
"filter": {
"fieldName": "eventName",
"inListFilter": {
"values": ["purchase",
"in_app_purchase",
"app_store_subscription_renew"]
}
}
},
...
Python
from google.analytics.data_v1beta import BetaAnalyticsDataClient
from google.analytics.data_v1beta.types import DateRange
from google.analytics.data_v1beta.types import Dimension
from google.analytics.data_v1beta.types import Filter
from google.analytics.data_v1beta.types import FilterExpression
from google.analytics.data_v1beta.types import Metric
from google.analytics.data_v1beta.types import RunReportRequest
from run_report import print_run_report_response
def run_sample():
"""Runs the sample."""
# TODO(developer): Replace this variable with your Google Analytics 4
# property ID before running the sample.
property_id = "YOUR-GA4-PROPERTY-ID"
run_report_with_dimension_in_list_filter(property_id)
def run_report_with_dimension_in_list_filter(property_id="YOUR-GA4-PROPERTY-ID"):
"""Runs a report using a dimension filter with `in_list_filter` expression.
The filter selects for when `eventName` is set to one of three event names
specified in the query.
This sample uses relative date range values. See https://developers.google.com/analytics/devguides/reporting/data/v1/rest/v1beta/DateRange
for more information.
"""
client = BetaAnalyticsDataClient()
request = RunReportRequest(
property=f"properties/{property_id}",
dimensions=[Dimension(name="eventName")],
metrics=[Metric(name="sessions")],
date_ranges=[DateRange(start_date="7daysAgo", end_date="yesterday")],
dimension_filter=FilterExpression(
filter=Filter(
field_name="eventName",
in_list_filter=Filter.InListFilter(
values=[
"purchase",
"in_app_purchase",
"app_store_subscription_renew",
]
),
)
),
)
response = client.run_report(request)
print_run_report_response(response)
Multiple Date Ranges
One report request can retrieve data for multiple dateRanges. For example, this report compares the first two weeks for August in 2019 and 2020:
HTTP
POST https://analyticsdata.googleapis.com/v1beta/properties/GA4_PROPERTY_ID:runReport
{
"dateRanges": [
{
"startDate": "2019-08-01",
"endDate": "2019-08-14"
},
{
"startDate": "2020-08-01",
"endDate": "2020-08-14"
}
],
"dimensions": [{ "name": "platform" }],
"metrics": [{ "name": "activeUsers" }]
}
Python
from google.analytics.data_v1beta import BetaAnalyticsDataClient
from google.analytics.data_v1beta.types import DateRange
from google.analytics.data_v1beta.types import Dimension
from google.analytics.data_v1beta.types import Metric
from google.analytics.data_v1beta.types import RunReportRequest
from run_report import print_run_report_response
def run_sample():
"""Runs the sample."""
# TODO(developer): Replace this variable with your Google Analytics 4
# property ID before running the sample.
property_id = "YOUR-GA4-PROPERTY-ID"
run_report_with_date_ranges(property_id)
def run_report_with_date_ranges(property_id="YOUR-GA4-PROPERTY-ID"):
"""Runs a report using two date ranges."""
client = BetaAnalyticsDataClient()
request = RunReportRequest(
property=f"properties/{property_id}",
date_ranges=[
DateRange(start_date="2019-08-01", end_date="2019-08-14"),
DateRange(start_date="2020-08-01", end_date="2020-08-14"),
],
dimensions=[Dimension(name="platform")],
metrics=[Metric(name="activeUsers")],
)
response = client.run_report(request)
print_run_report_response(response)
When multiple dateRanges are included in a request, a dateRange column is
automatically added to the report response. The following is an example
response. When the dateRange column is date_range_0, that row's data is for
the first date range. When the dateRange column is date_range_1, that row's
data is for the second date range.
{
"dimensionHeaders": [
{
"name": "platform"
},
{
"name": "dateRange"
}
],
"metricHeaders": [
{
"name": "activeUsers",
"type": "TYPE_INTEGER"
}
],
"rows": [
{
"dimensionValues": [
{
"value": "iOS"
},
{
"value": "date_range_0"
}
],
"metricValues": [
{
"value": "774"
}
]
},
{
"dimensionValues": [
{
"value": "Android"
},
{
"value": "date_range_1"
}
],
"metricValues": [
{
"value": "335"
}
]
},
...
],
}
Next step
Now that you have covered the basics of creating a report, take a look at the advanced features and realtime reporting guides for an overview of advanced reporting features of the Data API v1.