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.
HTTP
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.
HTTP
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.
HTTP
{
"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
:
Accesso più recente epoca in micro | Indirizzo email dell'utente | Numero di accessi |
---|---|---|
1525220215025371 | Bola@example.net | 5 |
1525220215028361 | Alex@example.net | 36 |
1525220215027671 | Charlie@example.net | 1153 |
1525220215027341 | Mahan@example.net | 1 |
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).
Accesso più recente epoca in micro | Indirizzo email dell'utente | Meccanismo di accesso | Numero di accessi |
---|---|---|---|
1525220215028367 | Alex@example.net | Firebase | 31 |
1525220215555778 | Alex@example.net | Interfaccia utente di Google Analytics | 1 |
1525220215022378 | Bola@example.net | Interfaccia utente di Google Analytics | 65 |
1525220215026389 | Bola@example.net | API Google Analytics | 894 |
1525220215025631 | Charlie@example.net | API Google Analytics | 67 |
1525220215068325 | Mahan@example.net | Google Ads | 3 |
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:
ID proprietà a cui è stato eseguito l'accesso | Nome proprietà a cui è stato eseguito l'accesso | Meccanismo di accesso | Numero di accessi |
---|---|---|---|
12345678 | DemoApp | Firebase | 31 |
12345678 | DemoApp | Interfaccia utente di Google Analytics | 624 |
12345678 | DemoApp | Google Ads | 83 |
12345678 | DemoApp | API Google Analytics | 1744 |
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.
Tempo di epoca Unix in micro | Indirizzo email dell'utente | ID proprietà a cui è stato eseguito l'accesso | Nome proprietà a cui è stato eseguito l'accesso | IP utente | Meccanismo di accesso | Dati di costo restituiti | Dati sulle entrate restituiti |
---|---|---|---|---|---|---|---|
1525220215025371 | Bola@example.net | 12345678 | DemoApp | 1.2.3.1 | Interfaccia utente di Google Analytics | true | true |
1525220645645645 | Mahan@example.net | 12345678 | DemoApp | 1.2.3.5 | Interfaccia utente di Google Analytics | falso | falso |
1525220211312322 | Bola@example.net | 12345678 | DemoApp | 11.22.33.11 | Google Ads | true | falso |
1525220210234221 | Alex@example.net | 12345678 | DemoApp | 11.22.33.22 | Firebase | falso | falso |
1525220215028368 | Alex@example.net | 12345678 | DemoApp | 1.2.3.2 | Google Ads | falso | falso |
1525220214234231 | Mahan@example.net | 12345678 | DemoApp | 11.22.33.55 | Google Ads | true | true |
1525220423423452 | Charlie@example.net | 12345678 | DemoApp | 1.2.3.3 | API Google Analytics | true | falso |
1525220132312333 | Mahan@example.net | 12345678 | DemoApp | 1.2.3.5 | Google Ads | true | true |
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.
Python
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}")