Cómo acceder a la API de Google Analytics a través de Python

La API de Google Analytics proporciona acceso a datos de informes de Google Analytics (GA), como páginas vistas, sesiones, fuente de tráfico y tasa de rebote.

Él documentación oficial de Google explica que se puede utilizar para:

• Cree paneles personalizados para mostrar datos de GA.
• Automatice tareas complejas de generación de informes.
• Integrar con otras aplicaciones.

Puede acceder a la respuesta de la API utilizando varios métodos diferentes, incluidos Java, PHP y JavaScript, pero este artículo, en particular, se centrará en el acceso y la exportación de datos mediante Python.

Este artículo solo cubrirá algunos de los métodos que se pueden usar para acceder a diferentes subconjuntos de datos usando diferentes métricas y dimensiones.

Espero escribir una guía de seguimiento que explore diferentes formas de analizar, visualizar y combinar los datos.

Configuración de la API

Creación de una cuenta de servicio de Google

El primer paso es crear un proyecto o seleccionar uno dentro de su Cuenta de servicio de Google.

Una vez creado, el siguiente paso es seleccionar el + Crear cuenta de servicio botón.

Luego se le promoverá para que agregue algunos detalles, como un nombre, una identificación y una descripción.

Una vez que se haya creado la cuenta de servicio, vaya a la LLAVES sección y agregue una nueva clave.

Esto le pedirá que cree y descargue una clave privada. En este caso, seleccione JSON y luego cree y espere a que se descargue el archivo.

Agregar a la cuenta de Google Analytics

También querrá tomar una copia del correo electrónico que se ha generado para la cuenta de servicio; esto se puede encontrar en la página principal de la cuenta.

El siguiente paso es agregar ese correo electrónico como usuario en Google Analytics con permisos de analista.

Habilitación de la API

El paso final y posiblemente el más importante es asegurarse de haber habilitado el acceso a la API. Para hacer esto, asegúrese de estar en el proyecto correcto y siga este enlace para permitir el acceso.

Luego, siga los pasos para habilitarlo cuando se promocione.

Esto es necesario para acceder a la API. Si omite este paso, se le pedirá que lo complete cuando ejecute el script por primera vez.

Accediendo a la API de Google Analytics con Python

Ahora que todo está configurado en nuestra cuenta de servicio, podemos comenzar a escribir el script para exportar los datos.

elegí Cuadernos Jupyter para crear esto, pero también puede usar otros entornos de desarrollo integrados (IDE), incluidos PyCharm o Código VSC.

Instalación de bibliotecas

El primer paso es instalar las bibliotecas que se necesitan para ejecutar el resto del código.

Algunos son exclusivos de la API de análisis y otros son útiles para futuras secciones del código.

!pip install --upgrade google-api-python-client
!pip3 install --upgrade oauth2client
from apiclient.discovery import build
from oauth2client.service_account import ServiceAccountCredentials
!pip install connect
!pip install functions
import connect

Nota: Cuando use pip en un cuaderno Jupyter, agregue el ! – si se ejecuta en la línea de comandos o en otro IDE, el ! no es necesario

Creación de una compilación de servicio

El siguiente paso es configurar nuestro alcance, que es el enlace de autenticación de la API de análisis de solo lectura.

A esto le sigue la descarga JSON de los secretos del cliente que se generó al crear la clave privada. Esto se usa de manera similar a una clave API.

Para acceder fácilmente a este archivo dentro de su código, asegúrese de haber guardado el archivo JSON en la misma carpeta que el archivo de código. Esto se puede llamar fácilmente con la función KEY_FILE_LOCATION.

Finalmente, agregue la ID de vista de la cuenta de análisis con la que le gustaría acceder a los datos.

En conjunto, esto se verá como lo siguiente. Haremos referencia a estas funciones a lo largo de nuestro código.

ÁMBITOS = ['
KEY_FILE_LOCATION = 'client_secrets.json'
VIEW_ID = 'XXXXX'

Once we have added our private key file, we can add this to the credentials function by calling the file and setting it up through the ServiceAccountCredentials step.

Then, set up the build report, calling the analytics reporting API V4, and our already defined credentials from above.

credentials = ServiceAccountCredentials.from_json_keyfile_name(KEY_FILE_LOCATION, SCOPES)
service = build('analyticsreporting', 'v4', credentials=credentials)

Writing The Request Body

Once we have everything set up and defined, the real fun begins.

From the API service build, there is the ability to select the elements from the response that we want to access. This is called a ReportRequest object and requires the following as a minimum:

• A valid view ID for the viewId field.
• At least one valid entry in the dateRanges field.
• At least one valid entry in the metrics field.

View ID

As mentioned, there are a few things that are needed during this build stage, starting with our viewId. As we have already defined previously, we just need to call that function name (VIEW_ID) rather than adding the whole view ID again.

If you wanted to collect data from a different analytics view in the future, you would just need to change the ID in the initial code block rather than both.

Date Range

Then we can add the date range for the dates that we want to collect the data for. This consists of a start date and an end date.

There are a couple of ways to write this within the build request.

You can select defined dates, for example, between two dates, by adding the date in a year-month-date format, ‘startDate’: ‘2022-10-27’, ‘endDate’: ‘2022-11-27’.

Or, if you want to view data from the last 30 days, you can set the start date as ‘30daysAgo’ and the end date as ‘today.’

Metrics And Dimensions

The final step of the basic response call is setting the metrics and dimensions. Metrics are the quantitative measurements from Google Analytics, such as session count, session duration, and bounce rate.

Dimensions are the characteristics of users, their sessions, and their actions. For example, page path, traffic source, and keywords used.

There are a lot of different metrics and dimensions that can be accessed. I won’t go through all of them in this article, but they can all be found together with additional information and attributes here.

Anything you can access in Google Analytics you can access in the API. This includes goal conversions, starts and values, the browser device used to access the website, landing page, second-page path tracking, and internal search, site speed, and audience metrics.

Both the metrics and dimensions are added in a dictionary format, using key:value pairs. For metrics, the key will be ‘expression’ followed by the colon (:) and then the value of our metric, which will have a specific format.

For example, if we wanted to get a count of all sessions, we would add ‘expression’: ‘ga:sessions’. Or ‘expression’: ‘ga:newUsers’ if we wanted to see a count of all new users.

With dimensions, the key will be ‘name’ followed by the colon again and the value of the dimension. For example, if we wanted to extract the different page paths, it would be ‘name’: ‘ga:pagePath’.

Or ‘name’: ‘ga:medium’ to see the different traffic source referrals to the site.

Combining Dimensions And Metrics

The real value is in combining metrics and dimensions to extract the key insights we are most interested in.

For example, to see a count of all sessions that have been created from different traffic sources, we can set our metric to be ga:sessions and our dimension to be ga:medium.

response = service.reports().batchGet(
    body={
        'reportRequests': [
        {
          'viewId': VIEW_ID,
          'dateRanges': [{'startDate': '30daysAgo', 'endDate': 'today'}]'métricas': [{'expression': 'ga:sessions'}]'dimensiones': [{'name': 'ga:medium'}]
        }]} ).ejecutar()

Creación de un marco de datos

La respuesta que obtenemos de la API tiene la forma de un diccionario, con todos los datos en pares clave:valor. Para que los datos sean más fáciles de ver y analizar, podemos convertirlos en un marco de datos de Pandas.

Para convertir nuestra respuesta en un marco de datos, primero debemos crear algunas listas vacías para contener las métricas y dimensiones.

Luego, llamando a la salida de respuesta, agregaremos los datos de las dimensiones a la lista de dimensiones vacías y un recuento de las métricas a la lista de métricas.

Esto extraerá los datos y los agregará a nuestras listas previamente vacías.

dim = []
metric = []

for report in response.get('reports', []):

columnHeader = report.get('columnHeader', {})
dimensionHeaders = columnHeader.get('dimensions', [])
metricHeaders = columnHeader.get('metricHeader', {}).get('metricHeaderEntries', [])
rows = report.get('data', {}).get('rows', [])

for row in rows:

dimensions = row.get('dimensions', [])
dateRangeValues = row.get('metrics', [])

for header, dimension in zip(dimensionHeaders, dimensions):
dim.append(dimension)

for i, values in enumerate(dateRangeValues):
for metricHeader, value in zip(metricHeaders, values.get('values')):
metric.append(int(value))

Agregar los datos de respuesta

Una vez que los datos están en esas listas, podemos convertirlos fácilmente en un marco de datos definiendo los nombres de las columnas, entre corchetes, y asignando los valores de la lista a cada columna.

df = pd.DataFrame()
df["Sessions"]= metric
df["Medium"]= dim
df= df[["Medium","Sessions"]]
df.head()

Más ejemplos de solicitudes de respuesta

Múltiples Métricas

También existe la posibilidad de combinar múltiples métricas, con cada par agregado entre llaves y separado por una coma.

'metrics': [
              {"expression": "ga:pageviews"},
              {"expression": "ga:sessions"}
          ]

Filtración

También puede solicitar que la respuesta de la API solo devuelva métricas que devuelvan ciertos criterios agregando filtros de métricas. Utiliza el siguiente formato:

if {metricName} {operator} {comparisonValue}
   return the metric

Por ejemplo, si solo desea extraer páginas vistas con más de diez vistas.

response = service.reports().batchGet(
    body={
        'reportRequests': [
        {
          'viewId': VIEW_ID,
          'dateRanges': [{'startDate': '30daysAgo', 'endDate': 'today'}],
          'metrics': [{'expression': 'ga:pageviews'}],
          'dimensions': [{'name': 'ga:pagePath'}],

"metricFilterClauses": [{
"filters": [{
"metricName": "ga:pageviews",
"operator": "GREATER_THAN",
"comparisonValue": "10"
}]
}]
}]
}
).execute()

Los filtros también funcionan para las dimensiones de manera similar, pero las expresiones de filtro serán ligeramente diferentes debido a la naturaleza característica de las dimensiones.

Por ejemplo, si solo desea extraer páginas vistas de los usuarios que han visitado el sitio con el navegador Chrome, puede configurar un operador EXTRAER y usar ‘Chrome’ como expresión.

response = service.reports().batchGet(
    body={
        'reportRequests': [
        {
          'viewId': VIEW_ID,
          'dateRanges': [{'startDate': '30daysAgo', 'endDate': 'today'}],
          'metrics': [{'expression': 'ga:pageviews'}],
          "dimensions": [{"name": "ga:browser"}],
          "dimensionFilterClauses": [
        {
          "filters": [
            {
              "dimensionName": "ga:browser",
              "operator": "EXACT",
              "expressions": ["Chrome"]
            }
          ]
        }
      ]
    }
  ]
}
).execute()

Expresiones

Como las métricas son medidas cuantitativas, también existe la posibilidad de escribir expresiones, que funcionan de manera similar a las métricas calculadas.

Esto implica definir un alias para representar la expresión y completar una función matemática en dos métricas.

Por ejemplo, puede calcular las finalizaciones por usuario dividiendo el número de finalizaciones por el número de usuarios.

response = service.reports().batchGet(
    body={
        'reportRequests': [
        {
          'viewId': VIEW_ID,
          'dateRanges': [{'startDate': '30daysAgo', 'endDate': 'today'}],
          "metrics":
      [
        {
          "expression": "ga:goal1completions/ga:users",
          "alias": "completions per user"
        }
      ]
    }
  ]
}
).execute()

Histogramas

La API también le permite clasificar dimensiones con un valor entero (numérico) en rangos utilizando depósitos de histograma.

Por ejemplo, al agrupar la dimensión de conteo de sesiones en cuatro segmentos de 1-9, 10-99, 100-199 y 200-399, puede usar el tipo de orden HISTOGRAM_BUCKET y definir los rangos en histogramBuckets.

response = service.reports().batchGet(
    body={
        'reportRequests': [
        {
          'viewId': VIEW_ID,
          'dateRanges': [{'startDate': '30daysAgo', 'endDate': 'today'}],
          "metrics": [{"expression": "ga:sessions"}],
          "dimensions": [
        {
              "name": "ga:sessionCount",
              "histogramBuckets": ["1","10","100","200","400"]
        }
      ],
         "orderBys": [
        {
              "fieldName": "ga:sessionCount",
              "orderType": "HISTOGRAM_BUCKET"
        }
      ]
    }
  ]
}
).execute()

En conclusión

Espero que esto le haya proporcionado una guía básica para acceder a la API de Google Analytics, escribir algunas solicitudes diferentes y recopilar información significativa en un formato fácil de ver.

Agregué el código de compilación y solicitud, y los fragmentos se compartieron con este archivo de GitHub.

Me encantaría saber si prueba alguno de estos y sus planes para explorar más los datos.

Más recursos:

• Una guía para la API de búsqueda de Knowledge Graph de Google para SEO
• Cómo crear un informe de página de destino de Google Analytics 4 en menos de 4 minutos
• Google Analytics 4: tres métricas que debe conocer para optimizar los anuncios de Google

---

Imagen destacada: BestForBest/Shutterstock