Panoramica

La versione 1 dell'API Admin di Google Analytics consente di accedere ai dati ai report utilizzando runAccessReport . Il report fornisce i record di ogni volta che un utente legge Google Analytics. i dati dei report. I record degli accessi vengono conservati per un massimo di due anni. Accesso ai dati I report sono disponibili solo per gli utenti con il ruolo di Amministratore.

Creazione di un report di accesso ai dati

I report sull'accesso ai dati sono forniti Metodo runAccessReport.

Funzionalità condivise con i report principali

Le richieste del report Accesso ai dati hanno la stessa semantica del report principale richieste, per molte funzionalità condivise. Ad esempio: Le specifiche per impaginazione, filtri dimensioni e intervalli di date si comportano allo stesso modo nei report di accesso ai dati come report principali.

Acquisisci familiarità con la panoramica della funzionalità di generazione di report principali della API di dati v1, mentre la parte restante si concentrerà sulle funzionalità specifiche delle richieste di report di accesso ai dati.

Selezione di un'entità segnalante

Simili ai report principali funzionalità dei API di dati v1, runAccessReport dell'API Admin Google Analytics v1 richiede Google Analytics dell'identificatore della proprietà da specificare all'interno un percorso di richiesta dell'URL nel formato properties/GA_PROPERTY_ID, ad esempio:

  POST  https://analyticsadmin.googleapis.com/v1beta/properties/GA_PROPERTY_ID:runAccessReport

Il report sull'accesso ai dati risultante verrà generato in base ai dati di Google Analytics record di accesso ai dati per la proprietà Google Analytics specificata.

Se utilizzi una delle librerie client dell'API Admin, non occorre manipolare manualmente il percorso dell'URL di richiesta. La maggior parte dei client API fornisci un parametro property che prevede una stringa sotto forma di properties/GA_PROPERTY_ID. Visualizza lo snippet di codice nella alla fine di questa guida per un esempio di utilizzo delle librerie client.

Dimensioni e metriche

Dimensioni per descrivere e raggruppare i dati di accesso alla proprietà. Ad esempio, la dimensione userEmail indica l'email dell'utente che ha eseguito l'accesso ai dati del report. I valori delle dimensioni nelle risposte ai report sono stringhe.

Metriche rappresentano le misurazioni quantitative di un report. La metrica accessCount restituisce il numero totale di record di accesso ai dati.

Consulta lo schema di accesso ai dati per un elenco completo delle dimensioni e i nomi delle metriche disponibili nelle richieste dei report sull'accesso ai dati.

Richiesta report di accesso ai dati

Per richiedere report sull'accesso ai dati, crea un oggetto RunAccessReportRequest. Me consigliamo di iniziare con questi parametri di richiesta:

• Almeno una voce valida nella data intervalli .
• Almeno una voce valida nel dimensioni .
• Se non utilizzi la dimensione epochTimeMicros, devi avere almeno una voce valida in il metriche per ricevere dati quantitativi per ogni combinazione di valori di dimensioni in un report.

Ecco un esempio di richiesta con i campi consigliati. Questa query genererà elenco di indirizzi email degli utenti, l'ultima volta che hanno effettuato l'accesso alla proprietà specificata nell'intervallo degli ultimi 7 giorni e il numero di accessi corrispondente.

POST https://analyticsadmin.googleapis.com/v1beta/properties/GA_PROPERTY_ID:runAccessReport
{
  "dateRanges": [
    {
      "startDate": "7daysAgo",
      "endDate": "today"
    }
  ],
  "dimensions": [
    {
      "dimensionName": "mostRecentAccessEpochTimeMicros"
    },
    {
      "dimensionName": "userEmail"
    }
  ],
  "metrics": [
    {
      "metricName": "accessCount"
    }
  ]
}

Segnala risposta

Concettualmente simile ai report principali funzionalità dell'API di dati v1, il report Accesso ai dati Risposta del di accesso a un report è composta principalmente da un'intestazione e da righe. L'intestazione è composta da AccessDimensionHeaders e AccessMetricHeaders in cui sono elencate le colonne del report.

Ogni report sugli accessi riga è costituita da AccessDimensionValues: e AccessMetricValues per le colonne del report. L'ordine delle colonne è coerente richiesta, l'intestazione e ogni riga.

Ecco un esempio di risposta per la precedente richiesta di esempio:

{
  "dimensionHeaders": [
    {
      "dimensionName": "mostRecentAccessEpochTimeMicros"
    },
    {
      "dimensionName": "userEmail"
    }
  ],
  "metricHeaders": [
    {
      "metricName": "accessCount"
    }
  ],
  "rows": [
    {
      "dimensionValues": [
        {
          "value": "1667591408427733"
        },
        {
          "value": "Bola@example.net"
        }
      ],
      "metricValues": [
        {
          "value": "1238"
        }
      ]
    },
    {
      "dimensionValues": [
        {
          "value": "1667710959827161"
        },
        {
          "value": "Alex@example.net"
        }
      ],
      "metricValues": [
        {
          "value": "475"
        }
      ]
    },
    {
      "dimensionValues": [
        {
          "value": "1667868650762743"
        },
        {
          "value": "Mahan@example.net"
        }
      ],
      "metricValues": [
        {
          "value": "96"
        }
      ]
    }
  ],
  "rowCount": 3
}

Filtro in base ai record di accesso

Utilizza la dimensionFilter campo del RunAccessReportRequest per limitare le risposte ai report a valori di dimensione specifici che corrispondono ai filtro.

L'esempio seguente genera un report basato sull'accesso ai singoli dati record, filtrando in base ai record di accesso di un singolo utente con email Alex@example.net. Il report contiene l'ora di ciascun record di accesso, email e indirizzo IP.

POST https://analyticsadmin.googleapis.com/v1beta/properties/GA_PROPERTY_ID:runAccessReport
{
  "dateRanges": [
    {
      "startDate": "7daysAgo",
      "endDate": "today"
    }
  ],
  "dimensions": [
    {
      "dimensionName": "epochTimeMicros"
    },
    {
      "dimensionName": "userEmail"
    },
    {
      "dimensionName": "userIP"
    }
  ],
  "dimensionFilter": {
    "accessFilter": {
      "fieldName": "userEmail",
      "stringFilter": {
        "matchType": "EXACT",
        "value": "Alex@example.net"
      }
    }
  }
}

Analogamente, metricFilter campo del RunAccessReportRequest può essere utilizzato per limitare la risposta ai report a valori di metrica specifici che corrispondono al filtro.

L'esempio seguente genera un report contenente email e numero di accessi di tutti gli utenti che hanno effettuato l'accesso alla proprietà specificata più di 100 volte.

{
  "dateRanges": [
    {
      "startDate": "7daysAgo",
      "endDate": "today"
    }
  ],
  "dimensions": [
    {
      "dimensionName": "userEmail"
    }
  ],
  "metricFilter": {
    "accessFilter": {
      "numericFilter": {
        "operation": "GREATER_THAN",
        "value": {
          "int64Value": 100
        }
      },
      "fieldName": "accessCount"
    }
  },
  "metrics": [
    {
      "metricName": "accessCount"
    }
  ]
}

Report di esempio

Ecco alcuni report di esempio che puoi provare.

Report Accesso più recente per utente

Il seguente report di accesso di esempio che può essere creato utilizzando runAccessReport:

Questo report può essere generato eseguendo query dimensioni mostRecentAccessEpochTimeMicros, userEmail e la metrica accessCount. La report contiene una riga per ogni utente: mostRecentAccessEpochTimeMicros la dimensione aggrega i record di accesso ai dati per ciascun utente che accede alla proprietà e restituisce l'ora dell'ultimo accesso (in microsecondi Unix dal epoch) per ogni riga.

Report suddivisione accesso utente

Un altro esempio di report utile è la suddivisione degli accessi degli utenti in base all'accesso Meccanismo (ad es. interfaccia utente di Google Analytics, API e così via).

Questo report può essere generato eseguendo query dimensioni mostRecentAccessEpochTimeMicros, userEmail, accessMechanism e accessCount metrica.

Il report contiene una riga per ogni combinazione utente/meccanismo di accesso. La mostRecentAccessEpochTimeMicros dimensione contiene l'ultima volta che un utente accesso alla proprietà utilizzando il meccanismo di accesso specificato.

Report Panoramica dell'accesso alla proprietà

È possibile generare un report per una proprietà senza suddividere i dati in base singoli utenti. Ad esempio, il seguente report indica la frequenza con cui una proprietà si accede utilizzando diversi meccanismi di accesso:

Questo report può essere generato eseguendo query dimensioni accessedPropertyId, accessedPropertyName, accessMechanism e accessCount metrica.

Il report contiene una riga per ogni combinazione di ID proprietà/meccanismo di accesso.

Report sugli accessi ai singoli dati

Per generare un report in cui ogni riga si basa su un singolo accesso ai dati record, ometti la dimensione mostRecentAccessEpochTimeMicros da una query utilizza invece la dimensione epochTimeMicros. Non è necessario eseguire query sul accessCount, poiché ogni riga del report contiene informazioni su una a una singola occorrenza di accesso ai dati.

Il seguente report contiene informazioni dettagliate su ogni volta che un utente ha eseguito l'accesso alla proprietà specificata.

Questo report può essere generato eseguendo query dimensioni epochTimeMicros, userEmail, accessedPropertyId, accessedPropertyName, userIP, accessMechanism, costDataReturned e revenueDataReturned.

Librerie client

Consulta la Guida rapida per una spiegazione come installare e configurare le librerie client.

Ecco un esempio di utilizzo della libreria client Python che esegue una query di accesso ai dati e stampa la risposta.

from datetime import datetime

from google.analytics.admin import AnalyticsAdminServiceClient
from google.analytics.admin_v1alpha.types import (
    AccessDateRange,
    AccessDimension,
    AccessMetric,
    RunAccessReportRequest,
)


def run_sample():
    """Runs the sample."""
    # TODO(developer): Replace this variable with your Google Analytics 4
    #  property ID (e.g. "123456") before running the sample.
    property_id = "YOUR-GA4-PROPERTY-ID"
    run_access_report(property_id)


def run_access_report(property_id: str, transport: str = None):
    """
    Runs an access report for a Google Analytics property. The report will
    aggregate over dimensions `userEmail`, `accessedPropertyId`,
    `reportType`, `revenueDataReturned`, `costDataReturned`,
    `userIP`, and return the access count, as well as the most recent access
    time for each combination.
    See https://developers.google.com/analytics/devguides/config/admin/v1/access-api-schema
    for the description of each field used in a data access report query.
    Args:
        property_id(str): The Google Analytics Property ID.
        transport(str): The transport to use. For example, "grpc"
            or "rest". If set to None, a transport is chosen automatically.
    """
    client = AnalyticsAdminServiceClient(transport=transport)
    request = RunAccessReportRequest(
        entity=f"properties/{property_id}",
        dimensions=[
            AccessDimension(dimension_name="userEmail"),
            AccessDimension(dimension_name="accessedPropertyId"),
            AccessDimension(dimension_name="reportType"),
            AccessDimension(dimension_name="revenueDataReturned"),
            AccessDimension(dimension_name="costDataReturned"),
            AccessDimension(dimension_name="userIP"),
            AccessDimension(dimension_name="mostRecentAccessEpochTimeMicros"),
        ],
        metrics=[AccessMetric(metric_name="accessCount")],
        date_ranges=[AccessDateRange(start_date="yesterday", end_date="today")],
    )

    access_report = client.run_access_report(request)

    print("Result:")
    print_access_report(access_report)


def print_access_report(response):
    """Prints the access report."""
    print(f"{response.row_count} rows received")
    for dimensionHeader in response.dimension_headers:
        print(f"Dimension header name: {dimensionHeader.dimension_name}")
    for metricHeader in response.metric_headers:
        print(f"Metric header name: {metricHeader.metric_name})")

    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].dimension_name
            if dimension_name.endswith("Micros"):
                # Convert microseconds since Unix Epoch to datetime object.
                dimension_value_formatted = datetime.utcfromtimestamp(
                    int(dimension_value.value) / 1000000
                )
            else:
                dimension_value_formatted = dimension_value.value
            print(f"{dimension_name}: {dimension_value_formatted}")

        for i, metric_value in enumerate(row.metric_values):
            metric_name = response.metric_headers[i].metric_name
            print(f"{metric_name}: {metric_value.value}")

properties_run_access_report.py