Esta guía explica cómo crear un informe básico para tus datos de Analytics usando la versión 1 de la API de datos de Google Analytics. Los informes de la API de datos v1 son similares a los informes que puedes generar en la sección Informes de Google Analytics. de usuario.
En esta guía, se abordan los informes principales, la función general de informes de la en la API de Cloud. La versión 1 de la API de datos también ofrece canalización de Informes de embudos y de embudos.
runReport es el método recomendado
para consultas y se usa en todos los ejemplos de esta guía. Ver avanzado
para obtener una descripción general de otros métodos básicos de generación de informes. Prueba la
Explorador de consultas para probar
para tus consultas.
Reports overview
Los informes son tablas de datos de eventos para un Propiedad de Google Analytics. Cada tabla de informe tiene las dimensiones y métricas solicitadas en tu consulta, con datos en filas individuales.
Usar filtros para mostrar solo las filas que coinciden con una condición determinada paginación para navegar por los resultados.
A continuación, se incluye una tabla de informe de ejemplo que muestra una dimensión (Country) y una métrica
(activeUsers):
| País | Usuarios activos |
|---|---|
| Japón | 2541 |
| Francia | 12 |
Especifica una fuente de datos
Cada solicitud de runReport requiere que especifiques una propiedad de Google Analytics
correcto. La propiedad de Analytics que especifiques se usará como conjunto de datos para
esa consulta. Por ejemplo:
POST https://analyticsdata.googleapis.com/v1beta/properties/GA_PROPERTY_ID:runReport
La respuesta de esta solicitud solo incluye datos de la propiedad de Analytics.
que especifiques como GA_PROPERTY_ID.
Si usas las bibliotecas cliente de la API de datos, especifica los datos
source en el parámetro property, en la forma de
properties/GA_PROPERTY_ID Consulta la
guía de inicio rápido para ver ejemplos de cómo usar la
bibliotecas cliente.
Consulte Cómo enviar eventos del Protocolo de medición a Google Analytics si incluir eventos del Protocolo de medición en tus informes.
Genera un informe
Para generar un informe, crea un
Objeto RunReportRequest.
Recomendamos comenzar con los siguientes parámetros:
- Una entrada válida en el campo
dateRanges. - Al menos una entrada válida en
dimensions. - Al menos una entrada válida en el campo
metrics
Esta es una solicitud de ejemplo con los campos recomendados:
HTTP
POST https://analyticsdata.googleapis.com/v1beta/properties/GA_PROPERTY_ID:runReport
{
"dateRanges": [{ "startDate": "2023-09-01"", "endDate": "2023-09-15" }],
"dimensions": [{ "name": "country" }],
"metrics": [{ "name": "activeUsers" }]
}
Java
import com.google.analytics.data.v1beta.BetaAnalyticsDataClient;
import com.google.analytics.data.v1beta.DateRange;
import com.google.analytics.data.v1beta.Dimension;
import com.google.analytics.data.v1beta.DimensionHeader;
import com.google.analytics.data.v1beta.Metric;
import com.google.analytics.data.v1beta.MetricHeader;
import com.google.analytics.data.v1beta.Row;
import com.google.analytics.data.v1beta.RunReportRequest;
import com.google.analytics.data.v1beta.RunReportResponse;
/**
* Google Analytics Data API sample application demonstrating the creation of a basic report.
*
* <p>See
* https://developers.google.com/analytics/devguides/reporting/data/v1/rest/v1beta/properties/runReport
* for more information.
*
* <p>Before you start the application, please review the comments starting with "TODO(developer)"
* and update the code to use correct values.
*
* <p>To run this sample using Maven:
*
* <pre>{@code
* cd google-analytics-data
* mvn compile exec:java -Dexec.mainClass="com.google.analytics.data.samples.RunReportSample"
* }</pre>
*/
public class RunReportSample {
public static void main(String... args) throws Exception {
/**
* TODO(developer): Replace this variable with your Google Analytics 4 property ID before
* running the sample.
*/
String propertyId = "YOUR-GA4-PROPERTY-ID";
sampleRunReport(propertyId);
}
// Runs a report of active users grouped by country.
static void sampleRunReport(String propertyId) throws Exception {
// Using a default constructor instructs the client to use the credentials
// specified in GOOGLE_APPLICATION_CREDENTIALS environment variable.
try (BetaAnalyticsDataClient analyticsData = BetaAnalyticsDataClient.create()) {
RunReportRequest request =
RunReportRequest.newBuilder()
.setProperty("properties/" + propertyId)
.addDimensions(Dimension.newBuilder().setName("country"))
.addMetrics(Metric.newBuilder().setName("activeUsers"))
.addDateRanges(
DateRange.newBuilder().setStartDate("2020-09-01").setEndDate("2020-09-15"))
.build();
// Make the request.
RunReportResponse response = analyticsData.runReport(request);
printRunResponseResponse(response);
}
}
// Prints results of a runReport call.
static void printRunResponseResponse(RunReportResponse response) {
System.out.printf("%s rows received%n", response.getRowsList().size());
for (DimensionHeader header : response.getDimensionHeadersList()) {
System.out.printf("Dimension header name: %s%n", header.getName());
}
for (MetricHeader header : response.getMetricHeadersList()) {
System.out.printf("Metric header name: %s (%s)%n", header.getName(), header.getType());
}
System.out.println("Report result:");
for (Row row : response.getRowsList()) {
System.out.printf(
"%s, %s%n", row.getDimensionValues(0).getValue(), row.getMetricValues(0).getValue());
}
}
}
PHP
use Google\Analytics\Data\V1beta\Client\BetaAnalyticsDataClient;
use Google\Analytics\Data\V1beta\DateRange;
use Google\Analytics\Data\V1beta\Dimension;
use Google\Analytics\Data\V1beta\Metric;
use Google\Analytics\Data\V1beta\MetricType;
use Google\Analytics\Data\V1beta\RunReportRequest;
use Google\Analytics\Data\V1beta\RunReportResponse;
/**
* @param string $propertyId Your GA-4 Property ID
*/
function run_report(string $propertyId)
{
// Create an instance of the Google Analytics Data API client library.
$client = new BetaAnalyticsDataClient();
// Make an API call.
$request = (new RunReportRequest())
->setProperty('properties/' . $propertyId)
->setDateRanges([
new DateRange([
'start_date' => '2020-09-01',
'end_date' => '2020-09-15',
]),
])
->setDimensions([
new Dimension([
'name' => 'country',
]),
])
->setMetrics([
new Metric([
'name' => 'activeUsers',
]),
]);
$response = $client->runReport($request);
printRunReportResponse($response);
}
/**
* Print results of a runReport call.
* @param RunReportResponse $response
*/
function printRunReportResponse(RunReportResponse $response)
{
printf('%s rows received%s', $response->getRowCount(), PHP_EOL);
foreach ($response->getDimensionHeaders() as $dimensionHeader) {
printf('Dimension header name: %s%s', $dimensionHeader->getName(), PHP_EOL);
}
foreach ($response->getMetricHeaders() as $metricHeader) {
printf(
'Metric header name: %s (%s)%s',
$metricHeader->getName(),
MetricType::name($metricHeader->getType()),
PHP_EOL
);
}
print 'Report result: ' . PHP_EOL;
foreach ($response->getRows() as $row) {
print $row->getDimensionValues()[0]->getValue()
. ' ' . $row->getMetricValues()[0]->getValue() . PHP_EOL;
}
}
Python
from google.analytics.data_v1beta import BetaAnalyticsDataClient
from google.analytics.data_v1beta.types import (
DateRange,
Dimension,
Metric,
MetricType,
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 rowIdx, row in enumerate(response.rows):
print(f"\nRow {rowIdx}")
for i, dimension_value in enumerate(row.dimension_values):
dimension_name = response.dimension_headers[i].name
print(f"{dimension_name}: {dimension_value.value}")
for i, metric_value in enumerate(row.metric_values):
metric_name = response.metric_headers[i].name
print(f"{metric_name}: {metric_value.value}")
Node.js
// TODO(developer): Uncomment this variable and replace with your
// Google Analytics 4 property ID before running the sample.
// propertyId = 'YOUR-GA4-PROPERTY-ID';
// Imports the Google Analytics Data API client library.
const {BetaAnalyticsDataClient} = require('@google-analytics/data');
// Initialize client that will be used to send requests. This client only
// needs to be created once, and can be reused for multiple requests.
const analyticsDataClient = new BetaAnalyticsDataClient();
// Runs a report of active users grouped by country.
async function runReport() {
const [response] = await analyticsDataClient.runReport({
property: `properties/${propertyId}`,
dimensions: [
{
name: 'country',
},
],
metrics: [
{
name: 'activeUsers',
},
],
dateRanges: [
{
startDate: '2020-09-01',
endDate: '2020-09-15',
},
],
});
printRunReportResponse(response);
}
// Prints results of a runReport call.
function printRunReportResponse(response) {
console.log(`${response.rowCount} rows received`);
response.dimensionHeaders.forEach(dimensionHeader => {
console.log(`Dimension header name: ${dimensionHeader.name}`);
});
response.metricHeaders.forEach(metricHeader => {
console.log(
`Metric header name: ${metricHeader.name} (${metricHeader.type})`
);
});
console.log('Report result:');
response.rows.forEach(row => {
console.log(
`${row.dimensionValues[0].value}, ${row.metricValues[0].value}`
);
});
}
runReport();
Consulta métricas
Metrics son las medidas cuantitativas de las
los datos de eventos de la empresa. Debes especificar al menos una métrica en tus solicitudes runReport.
Consulta Métricas de la API para obtener una lista completa de las métricas que puedes consultar.
Esta es una solicitud de ejemplo que muestra tres métricas, agrupadas por el
dimensión date:
HTTP
POST https://analyticsdata.googleapis.com/v1beta/properties/GA_PROPERTY_ID:runReport
{
"dateRanges": [{ "startDate": "7daysAgo", "endDate": "yesterday" }],
"dimensions": [{ "name": "date" }],
"metrics": [
{
"name": "activeUsers"
},
{
"name": "newUsers"
},
{
"name": "totalRevenue"
}
],
}
Java
import com.google.analytics.data.v1beta.BetaAnalyticsDataClient;
import com.google.analytics.data.v1beta.DateRange;
import com.google.analytics.data.v1beta.Dimension;
import com.google.analytics.data.v1beta.Metric;
import com.google.analytics.data.v1beta.RunReportRequest;
import com.google.analytics.data.v1beta.RunReportResponse;
/**
* Google Analytics Data API sample application demonstrating the creation of a basic report.
*
* <p>See
* https://developers.google.com/analytics/devguides/reporting/data/v1/rest/v1beta/properties/runReport
* for more information.
*
* <p>Before you start the application, please review the comments starting with "TODO(developer)"
* and update the code to use correct values.
*
* <p>To run this sample using Maven:
*
* <pre>{@code
* cd google-analytics-data
* mvn compile exec:java -Dexec.mainClass="com.google.analytics.data.samples.RunReportWithMultipleMetricsSample"
* }</pre>
*/
public class RunReportWithMultipleMetricsSample {
public static void main(String... args) throws Exception {
// TODO(developer): Replace with your Google Analytics 4 property ID before running the sample.
String propertyId = "YOUR-GA4-PROPERTY-ID";
sampleRunReportWithMultipleMetrics(propertyId);
}
// Runs a report of active users, new users and total revenue grouped by date dimension.
static void sampleRunReportWithMultipleMetrics(String propertyId) throws Exception {
// Initialize client that will be used to send requests. This client only needs to be created
// once, and can be reused for multiple requests. After completing all of your requests, call
// the "close" method on the client to safely clean up any remaining background resources.
try (BetaAnalyticsDataClient analyticsData = BetaAnalyticsDataClient.create()) {
RunReportRequest request =
RunReportRequest.newBuilder()
.setProperty("properties/" + propertyId)
.addDimensions(Dimension.newBuilder().setName("date"))
.addMetrics(Metric.newBuilder().setName("activeUsers"))
.addMetrics(Metric.newBuilder().setName("newUsers"))
.addMetrics(Metric.newBuilder().setName("totalRevenue"))
.addDateRanges(DateRange.newBuilder().setStartDate("7daysAgo").setEndDate("today"))
.build();
// Make the request.
RunReportResponse response = analyticsData.runReport(request);
// Prints the response using a method in RunReportSample.java
RunReportSample.printRunResponseResponse(response);
}
}
}
PHP
use Google\Analytics\Data\V1beta\Client\BetaAnalyticsDataClient;
use Google\Analytics\Data\V1beta\DateRange;
use Google\Analytics\Data\V1beta\Dimension;
use Google\Analytics\Data\V1beta\Metric;
use Google\Analytics\Data\V1beta\MetricType;
use Google\Analytics\Data\V1beta\RunReportRequest;
use Google\Analytics\Data\V1beta\RunReportResponse;
/**
* @param string $propertyID Your GA-4 Property ID
* Runs a report of active users grouped by three metrics.
*/
function run_report_with_multiple_metrics(string $propertyId)
{
// Create an instance of the Google Analytics Data API client library.
$client = new BetaAnalyticsDataClient();
// Make an API call.
$request = (new RunReportRequest())
->setProperty('properties/' . $propertyId)
->setDimensions([new Dimension(['name' => 'date'])])
->setMetrics([
new Metric(['name' => 'activeUsers']),
new Metric(['name' => 'newUsers']),
new Metric(['name' => 'totalRevenue'])
])
->setDateRanges([
new DateRange([
'start_date' => '7daysAgo',
'end_date' => 'today',
])
]);
$response = $client->runReport($request);
printRunReportResponseWithMultipleMetrics($response);
}
/**
* Print results of a runReport call.
* @param RunReportResponse $response
*/
function printRunReportResponseWithMultipleMetrics(RunReportResponse $response)
{
printf('%s rows received%s', $response->getRowCount(), PHP_EOL);
foreach ($response->getDimensionHeaders() as $dimensionHeader) {
printf('Dimension header name: %s%s', $dimensionHeader->getName(), PHP_EOL);
}
foreach ($response->getMetricHeaders() as $metricHeader) {
printf(
'Metric header name: %s (%s)' . PHP_EOL,
$metricHeader->getName(),
MetricType::name($metricHeader->getType())
);
}
print 'Report result: ' . PHP_EOL;
foreach ($response->getRows() as $row) {
printf(
'%s %s' . PHP_EOL,
$row->getDimensionValues()[0]->getValue(),
$row->getMetricValues()[0]->getValue()
);
}
}
Python
from google.analytics.data_v1beta import BetaAnalyticsDataClient
from google.analytics.data_v1beta.types import (
DateRange,
Dimension,
Metric,
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)
Node.js
// TODO(developer): Uncomment this variable and replace with your
// Google Analytics 4 property ID before running the sample.
// propertyId = 'YOUR-GA4-PROPERTY-ID';
// Imports the Google Analytics Data API client library.
const {BetaAnalyticsDataClient} = require('@google-analytics/data');
// Initialize client that will be used to send requests. This client only
// needs to be created once, and can be reused for multiple requests.
const analyticsDataClient = new BetaAnalyticsDataClient();
// Runs a report of active users grouped by three metrics.
async function runReportWithMultipleMetrics() {
const [response] = await analyticsDataClient.runReport({
property: `properties/${propertyId}`,
dimensions: [
{
name: 'date',
},
],
metrics: [
{
name: 'activeUsers',
},
{
name: 'newUsers',
},
{
name: 'totalRevenue',
},
],
dateRanges: [
{
startDate: '7daysAgo',
endDate: 'today',
},
],
});
printRunReportResponse(response);
}
runReportWithMultipleMetrics();
// Prints results of a runReport call.
function printRunReportResponse(response) {
console.log(`${response.rowCount} rows received`);
response.dimensionHeaders.forEach(dimensionHeader => {
console.log(`Dimension header name: ${dimensionHeader.name}`);
});
response.metricHeaders.forEach(metricHeader => {
console.log(
`Metric header name: ${metricHeader.name} (${metricHeader.type})`
);
});
console.log('Report result:');
response.rows.forEach(row => {
console.log(
`${row.dimensionValues[0].value}, ${row.metricValues[0].value}`
);
});
}
Esta es una respuesta de ejemplo que muestra 1, 135 usuarios activos, 512 usuarios nuevos y
73.0841 Ingresos totales en la moneda de tu propiedad de Analytics en la fecha
20231025 (25 de octubre de 2023).
"rows": [
...
{
"dimensionValues": [
{
"value": "20231025"
}
],
"metricValues": [
{
"value": "1135"
},
{
"value": "512"
},
{
"value": "73.0841"
}
]
},
...
],
Lee la respuesta
La respuesta de informe contiene un encabezado y
filas de datos. El encabezado consiste en
DimensionHeaders y
MetricHeaders, que enumera las columnas de la
. Cada fila consta de
DimensionValues y
MetricValues El orden de los
columnas sean coherentes en la solicitud, el encabezado y las filas.
A continuación, se muestra un ejemplo de respuesta para la solicitud de ejemplo anterior:
{
"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
}
Agrupa y filtra datos
Las dimensiones son atributos cualitativos que puedes utilizar
para agrupar y filtrar tus datos. Por ejemplo, la dimensión city indica la
ciudad, como Paris o New York, donde se originó cada evento. Las dimensiones son
opcional para las solicitudes runReport, y puedes usar hasta nueve dimensiones por
para cada solicitud.
Consulta las dimensiones de la API para obtener una lista completa de las dimensiones que puedes usar para agrupar y filtrar tus datos.
Grupo
A continuación, se incluye una solicitud de ejemplo que agrupa a los usuarios activos en tres dimensiones:
HTTP
POST https://analyticsdata.googleapis.com/v1beta/properties/GA_PROPERTY_ID:runReport
{
"dateRanges": [{ "startDate": "7daysAgo", "endDate": "yesterday" }],
"dimensions": [
{
"name": "country"
},
{
"name": "region"
},
{
"name": "city"
}
],
"metrics": [{ "name": "activeUsers" }]
}
```
Java
import com.google.analytics.data.v1beta.BetaAnalyticsDataClient;
import com.google.analytics.data.v1beta.DateRange;
import com.google.analytics.data.v1beta.Dimension;
import com.google.analytics.data.v1beta.Metric;
import com.google.analytics.data.v1beta.RunReportRequest;
import com.google.analytics.data.v1beta.RunReportResponse;
/**
* Google Analytics Data API sample application demonstrating the creation of a basic report.
*
* <p>See
* https://developers.google.com/analytics/devguides/reporting/data/v1/rest/v1beta/properties/runReport
* for more information.
*
* <p>Before you start the application, please review the comments starting with "TODO(developer)"
* and update the code to use correct values.
*
* <p>To run this sample using Maven:
*
* <pre>{@code
* cd google-analytics-data
* mvn compile exec:java -Dexec.mainClass="com.google.analytics.data.samples.RunReportWithMultipleDimensionsSample"
* }</pre>
*/
public class RunReportWithMultipleDimensionsSample {
public static void main(String... args) throws Exception {
// TODO(developer): Replace with your Google Analytics 4 property ID before running the sample.
String propertyId = "YOUR-GA4-PROPERTY-ID";
sampleRunReportWithMultipleDimensions(propertyId);
}
// Runs a report of active users grouped by three dimensions.
static void sampleRunReportWithMultipleDimensions(String propertyId) throws Exception {
// Initialize client that will be used to send requests. This client only needs to be created
// once, and can be reused for multiple requests. After completing all of your requests, call
// the "close" method on the client to safely clean up any remaining background resources.
try (BetaAnalyticsDataClient analyticsData = BetaAnalyticsDataClient.create()) {
RunReportRequest request =
RunReportRequest.newBuilder()
.setProperty("properties/" + propertyId)
.addDimensions(Dimension.newBuilder().setName("country"))
.addDimensions(Dimension.newBuilder().setName("region"))
.addDimensions(Dimension.newBuilder().setName("city"))
.addMetrics(Metric.newBuilder().setName("activeUsers"))
.addDateRanges(DateRange.newBuilder().setStartDate("7daysAgo").setEndDate("today"))
.build();
// Make the request.
RunReportResponse response = analyticsData.runReport(request);
// Prints the response using a method in RunReportSample.java
RunReportSample.printRunResponseResponse(response);
}
}
}
PHP
use Google\Analytics\Data\V1beta\Client\BetaAnalyticsDataClient;
use Google\Analytics\Data\V1beta\DateRange;
use Google\Analytics\Data\V1beta\Dimension;
use Google\Analytics\Data\V1beta\Metric;
use Google\Analytics\Data\V1beta\MetricType;
use Google\Analytics\Data\V1beta\RunReportRequest;
use Google\Analytics\Data\V1beta\RunReportResponse;
/**
* @param string $propertyID Your GA-4 Property ID
* Runs a report of active users grouped by three dimensions.
*/
function run_report_with_multiple_dimensions(string $propertyId)
{
// Create an instance of the Google Analytics Data API client library.
$client = new BetaAnalyticsDataClient();
// Make an API call.
$request = (new RunReportRequest())
->setProperty('properties/' . $propertyId)
->setDimensions([
new Dimension(['name' => 'country']),
new Dimension(['name' => 'region']),
new Dimension(['name' => 'city']),
])
->setMetrics([new Metric(['name' => 'activeUsers'])])
->setDateRanges([
new DateRange([
'start_date' => '7daysAgo',
'end_date' => 'today',
])
]);
$response = $client->runReport($request);
printRunReportResponseWithMultipleDimensions($response);
}
/**
* Print results of a runReport call.
* @param RunReportResponse $response
*/
function printRunReportResponseWithMultipleDimensions(RunReportResponse $response)
{
printf('%s rows received%s', $response->getRowCount(), PHP_EOL);
foreach ($response->getDimensionHeaders() as $dimensionHeader) {
printf('Dimension header name: %s%s', $dimensionHeader->getName(), PHP_EOL);
}
foreach ($response->getMetricHeaders() as $metricHeader) {
printf(
'Metric header name: %s (%s)' . PHP_EOL,
$metricHeader->getName(),
MetricType::name($metricHeader->getType())
);
}
print 'Report result: ' . PHP_EOL;
foreach ($response->getRows() as $row) {
printf(
'%s %s' . PHP_EOL,
$row->getDimensionValues()[0]->getValue(),
$row->getMetricValues()[0]->getValue()
);
}
}
Python
from google.analytics.data_v1beta import BetaAnalyticsDataClient
from google.analytics.data_v1beta.types import (
DateRange,
Dimension,
Metric,
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)
Node.js
// TODO(developer): Uncomment this variable and replace with your
// Google Analytics 4 property ID before running the sample.
// propertyId = 'YOUR-GA4-PROPERTY-ID';
// Imports the Google Analytics Data API client library.
const {BetaAnalyticsDataClient} = require('@google-analytics/data');
// Initialize client that will be used to send requests. This client only
// needs to be created once, and can be reused for multiple requests.
const analyticsDataClient = new BetaAnalyticsDataClient();
// Runs a report of active users grouped by three dimensions.
async function runReportWithMultipleDimensions() {
const [response] = await analyticsDataClient.runReport({
property: `properties/${propertyId}`,
dimensions: [
{
name: 'country',
},
{
name: 'region',
},
{
name: 'city',
},
],
metrics: [
{
name: 'activeUsers',
},
],
dateRanges: [
{
startDate: '7daysAgo',
endDate: 'today',
},
],
});
printRunReportResponse(response);
}
runReportWithMultipleDimensions();
// Prints results of a runReport call.
function printRunReportResponse(response) {
console.log(`${response.rowCount} rows received`);
response.dimensionHeaders.forEach(dimensionHeader => {
console.log(`Dimension header name: ${dimensionHeader.name}`);
});
response.metricHeaders.forEach(metricHeader => {
console.log(
`Metric header name: ${metricHeader.name} (${metricHeader.type})`
);
});
console.log('Report result:');
response.rows.forEach(row => {
console.log(
`${row.dimensionValues[0].value}, ${row.metricValues[0].value}`
);
});
}
A continuación, se incluye una fila de informe de muestra de la solicitud anterior. Esta fila muestra que hay fueron 47 usuarios activos durante el período especificado con eventos de Ciudad del Cabo, Sudáfrica.
"rows": [
...
{
"dimensionValues": [
{
"value": "South Africa"
},
{
"value": "Western Cape"
},
{
"value": "Cape Town"
}
],
"metricValues": [
{
"value": "47"
}
]
},
...
],
Filtro
Solo debes generar informes con datos para valores de dimensión específicos. Para filtrar
dimensiones, especifica un valor FilterExpression
en la
dimensionFilter
.
Este es un ejemplo que muestra un informe de serie temporal de eventCount, cuando
eventName es first_open para cada date :
HTTP
POST https://analyticsdata.googleapis.com/v1beta/properties/GA_PROPERTY_ID:runReport
{
"dateRanges": [{ "startDate": "7daysAgo", "endDate": "yesterday" }],
"dimensions": [{ "name": "date" }],
"metrics": [{ "name": "eventCount" }],
"dimensionFilter": {
"filter": {
"fieldName": "eventName",
"stringFilter": {
"value": "first_open"
}
}
},
}
Java
import com.google.analytics.data.v1beta.BetaAnalyticsDataClient;
import com.google.analytics.data.v1beta.DateRange;
import com.google.analytics.data.v1beta.Dimension;
import com.google.analytics.data.v1beta.Filter;
import com.google.analytics.data.v1beta.FilterExpression;
import com.google.analytics.data.v1beta.Metric;
import com.google.analytics.data.v1beta.RunReportRequest;
import com.google.analytics.data.v1beta.RunReportResponse;
/**
* Google Analytics Data API sample application demonstrating the usage of dimension and metric
* filters in a report.
*
* <p>See
* https://developers.google.com/analytics/devguides/reporting/data/v1/rest/v1beta/properties/runReport#body.request_body.FIELDS.dimension_filter
* for more information.
*
* <p>Before you start the application, please review the comments starting with "TODO(developer)"
* and update the code to use correct values.
*
* <p>To run this sample using Maven:
*
* <pre>{@code
* cd google-analytics-data
* mvn compile exec:java -Dexec.mainClass="com.google.analytics.data.samples.RunReportWithDimensionFilterSample"
* }</pre>
*/
public class RunReportWithDimensionFilterSample {
public static void main(String... args) throws Exception {
// TODO(developer): Replace with your Google Analytics 4 property ID before running the sample.
String propertyId = "YOUR-GA4-PROPERTY-ID";
sampleRunReportWithDimensionFilter(propertyId);
}
// 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.
static void sampleRunReportWithDimensionFilter(String propertyId) throws Exception {
// Initialize client that will be used to send requests. This client only needs to be created
// once, and can be reused for multiple requests. After completing all of your requests, call
// the "close" method on the client to safely clean up any remaining background resources.
try (BetaAnalyticsDataClient analyticsData = BetaAnalyticsDataClient.create()) {
RunReportRequest request =
RunReportRequest.newBuilder()
.setProperty("properties/" + propertyId)
.addDimensions(Dimension.newBuilder().setName("date"))
.addMetrics(Metric.newBuilder().setName("eventCount"))
.addDateRanges(
DateRange.newBuilder().setStartDate("7daysAgo").setEndDate("yesterday"))
.setDimensionFilter(
FilterExpression.newBuilder()
.setFilter(
Filter.newBuilder()
.setFieldName("eventName")
.setStringFilter(
Filter.StringFilter.newBuilder().setValue("first_open"))))
.build();
// Make the request.
RunReportResponse response = analyticsData.runReport(request);
// Prints the response using a method in RunReportSample.java
RunReportSample.printRunResponseResponse(response);
}
}
}
PHP
use Google\Analytics\Data\V1beta\Client\BetaAnalyticsDataClient;
use Google\Analytics\Data\V1beta\DateRange;
use Google\Analytics\Data\V1beta\Dimension;
use Google\Analytics\Data\V1beta\Filter;
use Google\Analytics\Data\V1beta\Filter\StringFilter;
use Google\Analytics\Data\V1beta\FilterExpression;
use Google\Analytics\Data\V1beta\Metric;
use Google\Analytics\Data\V1beta\MetricType;
use Google\Analytics\Data\V1beta\RunReportRequest;
use Google\Analytics\Data\V1beta\RunReportResponse;
/**
* @param string $propertyId Your GA-4 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.
*/
function run_report_with_dimension_filter(string $propertyId)
{
// Create an instance of the Google Analytics Data API client library.
$client = new BetaAnalyticsDataClient();
// Make an API call.
$request = (new RunReportRequest())
->setProperty('properties/' . $propertyId)
->setDimensions([new Dimension(['name' => 'date'])])
->setMetrics([new Metric(['name' => 'eventCount'])])
->setDateRanges([
new DateRange([
'start_date' => '7daysAgo',
'end_date' => 'yesterday',
])
])
->setDimensionFilter(new FilterExpression([
'filter' => new Filter([
'field_name' => 'eventName',
'string_filter' => new StringFilter([
'value' => 'first_open'
]),
]),
]));
$response = $client->runReport($request);
printRunReportResponseWithDimensionFilter($response);
}
/**
* Print results of a runReport call.
* @param RunReportResponse $response
*/
function printRunReportResponseWithDimensionFilter(RunReportResponse $response)
{
printf('%s rows received%s', $response->getRowCount(), PHP_EOL);
foreach ($response->getDimensionHeaders() as $dimensionHeader) {
printf('Dimension header name: %s%s', $dimensionHeader->getName(), PHP_EOL);
}
foreach ($response->getMetricHeaders() as $metricHeader) {
printf(
'Metric header name: %s (%s)' . PHP_EOL,
$metricHeader->getName(),
MetricType::name($metricHeader->getType())
);
}
print 'Report result: ' . PHP_EOL;
foreach ($response->getRows() as $row) {
printf(
'%s %s' . PHP_EOL,
$row->getDimensionValues()[0]->getValue(),
$row->getMetricValues()[0]->getValue()
);
}
}
Python
from google.analytics.data_v1beta import BetaAnalyticsDataClient
from google.analytics.data_v1beta.types import (
DateRange,
Dimension,
Filter,
FilterExpression,
Metric,
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)
Node.js
// TODO(developer): Uncomment this variable and replace with your
// Google Analytics 4 property ID before running the sample.
// propertyId = 'YOUR-GA4-PROPERTY-ID';
// Imports the Google Analytics Data API client library.
const {BetaAnalyticsDataClient} = require('@google-analytics/data');
// Initialize client that will be used to send requests. This client only
// needs to be created once, and can be reused for multiple requests.
const analyticsDataClient = new BetaAnalyticsDataClient();
// 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.
async function runReportWithDimensionFilter() {
const [response] = await analyticsDataClient.runReport({
property: `properties/${propertyId}`,
dimensions: [
{
name: 'date',
},
],
metrics: [
{
name: 'eventCount',
},
],
dateRanges: [
{
startDate: '7daysAgo',
endDate: 'yesterday',
},
],
dimensionFilter: {
filter: {
fieldName: 'eventName',
stringFilter: {
value: 'first_open',
},
},
},
});
printRunReportResponse(response);
}
runReportWithDimensionFilter();
// Prints results of a runReport call.
function printRunReportResponse(response) {
console.log(`${response.rowCount} rows received`);
response.dimensionHeaders.forEach(dimensionHeader => {
console.log(`Dimension header name: ${dimensionHeader.name}`);
});
response.metricHeaders.forEach(metricHeader => {
console.log(
`Metric header name: ${metricHeader.name} (${metricHeader.type})`
);
});
console.log('Report result:');
response.rows.forEach(row => {
console.log(
`${row.dimensionValues[0].value}, ${row.metricValues[0].value}`
);
});
}
Aquí hay otro ejemplo de FilterExpression,
donde andGroup incluye solo los datos que cumplen con todos los criterios de las expresiones
lista. Este dimensionFilter selecciona cuando browser es Chrome y
countryId es US:
HTTP
...
"dimensionFilter": {
"andGroup": {
"expressions": [
{
"filter": {
"fieldName": "browser",
"stringFilter": {
"value": "Chrome"
}
}
},
{
"filter": {
"fieldName": "countryId",
"stringFilter": {
"value": "US"
}
}
}
]
}
},
...
Java
import com.google.analytics.data.v1beta.BetaAnalyticsDataClient;
import com.google.analytics.data.v1beta.DateRange;
import com.google.analytics.data.v1beta.Dimension;
import com.google.analytics.data.v1beta.Filter;
import com.google.analytics.data.v1beta.FilterExpression;
import com.google.analytics.data.v1beta.FilterExpressionList;
import com.google.analytics.data.v1beta.Metric;
import com.google.analytics.data.v1beta.RunReportRequest;
import com.google.analytics.data.v1beta.RunReportResponse;
/**
* Google Analytics Data API sample application demonstrating the usage of dimension and metric
* filters in a report.
*
* <p>See
* https://developers.google.com/analytics/devguides/reporting/data/v1/rest/v1beta/properties/runReport#body.request_body.FIELDS.dimension_filter
* for more information.
*
* <p>Before you start the application, please review the comments starting with "TODO(developer)"
* and update the code to use correct values.
*
* <p>To run this sample using Maven:
*
* <pre>{@code
* cd google-analytics-data
* mvn compile exec:java -Dexec.mainClass="com.google.analytics.data.samples.RunReportWithMultipleDimensionFiltersSample"
* }</pre>
*/
public class RunReportWithMultipleDimensionFiltersSample {
public static void main(String... args) throws Exception {
// TODO(developer): Replace with your Google Analytics 4 property ID before running the sample.
String propertyId = "YOUR-GA4-PROPERTY-ID";
sampleRunReportWithMultipleDimensionFilters(propertyId);
}
// 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.
static void sampleRunReportWithMultipleDimensionFilters(String propertyId) throws Exception {
// Initialize client that will be used to send requests. This client only needs to be created
// once, and can be reused for multiple requests. After completing all of your requests, call
// the "close" method on the client to safely clean up any remaining background resources.
try (BetaAnalyticsDataClient analyticsData = BetaAnalyticsDataClient.create()) {
RunReportRequest request =
RunReportRequest.newBuilder()
.setProperty("properties/" + propertyId)
.addDimensions(Dimension.newBuilder().setName("browser"))
.addMetrics(Metric.newBuilder().setName("activeUsers"))
.addDateRanges(
DateRange.newBuilder().setStartDate("7daysAgo").setEndDate("yesterday"))
.setDimensionFilter(
FilterExpression.newBuilder()
.setAndGroup(
FilterExpressionList.newBuilder()
.addExpressions(
FilterExpression.newBuilder()
.setFilter(
Filter.newBuilder()
.setFieldName("browser")
.setStringFilter(
Filter.StringFilter.newBuilder()
.setValue("Chrome"))))
.addExpressions(
FilterExpression.newBuilder()
.setFilter(
Filter.newBuilder()
.setFieldName("countryId")
.setStringFilter(
Filter.StringFilter.newBuilder()
.setValue("US"))))))
.build();
// Make the request.
RunReportResponse response = analyticsData.runReport(request);
// Prints the response using a method in RunReportSample.java
RunReportSample.printRunResponseResponse(response);
}
}
}
PHP
use Google\Analytics\Data\V1beta\Client\BetaAnalyticsDataClient;
use Google\Analytics\Data\V1beta\DateRange;
use Google\Analytics\Data\V1beta\Dimension;
use Google\Analytics\Data\V1beta\Filter;
use Google\Analytics\Data\V1beta\Filter\StringFilter;
use Google\Analytics\Data\V1beta\FilterExpression;
use Google\Analytics\Data\V1beta\FilterExpressionList;
use Google\Analytics\Data\V1beta\Metric;
use Google\Analytics\Data\V1beta\MetricType;
use Google\Analytics\Data\V1beta\RunReportRequest;
use Google\Analytics\Data\V1beta\RunReportResponse;
/**
* @param string $propertyId Your GA-4 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.
*/
function run_report_with_multiple_dimension_filters(string $propertyId)
{
// Create an instance of the Google Analytics Data API client library.
$client = new BetaAnalyticsDataClient();
// Make an API call.
$request = (new RunReportRequest())
->setProperty('properties/' . $propertyId)
->setDimensions([new Dimension(['name' => 'browser'])])
->setMetrics([new Metric(['name' => 'activeUsers'])])
->setDateRanges([
new DateRange([
'start_date' => '7daysAgo',
'end_date' => 'yesterday',
]),
])
->setDimensionFilter(new FilterExpression([
'and_group' => new FilterExpressionList([
'expressions' => [
new FilterExpression([
'filter' => new Filter([
'field_name' => 'browser',
'string_filter' => new StringFilter([
'value' => 'Chrome',
])
]),
]),
new FilterExpression([
'filter' => new Filter([
'field_name' => 'countryId',
'string_filter' => new StringFilter([
'value' => 'US',
])
]),
]),
],
]),
]));
$response = $client->runReport($request);
printRunReportResponseWithMultipleDimensionFilters($response);
}
/**
* Print results of a runReport call.
* @param RunReportResponse $response
*/
function printRunReportResponseWithMultipleDimensionFilters(RunReportResponse $response)
{
printf('%s rows received%s', $response->getRowCount(), PHP_EOL);
foreach ($response->getDimensionHeaders() as $dimensionHeader) {
printf('Dimension header name: %s%s', $dimensionHeader->getName(), PHP_EOL);
}
foreach ($response->getMetricHeaders() as $metricHeader) {
printf(
'Metric header name: %s (%s)' . PHP_EOL,
$metricHeader->getName(),
MetricType::name($metricHeader->getType())
);
}
print 'Report result: ' . PHP_EOL;
foreach ($response->getRows() as $row) {
printf(
'%s %s' . PHP_EOL,
$row->getDimensionValues()[0]->getValue(),
$row->getMetricValues()[0]->getValue()
);
}
}
Python
from google.analytics.data_v1beta import BetaAnalyticsDataClient
from google.analytics.data_v1beta.types import (
DateRange,
Dimension,
Filter,
FilterExpression,
FilterExpressionList,
Metric,
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)
Node.js
// TODO(developer): Uncomment this variable and replace with your
// Google Analytics 4 property ID before running the sample.
// propertyId = 'YOUR-GA4-PROPERTY-ID';
// Imports the Google Analytics Data API client library.
const {BetaAnalyticsDataClient} = require('@google-analytics/data');
// Initialize client that will be used to send requests. This client only
// needs to be created once, and can be reused for multiple requests.
const analyticsDataClient = new BetaAnalyticsDataClient();
// 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.
async function runReportWithMultipleDimensionFilters() {
const [response] = await analyticsDataClient.runReport({
property: `properties/${propertyId}`,
dimensions: [
{
name: 'browser',
},
],
metrics: [
{
name: 'activeUsers',
},
],
dateRanges: [
{
startDate: '7daysAgo',
endDate: 'yesterday',
},
],
dimensionFilter: {
andGroup: {
expressions: [
{
filter: {
fieldName: 'browser',
stringFilter: {
value: 'Chrome',
},
},
},
{
filter: {
fieldName: 'countryId',
stringFilter: {
value: 'US',
},
},
},
],
},
},
});
printRunReportResponse(response);
}
runReportWithMultipleDimensionFilters();
// Prints results of a runReport call.
function printRunReportResponse(response) {
console.log(`${response.rowCount} rows received`);
response.dimensionHeaders.forEach(dimensionHeader => {
console.log(`Dimension header name: ${dimensionHeader.name}`);
});
response.metricHeaders.forEach(metricHeader => {
console.log(
`Metric header name: ${metricHeader.name} (${metricHeader.type})`
);
});
console.log('Report result:');
response.rows.forEach(row => {
console.log(
`${row.dimensionValues[0].value}, ${row.metricValues[0].value}`
);
});
}
Una orGroup incluye datos que cumplen con cualquiera de los criterios de las expresiones.
lista.
Un notExpression excluye los datos que coinciden con su expresión interna. Este es un
dimensionFilter que muestra datos solo cuando pageTitle no es My
Homepage El informe muestra datos de eventos para cada pageTitle excepto My
Homepage:
HTTP
...
"dimensionFilter": {
"notExpression": {
"filter": {
"fieldName": "pageTitle",
"stringFilter": {
"value": "My Homepage"
}
}
}
},
...
Java
import com.google.analytics.data.v1beta.BetaAnalyticsDataClient;
import com.google.analytics.data.v1beta.DateRange;
import com.google.analytics.data.v1beta.Dimension;
import com.google.analytics.data.v1beta.Filter;
import com.google.analytics.data.v1beta.FilterExpression;
import com.google.analytics.data.v1beta.Metric;
import com.google.analytics.data.v1beta.RunReportRequest;
import com.google.analytics.data.v1beta.RunReportResponse;
/**
* Google Analytics Data API sample application demonstrating the usage of dimension and metric
* filters in a report.
*
* <p>See
* https://developers.google.com/analytics/devguides/reporting/data/v1/rest/v1beta/properties/runReport#body.request_body.FIELDS.dimension_filter
* for more information.
*
* <p>Before you start the application, please review the comments starting with "TODO(developer)"
* and update the code to use correct values.
*
* <p>To run this sample using Maven:
*
* <pre>{@code
* cd google-analytics-data
* mvn compile exec:java -Dexec.mainClass="com.google.analytics.data.samples.RunReportWithDimensionExcludeFilterSample"
* }</pre>
*/
public class RunReportWithDimensionExcludeFilterSample {
public static void main(String... args) throws Exception {
// TODO(developer): Replace with your Google Analytics 4 property ID before running the sample.
String propertyId = "YOUR-GA4-PROPERTY-ID";
sampleRunReportWithDimensionExcludeFilter(propertyId);
}
// 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.
static void sampleRunReportWithDimensionExcludeFilter(String propertyId) throws Exception {
// Initialize client that will be used to send requests. This client only needs to be created
// once, and can be reused for multiple requests. After completing all of your requests, call
// the "close" method on the client to safely clean up any remaining background resources.
try (BetaAnalyticsDataClient analyticsData = BetaAnalyticsDataClient.create()) {
RunReportRequest request =
RunReportRequest.newBuilder()
.setProperty("properties/" + propertyId)
.addDimensions(Dimension.newBuilder().setName("pageTitle"))
.addMetrics(Metric.newBuilder().setName("sessions"))
.addDateRanges(
DateRange.newBuilder().setStartDate("7daysAgo").setEndDate("yesterday"))
.setDimensionFilter(
FilterExpression.newBuilder()
.setNotExpression(
FilterExpression.newBuilder()
.setFilter(
Filter.newBuilder()
.setFieldName("pageTitle")
.setStringFilter(
Filter.StringFilter.newBuilder()
.setValue("My Homepage")))))
.build();
// Make the request.
RunReportResponse response = analyticsData.runReport(request);
// Prints the response using a method in RunReportSample.java
RunReportSample.printRunResponseResponse(response);
}
}
}
PHP
use Google\Analytics\Data\V1beta\Client\BetaAnalyticsDataClient;
use Google\Analytics\Data\V1beta\DateRange;
use Google\Analytics\Data\V1beta\Dimension;
use Google\Analytics\Data\V1beta\Filter;
use Google\Analytics\Data\V1beta\Filter\StringFilter;
use Google\Analytics\Data\V1beta\FilterExpression;
use Google\Analytics\Data\V1beta\Metric;
use Google\Analytics\Data\V1beta\MetricType;
use Google\Analytics\Data\V1beta\RunReportRequest;
use Google\Analytics\Data\V1beta\RunReportResponse;
/**
* 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.
* @param string $propertyId Your GA-4 Property ID
*/
function run_report_with_dimension_exclude_filter(string $propertyId)
{
// Create an instance of the Google Analytics Data API client library.
$client = new BetaAnalyticsDataClient();
// Make an API call.
$request = (new RunReportRequest())
->setProperty('properties/' . $propertyId)
->setDimensions([new Dimension(['name' => 'pageTitle'])])
->setMetrics([new Metric(['name' => 'sessions'])])
->setDateRanges([new DateRange([
'start_date' => '7daysAgo',
'end_date' => 'yesterday',
])
])
->setDimensionFilter(new FilterExpression([
'not_expression' => new FilterExpression([
'filter' => new Filter([
'field_name' => 'pageTitle',
'string_filter' => new StringFilter([
'value' => 'My Homepage',
]),
]),
]),
]));
$response = $client->runReport($request);
printRunReportResponseWithDimensionExcludeFilter($response);
}
/**
* Print results of a runReport call.
* @param RunReportResponse $response
*/
function printRunReportResponseWithDimensionExcludeFilter(RunReportResponse $response)
{
printf('%s rows received%s', $response->getRowCount(), PHP_EOL);
foreach ($response->getDimensionHeaders() as $dimensionHeader) {
printf('Dimension header name: %s%s', $dimensionHeader->getName(), PHP_EOL);
}
foreach ($response->getMetricHeaders() as $metricHeader) {
printf(
'Metric header name: %s (%s)' . PHP_EOL,
$metricHeader->getName(),
MetricType::name($metricHeader->getType())
);
}
print 'Report result: ' . PHP_EOL;
foreach ($response->getRows() as $row) {
printf(
'%s %s' . PHP_EOL,
$row->getDimensionValues()[0]->getValue(),
$row->getMetricValues()[0]->getValue()
);
}
}
Python
from google.analytics.data_v1beta import BetaAnalyticsDataClient
from google.analytics.data_v1beta.types import (
DateRange,
Dimension,
Filter,
FilterExpression,
Metric,
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)
Node.js
// TODO(developer): Uncomment this variable and replace with your
// Google Analytics 4 property ID before running the sample.
// propertyId = 'YOUR-GA4-PROPERTY-ID';
// Imports the Google Analytics Data API client library.
const {BetaAnalyticsDataClient} = require('@google-analytics/data');
// Initialize client that will be used to send requests. This client only
// needs to be created once, and can be reused for multiple requests.
const analyticsDataClient = new BetaAnalyticsDataClient();
// 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.
async function runReportWithDimensionExcludeFilter() {
const [response] = await analyticsDataClient.runReport({
property: `properties/${propertyId}`,
dimensions: [
{
name: 'pageTitle',
},
],
metrics: [
{
name: 'sessions',
},
],
dateRanges: [
{
startDate: '7daysAgo',
endDate: 'yesterday',
},
],
dimensionFilter: {
notExpression: {
filter: {
fieldName: 'pageTitle',
stringFilter: {
value: 'My Homepage',
},
},
},
},
});
printRunReportResponse(response);
}
runReportWithDimensionExcludeFilter();
// Prints results of a runReport call.
function printRunReportResponse(response) {
console.log(`${response.rowCount} rows received`);
response.dimensionHeaders.forEach(dimensionHeader => {
console.log(`Dimension header name: ${dimensionHeader.name}`);
});
response.metricHeaders.forEach(metricHeader => {
console.log(
`Metric header name: ${metricHeader.name} (${metricHeader.type})`
);
});
console.log('Report result:');
response.rows.forEach(row => {
console.log(
`${row.dimensionValues[0].value}, ${row.metricValues[0].value}`
);
});
}
Un inListFilter coincide con los datos de cualquiera de los valores de la lista. Este es un
dimensionFilter que muestra datos de eventos en los que eventName es cualquiera de
purchase, in_app_purchase y app_store_subscription_renew:
HTTP
...
"dimensionFilter": {
"filter": {
"fieldName": "eventName",
"inListFilter": {
"values": ["purchase",
"in_app_purchase",
"app_store_subscription_renew"]
}
}
},
...
Java
import com.google.analytics.data.v1beta.BetaAnalyticsDataClient;
import com.google.analytics.data.v1beta.DateRange;
import com.google.analytics.data.v1beta.Dimension;
import com.google.analytics.data.v1beta.Filter;
import com.google.analytics.data.v1beta.FilterExpression;
import com.google.analytics.data.v1beta.Metric;
import com.google.analytics.data.v1beta.RunReportRequest;
import com.google.analytics.data.v1beta.RunReportResponse;
import java.util.ArrayList;
/**
* Google Analytics Data API sample application demonstrating the usage of dimension and metric
* filters in a report.
*
* <p>See
* https://developers.google.com/analytics/devguides/reporting/data/v1/rest/v1beta/properties/runReport#body.request_body.FIELDS.dimension_filter
* for more information.
*
* <p>Before you start the application, please review the comments starting with "TODO(developer)"
* and update the code to use correct values.
*
* <p>To run this sample using Maven:
*
* <pre>{@code
* cd google-analytics-data
* mvn compile exec:java -Dexec.mainClass="com.google.analytics.data.samples.RunReportWithDimensionInListFilterSample"
* }</pre>
*/
public class RunReportWithDimensionInListFilterSample {
public static void main(String... args) throws Exception {
// TODO(developer): Replace with your Google Analytics 4 property ID before running the sample.
String propertyId = "YOUR-GA4-PROPERTY-ID";
sampleRunReportWithDimensionInListFilter(propertyId);
}
// 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.
static void sampleRunReportWithDimensionInListFilter(String propertyId) throws Exception {
// Initialize client that will be used to send requests. This client only needs to be created
// once, and can be reused for multiple requests. After completing all of your requests, call
// the "close" method on the client to safely clean up any remaining background resources.
try (BetaAnalyticsDataClient analyticsData = BetaAnalyticsDataClient.create()) {
RunReportRequest request =
RunReportRequest.newBuilder()
.setProperty("properties/" + propertyId)
.addDimensions(Dimension.newBuilder().setName("eventName"))
.addMetrics(Metric.newBuilder().setName("sessions"))
.addDateRanges(
DateRange.newBuilder().setStartDate("7daysAgo").setEndDate("yesterday"))
.setDimensionFilter(
FilterExpression.newBuilder()
.setFilter(
Filter.newBuilder()
.setFieldName("eventName")
.setInListFilter(
Filter.InListFilter.newBuilder()
.addAllValues(
new ArrayList<String>() {
{
add("purchase");
add("in_app_purchase");
add("app_store_subscription_renew");
}
})
.build())))
.build();
// Make the request.
RunReportResponse response = analyticsData.runReport(request);
// Prints the response using a method in RunReportSample.java
RunReportSample.printRunResponseResponse(response);
}
}
}
PHP
use Google\Analytics\Data\V1beta\Client\BetaAnalyticsDataClient;
use Google\Analytics\Data\V1beta\DateRange;
use Google\Analytics\Data\V1beta\Dimension;
use Google\Analytics\Data\V1beta\Filter;
use Google\Analytics\Data\V1beta\Filter\InListFilter;
use Google\Analytics\Data\V1beta\FilterExpression;
use Google\Analytics\Data\V1beta\Metric;
use Google\Analytics\Data\V1beta\MetricType;
use Google\Analytics\Data\V1beta\RunReportRequest;
use Google\Analytics\Data\V1beta\RunReportResponse;
/**
* 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.
* @param string $propertyId Your GA-4 Property ID
*/
function run_report_with_dimension_in_list_filter(string $propertyId)
{
// Create an instance of the Google Analytics Data API client library.
$client = new BetaAnalyticsDataClient();
// Make an API call.
$request = (new RunReportRequest())
->setProperty('properties/' . $propertyId)
->setDimensions([new Dimension(['name' => 'eventName'])])
->setMetrics([new Metric(['name' => 'sessions'])])
->setDateRanges([new DateRange([
'start_date' => '7daysAgo',
'end_date' => 'yesterday',
])
])
->setDimensionFilter(new FilterExpression([
'filter' => new Filter([
'field_name' => 'eventName',
'in_list_filter' => new InListFilter([
'values' => [
'purchase',
'in_app_purchase',
'app_store_subscription_renew',
],
]),
]),
]));
$response = $client->runReport($request);
printRunReportResponseWithDimensionInListFilter($response);
}
/**
* Print results of a runReport call.
* @param RunReportResponse $response
*/
function printRunReportResponseWithDimensionInListFilter(RunReportResponse $response)
{
printf('%s rows received%s', $response->getRowCount(), PHP_EOL);
foreach ($response->getDimensionHeaders() as $dimensionHeader) {
printf('Dimension header name: %s%s', $dimensionHeader->getName(), PHP_EOL);
}
foreach ($response->getMetricHeaders() as $metricHeader) {
printf(
'Metric header name: %s (%s)' . PHP_EOL,
$metricHeader->getName(),
MetricType::name($metricHeader->getType())
);
}
print 'Report result: ' . PHP_EOL;
foreach ($response->getRows() as $row) {
printf(
'%s %s' . PHP_EOL,
$row->getDimensionValues()[0]->getValue(),
$row->getMetricValues()[0]->getValue()
);
}
}
Python
from google.analytics.data_v1beta import BetaAnalyticsDataClient
from google.analytics.data_v1beta.types import (
DateRange,
Dimension,
Filter,
FilterExpression,
Metric,
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)
Node.js
// TODO(developer): Uncomment this variable and replace with your
// Google Analytics 4 property ID before running the sample.
// propertyId = 'YOUR-GA4-PROPERTY-ID';
// Imports the Google Analytics Data API client library.
const {BetaAnalyticsDataClient} = require('@google-analytics/data');
// Initialize client that will be used to send requests. This client only
// needs to be created once, and can be reused for multiple requests.
const analyticsDataClient = new BetaAnalyticsDataClient();
// 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.
async function runReportWithDimensionInListFilter() {
const [response] = await analyticsDataClient.runReport({
property: `properties/${propertyId}`,
dimensions: [
{
name: 'eventName',
},
],
metrics: [
{
name: 'sessions',
},
],
dateRanges: [
{
startDate: '7daysAgo',
endDate: 'yesterday',
},
],
dimensionFilter: {
filter: {
fieldName: 'eventName',
inListFilter: {
values: [
'purchase',
'in_app_purchase',
'app_store_subscription_renew',
],
},
},
},
});
printRunReportResponse(response);
}
runReportWithDimensionInListFilter();
// Prints results of a runReport call.
function printRunReportResponse(response) {
console.log(`${response.rowCount} rows received`);
response.dimensionHeaders.forEach(dimensionHeader => {
console.log(`Dimension header name: ${dimensionHeader.name}`);
});
response.metricHeaders.forEach(metricHeader => {
console.log(
`Metric header name: ${metricHeader.name} (${metricHeader.type})`
);
});
console.log('Report result:');
response.rows.forEach(row => {
console.log(
`${row.dimensionValues[0].value}, ${row.metricValues[0].value}`
);
});
}
Navega por informes largos
De forma predeterminada, el informe contiene solo las primeras 10,000 filas de datos de eventos. Para
vea hasta 100,000 filas en el informe, puede incluir "limit": 100000 en
el
RunReportRequest
En el caso de los informes con más de 100,000 filas, debes enviar una serie de solicitudes y revisar los resultados. Por ejemplo, esta es una solicitud para la primera 100,000 filas:
HTTP
POST https://analyticsdata.googleapis.com/v1beta/properties/GA_PROPERTY_ID:runReport
{
...
"limit": 100000,
"offset": 0
}
Java
import com.google.analytics.data.v1beta.BetaAnalyticsDataClient;
import com.google.analytics.data.v1beta.DateRange;
import com.google.analytics.data.v1beta.Dimension;
import com.google.analytics.data.v1beta.Metric;
import com.google.analytics.data.v1beta.RunReportRequest;
import com.google.analytics.data.v1beta.RunReportResponse;
/**
* Google Analytics Data API sample application demonstrating the use of pagination to retrieve
* large result sets.
*
* <p>See
* https://developers.google.com/analytics/devguides/reporting/data/v1/rest/v1beta/properties/runReport#body.request_body.FIELDS.offset
* for more information.
*
* <p>Before you start the application, please review the comments starting with "TODO(developer)"
* and update the code to use correct values.
*
* <p>To run this sample using Maven:
*
* <pre>{@code
* cd google-analytics-data
* mvn compile exec:java -Dexec.mainClass="com.google.analytics.data.samples.RunReportWithPaginationSample"
* }</pre>
*/
public class RunReportWithPaginationSample {
public static void main(String... args) throws Exception {
// TODO(developer): Replace with your Google Analytics 4 property ID before running the sample.
String propertyId = "YOUR-GA4-PROPERTY-ID";
sampleRunReportWithPagination(propertyId);
}
// Runs a report several times, each time retrieving a portion of result using pagination.
static void sampleRunReportWithPagination(String propertyId) throws Exception {
// Initialize client that will be used to send requests. This client only needs to be created
// once, and can be reused for multiple requests. After completing all of your requests, call
// the "close" method on the client to safely clean up any remaining background resources.
try (BetaAnalyticsDataClient analyticsData = BetaAnalyticsDataClient.create()) {
RunReportRequest request =
RunReportRequest.newBuilder()
.setProperty("properties/" + propertyId)
.addDateRanges(
DateRange.newBuilder().setStartDate("365daysAgo").setEndDate("yesterday"))
.addDimensions(Dimension.newBuilder().setName("firstUserSource"))
.addDimensions(Dimension.newBuilder().setName("firstUserMedium"))
.addDimensions(Dimension.newBuilder().setName("firstUserCampaignName"))
.addMetrics(Metric.newBuilder().setName("sessions"))
.addMetrics(Metric.newBuilder().setName("keyEvents"))
.addMetrics(Metric.newBuilder().setName("totalRevenue"))
.setLimit(100000)
.setOffset(0)
.build();
// Make the request.
RunReportResponse response = analyticsData.runReport(request);
RunReportSample.printRunResponseResponse(response);
// Run the same report with a different offset value to retrieve the second page of a
// response.
request =
RunReportRequest.newBuilder()
.setProperty("properties/" + propertyId)
.addDateRanges(
DateRange.newBuilder().setStartDate("365daysAgo").setEndDate("yesterday"))
.addDimensions(Dimension.newBuilder().setName("firstUserSource"))
.addDimensions(Dimension.newBuilder().setName("firstUserMedium"))
.addDimensions(Dimension.newBuilder().setName("firstUserCampaignName"))
.addMetrics(Metric.newBuilder().setName("sessions"))
.addMetrics(Metric.newBuilder().setName("keyEvents"))
.addMetrics(Metric.newBuilder().setName("totalRevenue"))
.setLimit(100000)
.setOffset(100000)
.build();
// Make the request.
response = analyticsData.runReport(request);
// Prints the response using a method in RunReportSample.java
RunReportSample.printRunResponseResponse(response);
}
}
}
PHP
// Make an API call.
$request = (new RunReportRequest())
->setProperty('properties/' . $propertyId)
->setDateRanges([
new DateRange([
'start_date' => '350daysAgo',
'end_date' => 'yesterday',
])
])
->setDimensions([
new Dimension(['name' => 'firstUserSource']),
new Dimension(['name' => 'firstUserMedium']),
new Dimension(['name' => 'firstUserCampaignName']),
])
->setMetrics([
new Metric(['name' => 'sessions']),
new Metric(['name' => 'keyEvents']),
new Metric(['name' => 'totalRevenue']),
])
->setLimit(100000)
->setOffset(0);
$requestCount = 1;
printf('Sending request #%d' . PHP_EOL, $requestCount);
$response = $client->runReport($request);
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="keyEvents"),
Metric(name="totalRevenue"),
],
limit=100000,
offset=0,
)
response = client.run_report(request)
Node.js
const [response] = await analyticsDataClient.runReport({
property: `properties/${propertyId}`,
dateRanges: [
{
startDate: '350daysAgo',
endDate: 'yesterday',
},
],
dimensions: [
{
name: 'firstUserSource',
},
{
name: 'firstUserMedium',
},
{
name: 'firstUserCampaignName',
},
],
metrics: [
{
name: 'sessions',
},
{
name: 'keyEvents',
},
{
name: 'totalRevenue',
},
],
limit: 100000,
offset: 0,
});
El parámetro rowCount en la respuesta indica la cantidad total de filas.
independiente de los valores limit y offset de la solicitud. Por ejemplo,
La respuesta muestra "rowCount": 272345, necesitas tres solicitudes de 100,000 filas
cada una para recuperar todos los datos.
Esta es una solicitud de ejemplo para las siguientes 100,000 filas. Todos los demás parámetros, como
dateRange, dimensions y metrics deben ser los mismos que el primero.
para cada solicitud.
HTTP
POST https://analyticsdata.googleapis.com/v1beta/properties/GA_PROPERTY_ID:runReport
{
...
"limit": 100000,
"offset": 100000
}
Java
request =
RunReportRequest.newBuilder()
.setProperty("properties/" + propertyId)
.addDateRanges(
DateRange.newBuilder().setStartDate("365daysAgo").setEndDate("yesterday"))
.addDimensions(Dimension.newBuilder().setName("firstUserSource"))
.addDimensions(Dimension.newBuilder().setName("firstUserMedium"))
.addDimensions(Dimension.newBuilder().setName("firstUserCampaignName"))
.addMetrics(Metric.newBuilder().setName("sessions"))
.addMetrics(Metric.newBuilder().setName("keyEvents"))
.addMetrics(Metric.newBuilder().setName("totalRevenue"))
.setLimit(100000)
.setOffset(100000)
.build();
// Make the request.
response = analyticsData.runReport(request);
// Prints the response using a method in RunReportSample.java
RunReportSample.printRunResponseResponse(response);
PHP
$rowsReceived = count($response->getRows());
$totalRows = $response->getRowCount();
// Run the same report with an increased offset value to retrieve each additional
// page until all rows are received.
while ($rowsReceived < $totalRows) {
$request = $request->setOffset($rowsReceived);
$requestCount++;
printf('Sending request #%d' . PHP_EOL, $requestCount);
$response = $client->runReport($request);
$rowsReceived += count($response->getRows());
printRunReportResponseWithPagination($response, $requestCount);
}
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="keyEvents"),
Metric(name="totalRevenue"),
],
limit=100000,
offset=100000,
)
response = client.run_report(request)
Node.js
const [secondResponse] = await analyticsDataClient.runReport({
property: `properties/${propertyId}`,
dateRanges: [
{
startDate: '350daysAgo',
endDate: 'yesterday',
},
],
dimensions: [
{
name: 'firstUserSource',
},
{
name: 'firstUserMedium',
},
{
name: 'firstUserCampaignName',
},
],
metrics: [
{
name: 'sessions',
},
{
name: 'keyEvents',
},
{
name: 'totalRevenue',
},
],
limit: 100000,
offset: 100000,
});
Puedes usar valores offset, como 200000 o 300000, para recuperar
resultados posteriores. Todos los demás parámetros, como dateRange, dimensions y
metrics debe ser la misma que la primera solicitud.
Utilizar varios períodos
Una solicitud de informe puede recuperar datos de múltiples
dateRanges Por ejemplo, este informe compara
las primeras dos semanas de agosto de 2022 y 2023:
HTTP
POST https://analyticsdata.googleapis.com/v1beta/properties/GA_PROPERTY_ID:runReport
{
"dateRanges": [
{
"startDate": "2022-08-01",
"endDate": "2022-08-14"
},
{
"startDate": "2023-08-01",
"endDate": "2023-08-14"
}
],
"dimensions": [{ "name": "platform" }],
"metrics": [{ "name": "activeUsers" }]
}
Java
import com.google.analytics.data.v1beta.BetaAnalyticsDataClient;
import com.google.analytics.data.v1beta.DateRange;
import com.google.analytics.data.v1beta.Dimension;
import com.google.analytics.data.v1beta.Metric;
import com.google.analytics.data.v1beta.RunReportRequest;
import com.google.analytics.data.v1beta.RunReportResponse;
/**
* Google Analytics Data API sample application demonstrating the usage of date ranges in a report.
*
* <p>See
* https://developers.google.com/analytics/devguides/reporting/data/v1/rest/v1beta/properties/runReport#body.request_body.FIELDS.date_ranges
* for more information.
*
* <p>Before you start the application, please review the comments starting with "TODO(developer)"
* and update the code to use correct values.
*
* <p>To run this sample using Maven:
*
* <pre>{@code
* cd google-analytics-data
* mvn compile exec:java -Dexec.mainClass="com.google.analytics.data.samples.RunReportWithDateRangesSample"
* }</pre>
*/
public class RunReportWithDateRangesSample {
public static void main(String... args) throws Exception {
// TODO(developer): Replace with your Google Analytics 4 property ID before running the sample.
String propertyId = "YOUR-GA4-PROPERTY-ID";
sampleRunReportWithDateRanges(propertyId);
}
// Runs a report using two date ranges.
static void sampleRunReportWithDateRanges(String propertyId) throws Exception {
// Initialize client that will be used to send requests. This client only needs to be created
// once, and can be reused for multiple requests. After completing all of your requests, call
// the "close" method on the client to safely clean up any remaining background resources.
try (BetaAnalyticsDataClient analyticsData = BetaAnalyticsDataClient.create()) {
RunReportRequest request =
RunReportRequest.newBuilder()
.setProperty("properties/" + propertyId)
.addDateRanges(
DateRange.newBuilder().setStartDate("2019-08-01").setEndDate("2019-08-14"))
.addDateRanges(
DateRange.newBuilder().setStartDate("2020-08-01").setEndDate("2020-08-14"))
.addDimensions(Dimension.newBuilder().setName("platform"))
.addMetrics(Metric.newBuilder().setName("activeUsers"))
.build();
// Make the request.
RunReportResponse response = analyticsData.runReport(request);
// Prints the response using a method in RunReportSample.java
RunReportSample.printRunResponseResponse(response);
}
}
}
PHP
use Google\Analytics\Data\V1beta\Client\BetaAnalyticsDataClient;
use Google\Analytics\Data\V1beta\DateRange;
use Google\Analytics\Data\V1beta\Dimension;
use Google\Analytics\Data\V1beta\Metric;
use Google\Analytics\Data\V1beta\MetricType;
use Google\Analytics\Data\V1beta\RunReportRequest;
use Google\Analytics\Data\V1beta\RunReportResponse;
/**
* @param string $propertyID Your GA-4 Property ID
* Runs a report using two date ranges.
*/
function run_report_with_date_ranges(string $propertyId)
{
// Create an instance of the Google Analytics Data API client library.
$client = new BetaAnalyticsDataClient();
// Make an API call.
$request = (new RunReportRequest())
->setProperty('properties/' . $propertyId)
->setDateRanges([
new DateRange([
'start_date' => '2019-08-01',
'end_date' => '2019-08-14',
]),
new DateRange([
'start_date' => '2020-08-01',
'end_date' => '2020-08-14',
]),
])
->setDimensions([new Dimension(['name' => 'platform'])])
->setMetrics([new Metric(['name' => 'activeUsers'])]);
$response = $client->runReport($request);
printRunReportResponseWithDateRanges($response);
}
/**
* Print results of a runReport call.
* @param RunReportResponse $response
*/
function printRunReportResponseWithDateRanges(RunReportResponse $response)
{
printf('%s rows received%s', $response->getRowCount(), PHP_EOL);
foreach ($response->getDimensionHeaders() as $dimensionHeader) {
printf('Dimension header name: %s%s', $dimensionHeader->getName(), PHP_EOL);
}
foreach ($response->getMetricHeaders() as $metricHeader) {
printf(
'Metric header name: %s (%s)' . PHP_EOL,
$metricHeader->getName(),
MetricType::name($metricHeader->getType())
);
}
print 'Report result: ' . PHP_EOL;
foreach ($response->getRows() as $row) {
printf(
'%s %s' . PHP_EOL,
$row->getDimensionValues()[0]->getValue(),
$row->getMetricValues()[0]->getValue()
);
}
}
Python
from google.analytics.data_v1beta import BetaAnalyticsDataClient
from google.analytics.data_v1beta.types import (
DateRange,
Dimension,
Metric,
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)
Node.js
// TODO(developer): Uncomment this variable and replace with your
// Google Analytics 4 property ID before running the sample.
// propertyId = 'YOUR-GA4-PROPERTY-ID';
// Imports the Google Analytics Data API client library.
const {BetaAnalyticsDataClient} = require('@google-analytics/data');
// Initialize client that will be used to send requests. This client only
// needs to be created once, and can be reused for multiple requests.
const analyticsDataClient = new BetaAnalyticsDataClient();
// Runs a report using two date ranges.
async function runReportWithDateRanges() {
const [response] = await analyticsDataClient.runReport({
property: `properties/${propertyId}`,
dateRanges: [
{
startDate: '2019-08-01',
endDate: '2019-08-14',
},
{
startDate: '2020-08-01',
endDate: '2020-08-14',
},
],
dimensions: [
{
name: 'platform',
},
],
metrics: [
{
name: 'activeUsers',
},
],
});
printRunReportResponse(response);
}
runReportWithDateRanges();
// Prints results of a runReport call.
function printRunReportResponse(response) {
console.log(`${response.rowCount} rows received`);
response.dimensionHeaders.forEach(dimensionHeader => {
console.log(`Dimension header name: ${dimensionHeader.name}`);
});
response.metricHeaders.forEach(metricHeader => {
console.log(
`Metric header name: ${metricHeader.name} (${metricHeader.type})`
);
});
console.log('Report result:');
response.rows.forEach(row => {
console.log(
`${row.dimensionValues[0].value}, ${row.metricValues[0].value}`
);
});
}
Cuando incluyes varios dateRanges en una solicitud, se agrega una columna dateRange
automáticamente a la respuesta. Cuando la columna dateRange sea
date_range_0, los datos de esa fila corresponden al primer período. Cuando
La columna dateRange es date_range_1, los datos de esa fila corresponden a la segunda fecha
del rango de destino de la ruta.
Esta es una respuesta de ejemplo para dos períodos:
{
"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"
}
]
},
...
],
}
Próximos pasos
Consulta las funciones avanzadas y los informes en tiempo real para una descripción general de las funciones de informes más avanzadas de la versión 1 de la API de datos.