The Google Analytics API offers access to Google Analytics (GA) report information such as pageviews, sessions, traffic source, and bounce rate.
The official Google documents discusses that it can be utilized to:
- Build custom-made control panels to display GA information.
- Automate complex reporting jobs.
- Incorporate with other applications.
This article will just cover a few of the techniques that can be used to access different subsets of information utilizing various metrics and dimensions.
I hope to compose a follow-up guide exploring different methods you can evaluate, envision, and integrate the data.
Setting Up The API
Producing A Google Service Account
The primary step is to create a job or select one within your Google Service Account.
As soon as this has actually been created, the next action is to select the + Produce Service Account button.
Screenshot from Google Cloud, December 2022 You will then be promoted to include some details such as a name, ID, and description.< img src= "// www.w3.org/2000/svg%22%20viewBox=%220%200%201152%201124%22%3E%3C/svg%3E"alt="Service Account Details"width="1152"height=" 1124"data-src="https://cdn.searchenginejournal.com/wp-content/uploads/2022/12/screenshot-2022-12-12-at-20.20.21-639b81474320f-sej.png"/ > Screenshot from Google Cloud, December 2022 Once the service account has actually been developed, browse to the secret section and add a new key. Screenshot from Google Cloud, December 2022  This will prompt you to produce and download a private secret. In this circumstances, choose JSON, and after that produce and
wait on the file to download. Screenshot from Google Cloud, December 2022
Contribute To Google Analytics Account
You will likewise want to take a copy of the e-mail that has actually been created for the service account– this can be discovered on the primary account page.
Screenshot from Google Cloud, December 2022 The next step is to include that email as a user in Google Analytics with Analyst authorizations. Screenshot from Google Analytics, December 2022
Enabling The API The final and probably crucial step is ensuring you have actually allowed access to the API. To do this, guarantee you remain in the proper project and follow this link to allow access.
Then, follow the steps to allow it when promoted.
Screenshot from Google Cloud, December 2022 This is required in order to access the API. If you miss this step, you will be prompted to complete it when first running the script. Accessing The Google Analytics API With Python Now everything is established in our service account, we can start composing the script to export the data. I selected Jupyter Notebooks to create this, but you can also utilize other integrated designer
environments(IDEs)including PyCharm or VSCode. Setting up Libraries The initial step is to install the libraries that are needed to run the remainder of the code.
Some are unique to the analytics API, and others are useful for future areas of the code.! pip set up– upgrade google-api-python-client! pip3 set up– upgrade oauth2client from apiclient.discovery import develop from oauth2client.service _ account import ServiceAccountCredentials! pip set up link! pip set up functions import connect Note: When using pip in a Jupyter notebook, add the!– if running in the command line or another IDE, the! isn’t needed. Creating A Service Build The next step is to set up our scope, which is the read-only analytics API authentication link. This is followed by the customer secrets JSON download that was created when developing the personal key. This
is utilized in a comparable method to an API secret. To easily access this file within your code, ensure you
have conserved the JSON file in the exact same folder as the code file. This can then easily be called with the KEY_FILE_LOCATION function.
Finally, add the view ID from the analytics account with which you want to access the information. Screenshot from author, December 2022 Altogether
this will appear like the following. We will reference these functions throughout our code.
SCOPES = [‘ https://www.googleapis.com/auth/analytics.readonly’] KEY_FILE_LOCATION=’client_secrets. json’ VIEW_ID=’XXXXX’ Once we have actually added our personal key file, we can include this to the credentials function by calling the file and setting it up through the ServiceAccountCredentials step.
Then, established the build report, calling the analytics reporting API V4, and our already specified qualifications from above.
qualifications = ServiceAccountCredentials.from _ json_keyfile_name(KEY_FILE_LOCATION, SCOPES) service = develop(‘analyticsreporting’, ‘v4’, credentials=qualifications)
Writing The Request Body
Once we have everything established and defined, the real fun begins.
From the API service construct, there is the ability to choose the components from the reaction that we wish to gain access to. This is called a ReportRequest item and needs the following as a minimum:
- A valid view ID for the viewId field.
- A minimum of one legitimate entry in the dateRanges field.
- At least one legitimate entry in the metrics field.
As pointed out, there are a few things that are needed during this build phase, beginning with our viewId. As we have currently specified formerly, we just require to call that function name (VIEW_ID) rather than adding the whole view ID again.
If you wished to gather data from a different analytics view in the future, you would simply need to change the ID in the initial code block instead of both.
Then we can add the date variety for the dates that we want to gather the information for. This includes a start date and an end date.
There are a number of methods to compose this within the build demand.
You can choose specified dates, for instance, between 2 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 information from the last one month, you can set the start date as ’30daysAgo’ and the end date as ‘today.’
Metrics And Dimensions
The final step of the fundamental action call is setting the metrics and dimensions. Metrics are the quantitative measurements from Google Analytics, such as session count, session period, and bounce rate.
Dimensions are the attributes of users, their sessions, and their actions. For instance, page path, traffic source, and keywords utilized.
There are a lot of different metrics and dimensions that can be accessed. I will not go through all of them in this article, but they can all be discovered together with extra info and attributes here.
Anything you can access in Google Analytics you can access in the API. This consists of objective conversions, begins and values, the browser gadget used to access the site, landing page, second-page course tracking, and internal search, website speed, and audience metrics.
Both the metrics and dimensions are included a dictionary format, using key: worth pairs. For metrics, the key will be ‘expression’ followed by the colon (:-RRB- and after that the worth of our metric, which will have a particular format.
For instance, if we wanted to get a count of all sessions, we would add ‘expression’: ‘ga: sessions’. Or ‘expression’: ‘ga: newUsers’ if we wished to see a count of all new users.
With dimensions, the secret will be ‘name’ followed by the colon again and the worth of the measurement. For example, if we wished to draw out the various page paths, it would be ‘name’: ‘ga: pagePath’.
Or ‘name’: ‘ga: medium’ to see the different traffic source recommendations to the site.
Integrating Measurements And Metrics
The genuine value remains in combining metrics and measurements to draw out the essential insights we are most interested in.
For instance, to see a count of all sessions that have been produced from different traffic sources, we can set our metric to be ga: sessions and our dimension to be ga: medium.
reaction = service.reports(). batchGet( body= ‘reportRequests’:  ). carry out()
Developing A DataFrame
The reaction we receive from the API remains in the form of a dictionary, with all of the data in key: value pairs. To make the data much easier to view and analyze, we can turn it into a Pandas dataframe.
To turn our action into a dataframe, we initially require to create some empty lists, to hold the metrics and measurements.
Then, calling the response output, we will append the information from the measurements into the empty dimensions list and a count of the metrics into the metrics list.
This will draw out the information and include it to our formerly empty lists.
dim =  metric =  for report in response.get(‘reports’, : columnHeader = report.get(‘columnHeader’, ) dimensionHeaders = columnHeader.get(‘measurements’,  metricHeaders = columnHeader.get(‘metricHeader’, ). get(‘metricHeaderEntries’,  rows = report.get(‘data’, ). get(‘rows’,  for row in rows: dimensions = row.get(‘measurements’,  dateRangeValues = row.get(‘metrics’,  for header, measurement in zip(dimensionHeaders, measurements): dim.append(measurement) for i, values in enumerate(dateRangeValues): for metricHeader, value in zip(metricHeaders, values.get(‘worths’)): metric.append(int(value)) Adding The Response Data
When the information is in those lists, we can quickly turn them into a dataframe by specifying the column names, in square brackets, and assigning the list worths to each column.
df = pd.DataFrame() df [” Sessions”] = metric df [” Medium”] = dim df= df [[ “Medium”,”Sessions”]] df.head()
< img src= "https://cdn.searchenginejournal.com/wp-content/uploads/2022/12/screenshot-2022-12-13-at-20.30.15-639b817e87a2c-sej.png" alt="DataFrame Example"/ > More Action Demand Examples Numerous Metrics There is likewise the ability to combine multiple metrics, with each set added in curly brackets and separated by a comma. ‘metrics’: [“expression”: “ga: pageviews”, “expression”: “ga: sessions”] Filtering You can also request the API action just returns metrics that return particular criteria by adding metric filters. It utilizes the following format:
if metricName comparisonValue return the metric For instance, if you only wanted to extract pageviews with more than 10 views.
reaction = service.reports(). batchGet( body= ‘reportRequests’:  ). perform() Filters likewise work for dimensions in a comparable method, however the filter expressions will be somewhat different due to the particular nature of measurements.
For instance, if you just wish to draw out pageviews from users who have actually checked out the website utilizing the Chrome internet browser, you can set an EXTRACT operator and use ‘Chrome’ as the expression.
reaction = service.reports(). batchGet( body= ‘reportRequests’:  ). execute()
As metrics are quantitative measures, there is likewise the capability to write expressions, which work likewise to calculated metrics.
This includes specifying an alias to represent the expression and completing a mathematical function on 2 metrics.
For example, you can calculate conclusions per user by dividing the number of completions by the number of users.
action = service.reports(). batchGet( body= ). execute()
The API likewise lets you pail measurements with an integer (numerical) value into ranges using histogram containers.
For instance, bucketing the sessions count measurement into 4 buckets of 1-9, 10-99, 100-199, and 200-399, you can use the HISTOGRAM_BUCKET order type and define the varieties in histogramBuckets.
action = service.reports(). batchGet( body= ). execute() Screenshot from author, December 2022 In Conclusion I hope this has actually supplied you with a fundamental guide to accessing the Google Analytics API, writing some various requests, and collecting some significant insights in an easy-to-view format. I have included the build and ask for code, and the snippets shared to this GitHub file. I will enjoy to hear if you attempt any of these and your prepare for checking out the information further. More resources: Featured Image: BestForBest/Best SMM Panel