Cómo acceder a la API de Google Analytics usando Python

La API de Google Analytics brinda acceso a los 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 una respuesta API usando varios métodos diferentes, incluidos Java, PHP y JavaScript, pero este artículo se centrará específicamente en recuperar y exportar datos usando Pitón.

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

Espero escribir una guía de seguimiento que explore las diferentes formas en que puede analizar. visualizary combinar 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 desde dentro Cuenta de servicio de Google.

Después de crear esto, el siguiente paso es elegir + Crear una cuenta de servicio botón.

Luego se le pedirá que agregue algunos detalles, como el nombre, la identificación y la descripción.

Una vez creada la cuenta de servicio, vaya a LLAVES sección y agregue una nueva clave.

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

Agregar a la cuenta de Google Analytics

También querrá obtener una copia del correo electrónico que se creó para la cuenta de servicio, que 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 Analytics.

Habilitación de la API

El último paso, y sin duda el más importante, es asegurarse de habilitar el acceso a la API. Para hacer esto, asegúrese de estar en el proyecto correcto y siga este enlace para proporcionar acceso.

Luego, siga los pasos para habilitarlo cuando se le solicite.

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

Accediendo a la API de Google Analytics con Python

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

elegí cuadernos jupyter Sin embargo, para crearlo, puede utilizar otros entornos de desarrollo integrados (IDE), incluido el suyo. PyCharm o Código VSC.

instalación de bibliotecas

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

Algunos son exclusivos de la API de análisis, mientras que 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: ¡Al usar pip en el cuaderno Jupyter! – si se ejecuta en la línea de comandos o en otro IDE, ! no es necesario.

Creación de una estructura de servicio

El siguiente paso es configurar nuestro alcance con un enlace de autenticación de API de análisis de solo lectura.

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

Asegúrese de guardar el archivo JSON en el mismo directorio que el archivo de código para que pueda acceder fácilmente a este archivo dentro de su código. Esto se puede llamar fácilmente con la función KEY_FILE_LOCATION.

Finalmente, agregue el ID de vista de la cuenta de análisis desde la que desea acceder a los datos.

En general, se verá así. Nos referiremos a estas funciones a lo largo de nuestro código.

SCOPES = ['https://www.googleapis.com/auth/analytics.readonly']
KEY_FILE_LOCATION = 'client_secrets.json'
VIEW_ID = 'XXXXX'

Después de agregar nuestro archivo de clave privada, podemos agregarlo a la función de credenciales llamando al archivo y configurándolo a través del paso ServiceAccountCredentials.

A continuación, cree el informe de compilación llamando al informe de análisis API V4 y nuestras credenciales definidas anteriormente.

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

Escribiendo el cuerpo de la consulta

Una vez que tienes todo configurado y definido, comienza la verdadera diversión.

Existe una opción para seleccionar los elementos de la respuesta a los que queremos acceder desde la estructura del servicio API. Esto se denomina objeto ReportRequest y requiere, como mínimo, lo siguiente:

• Un ID de vista válido para el campo ViewId.
• Al menos una entrada válida en el campo DateRanges.
• Al menos una entrada válida en el campo Métricas.

Ver identificación

Como se mencionó, hay algunas cosas que necesitamos en esta fase de compilación, comenzando con nuestro viewId. En lugar de volver a agregar la ID de vista completa como definimos anteriormente, solo necesitamos llamar a ese nombre de función (VIEW_ID).

Si desea recopilar datos de una vista de análisis diferente en el futuro, simplemente necesita cambiar la ID en el bloque de código inicial, no ambos.

Rango de fechas

Luego, podemos agregar un rango de fechas para las fechas de las que queremos recopilar datos. Consta de una fecha de inicio y finalización.

Hay varias formas de escribir esto en el indicador de instalación.

Puede seleccionar fechas específicas, por ejemplo, entre dos fechas, agregando la fecha en formato año-mes-fecha, ‘startDate’: ‘2022-10-27’, ‘end date’: ‘2022-11-27’.

O bien, si desea ver los datos de los últimos 30 días, puede establecer la fecha de inicio en “30daysAgo” y la fecha de finalización en “hoy”.

Métricas y Dimensiones

El último paso de la llamada de respuesta básica es establecer los tamaños y dimensiones. Las métricas son medidas cuantitativas de Google Analytics, como el recuento de sesiones, la duración de la sesión y la tasa de rebote.

Las dimensiones son las características, sesiones y acciones de los usuarios. Por ejemplo, la ruta de la página, la fuente de tráfico y las palabras clave utilizadas.

Hay muchos tamaños y dimensiones diferentes disponibles. No los revisaré todos en este artículo, pero todos se pueden encontrar con información y atributos adicionales. aquí.

Todo lo que puede obtener en Google Analytics, puede acceder en la API. Esto incluye conversiones de objetivos, clientes potenciales y valores, dispositivo de navegación utilizado para acceder al sitio web, página de destino, seguimiento de la ruta de la segunda página y búsqueda interna, velocidad del sitio y métricas de audiencia.

Tanto las medidas como las medidas se agregan en formato de diccionario usando pares clave:valor. Para las métricas, la clave será “expresión” seguida de dos puntos (:) y luego el valor de nuestra métrica, que tiene un formato especial.

Por ejemplo, si quisiéramos obtener el número total de sesiones, agregaríamos la ‘expresión’: ‘ga:sessions’. O ‘expression’: ‘ga:newUsers’ queremos ver el número de todos los usuarios nuevos.

Con dimensiones, la clave será “nombre” y luego dos puntos y el valor de la dimensión. Por ejemplo, si quisiéramos extraer diferentes rutas de página, esta sería ‘name’: ‘ga:pagePath’.

O ‘name’: ‘ga:medium’ para ver las diferentes fuentes de tráfico que redirigen al sitio.

Combinación de dimensiones y métricas

El valor real está en combinar dimensiones y métricas para extraer los conocimientos clave que más nos interesan.

Por ejemplo, para ver el número total de sesiones creadas a partir de diferentes fuentes de tráfico, podemos establecer la métrica en ga:sessions y nuestras métricas en ga:medium.

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

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 los pares clave:valor. Podemos convertirlo en un marco de datos de Pandas para que sea más fácil ver y analizar los datos.

Para convertir nuestra respuesta en un marco de datos, primero debemos crear algunas listas vacías para contener los tamaños y dimensiones.

Luego, llamando a la salida de respuesta, agregaremos los datos de las métricas a la lista de métricas vacía y el número de 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))

Adición de 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 valores de lista a cada columna.

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

Más solicitudes de respuesta de muestra

Múltiples métricas

También es posible combinar varias dimensiones encerradas en cada par de llaves y separadas por comas.

'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 que tengan 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 funcionan de manera similar para las métricas, pero debido a la naturaleza característica de las métricas, las expresiones de filtro serán ligeramente diferentes.

Por ejemplo, si solo desea extraer vistas de página de los usuarios que visitaron el sitio con el navegador Chrome, puede especificar el operador EXTRACT 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

Debido a que las métricas son medidas cuantitativas, también es posible escribir expresiones que funcionen de manera similar a las medidas calculadas.

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

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 dividir las métricas en rangos con un valor entero (numérico) usando cubos de histograma.

Por ejemplo, puede usar el tipo de orden HISTOGRAM_BUCKET y establecer los rangos en histogramBuckets, dividiendo el tamaño de las sesiones en cuatro grupos de 1-9, 10-99, 100-199 y 200-399.

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 el final

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

Agregué el código de configuración y solicitud y fragmentos compartidos 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:

---

Imagen destacada: BestForBest/Shutterstock