The Google Analytics API provides access to Google Analytics (GA) report information such as pageviews, sessions, traffic source, and bounce rate.
The main Google paperwork discusses that it can be used to:
- Construct customized control panels to show GA information.
- Automate complex reporting jobs.
- Integrate with other applications.
This post will just cover a few of the approaches that can be utilized to access various subsets of data using various metrics and dimensions.
I intend to compose a follow-up guide checking out various ways you can examine, picture, and combine the information.
Setting Up The API
Creating A Google Service Account
The first step is to create a project or select one within your Google Service Account.
As soon as this has been developed, the next action is to choose the + Develop Service Account button.
Screenshot from Google Cloud, December 2022 You will then be promoted to add 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 Particulars"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 produced, navigate to the KEYS section and add a new secret. Screenshot from Google Cloud, December 2022  This will prompt you to create and download a personal secret. In this instance, select JSON, and after that develop and
wait for the file to download. Screenshot from Google Cloud, December 2022
Contribute To Google Analytics Account
You will likewise wish to take a copy of the email that has been generated for the service account– this can be discovered on the primary account page.
Screenshot from Google Cloud, December 2022 The next action is to include that email as a user in Google Analytics with Analyst permissions. Screenshot from Google Analytics, December 2022
Making it possible for The API The last and perhaps most important step is guaranteeing you have actually made it possible for access to the API. To do this, ensure you remain in the proper project and follow this link to allow access.
Then, follow the steps to enable 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 triggered to complete it when first running the script. Accessing The Google Analytics API With Python Now everything is set up in our service account, we can start writing the script to export the data. I picked Jupyter Notebooks to create this, however you can likewise use other integrated designer
environments(IDEs)consisting of PyCharm or VSCode. Installing Libraries The first step is to install the libraries that are needed to run the rest of the code.
Some are unique to the analytics API, and others are useful for future sections of the code.! pip install– upgrade google-api-python-client! pip3 set up– upgrade oauth2client from apiclient.discovery import construct from oauth2client.service _ account import ServiceAccountCredentials! pip install connect! pip install functions import link Note: When using pip in a Jupyter note pad, add the!– if running in the command line or another IDE, the! isn’t required. Developing A Service Construct The next action is to set up our scope, which is the read-only analytics API authentication link. This is followed by the client secrets JSON download that was generated when creating the personal secret. This
is used in a comparable method to an API secret. To quickly access this file within your code, guarantee you
have actually saved the JSON file in the very same folder as the code file. This can then quickly be called with the KEY_FILE_LOCATION function.
Finally, add the view ID from the analytics account with which you wish to access the data. Screenshot from author, December 2022 Altogether
this will look 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 added our personal essential file, we can include this to the qualifications work by calling the file and setting it up through the ServiceAccountCredentials action.
Then, established the build report, calling the analytics reporting API V4, and our already specified credentials from above.
credentials = ServiceAccountCredentials.from _ json_keyfile_name(KEY_FILE_LOCATION, SCOPES) service = build(‘analyticsreporting’, ‘v4’, credentials=credentials)
Composing The Request Body
Once we have everything established and specified, the genuine fun starts.
From the API service develop, there is the ability to pick the aspects from the reaction that we wish to gain access to. This is called a ReportRequest things and needs the following as a minimum:
- A legitimate view ID for the viewId field.
- At least one valid entry in the dateRanges field.
- At least one legitimate entry in the metrics field.
As pointed out, there are a couple of things that are required throughout this construct stage, starting with our viewId. As we have currently defined previously, we simply require to call that function name (VIEW_ID) rather than adding the whole view ID again.
If you wanted to gather data from a different analytics view in the future, you would just need to alter the ID in the preliminary code block instead of both.
Then we can add the date variety for the dates that we want to gather the data for. This consists of a start date and an end date.
There are a number of methods to write this within the build request.
You can select defined dates, for instance, in between 2 dates, by including the date in a year-month-date format, ‘startDate’: ‘2022-10-27’, ‘endDate’: ‘2022-11-27’.
Or, if you wish to see data from the last 30 days, you can set the start date as ’30daysAgo’ and the end date as ‘today.’
Metrics And Measurements
The final step of the standard response 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 qualities of users, their sessions, and their actions. For instance, page course, traffic source, and keywords used.
There are a lot of various metrics and measurements that can be accessed. I will not go through all of them in this article, however they can all be discovered together with additional details and attributes here.
Anything you can access in Google Analytics you can access in the API. This includes goal conversions, begins and values, the browser gadget utilized to access the website, landing page, second-page path tracking, and internal search, website speed, and audience metrics.
Both the metrics and measurements are included a dictionary format, using secret: value pairs. For metrics, the key will be ‘expression’ followed by the colon (:-RRB- and then the worth of our metric, which will have a specific format.
For example, if we wanted to get a count of all sessions, we would include ‘expression’: ‘ga: sessions’. Or ‘expression’: ‘ga: newUsers’ if we wanted to see a count of all new users.
With measurements, the key will be ‘name’ followed by the colon once again and the worth of the dimension. For example, if we wished 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 website.
Integrating Measurements And Metrics
The genuine value is in combining metrics and dimensions to extract the essential insights we are most interested in.
For example, 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 measurement to be ga: medium.
action = service.reports(). batchGet( body= ‘reportRequests’:  ). carry out()
Creating A DataFrame
The action we receive from the API is in the type of a dictionary, with all of the information in key: value sets. To make the data easier to view and examine, we can turn it into a Pandas dataframe.
To turn our action into a dataframe, we initially need to develop some empty lists, to hold the metrics and dimensions.
Then, calling the response output, we will add the data from the measurements into the empty dimensions list and a count of the metrics into the metrics list.
This will extract the information and add it to our previously empty lists.
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(‘information’, ). get(‘rows’,  for row in rows: measurements = row.get(‘dimensions’,  dateRangeValues = row.get(‘metrics’,  for header, dimension in zip(dimensionHeaders, measurements): dim.append(measurement) for i, values in enumerate(dateRangeValues): for metricHeader, value in zip(metricHeaders, values.get(‘values’)): metric.append(int(worth)) Including The Response Data
When the information remains in those lists, we can quickly turn them into a dataframe by defining the column names, in square brackets, and appointing 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 Response Demand Examples Numerous Metrics There is also the capability to integrate several metrics, with each pair added in curly brackets and separated by a comma. ‘metrics’: [, ] Filtering You can likewise ask for the API response just returns metrics that return particular criteria by adding metric filters. It utilizes the following format:
if return the metric For instance, if you only wished to extract pageviews with more than 10 views.
action = service.reports(). batchGet( body= ). execute() Filters also work for dimensions in a similar way, however the filter expressions will be a little various due to the characteristic nature of dimensions.
For example, if you only wish to draw out pageviews from users who have checked out the website using the Chrome browser, you can set an EXTRACT operator and use ‘Chrome’ as the expression.
reaction = service.reports(). batchGet( body= ). carry out()
As metrics are quantitative procedures, there is likewise the ability to compose expressions, which work similarly to calculated metrics.
This includes defining an alias to represent the expression and completing a mathematical function on two metrics.
For example, you can calculate conclusions per user by dividing the variety of conclusions by the variety of users.
reaction = service.reports(). batchGet( body= ‘reportRequests’:  ). perform()
The API likewise lets you pail measurements with an integer (numerical) worth into ranges using histogram pails.
For instance, bucketing the sessions count dimension into 4 pails of 1-9, 10-99, 100-199, and 200-399, you can utilize the HISTOGRAM_BUCKET order type and specify the varieties in histogramBuckets.
response = service.reports(). batchGet( body= ). carry out() Screenshot from author, December 2022 In Conclusion I hope this has supplied you with a standard guide to accessing the Google Analytics API, writing some different requests, and collecting some significant insights in an easy-to-view format. I have added the construct and request code, and the snippets shared to this GitHub file. I will enjoy to hear if you try any of these and your plans for exploring the data further. More resources: Included Image: BestForBest/Best SMM Panel