The Google Analytics API supplies access to Google Analytics (GA) report information such as pageviews, sessions, traffic source, and bounce rate.
The main Google documents describes that it can be utilized to:
- Construct customized dashboards to show GA data.
- Automate complex reporting tasks.
- Integrate with other applications.
This article will just cover a few of the methods that can be utilized to access various subsets of information utilizing different metrics and dimensions.
I intend to compose a follow-up guide checking out various methods you can evaluate, visualize, and combine the information.
Establishing The API
Developing A Google Service Account
The first step is to develop a project or choose one within your Google Service Account.
Once this has actually been developed, the next step 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 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 been developed, browse to the secret area and add a new key. Screenshot from Google Cloud, December 2022  This will trigger you to produce and download a personal secret. In this circumstances, choose JSON, and then develop and
wait for the file to download. Screenshot from Google Cloud, December 2022
Contribute To Google Analytics Account
You will also wish to take a copy of the email that has actually 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 e-mail as a user in Google Analytics with Analyst permissions. Screenshot from Google Analytics, December 2022
Making it possible for The API The final and perhaps essential action is guaranteeing you have made it possible for access to the API. To do this, guarantee you are in the right task and follow this link to enable access.
Then, follow the steps to enable it when promoted.
Screenshot from Google Cloud, December 2022 This is needed in order to access the API. If you miss this step, you will be triggered to finish it when first running the script. Accessing The Google Analytics API With Python Now whatever is established in our service account, we can start writing the script to export the information. I picked Jupyter Notebooks to produce this, but you can likewise utilize other incorporated developer
environments(IDEs)including PyCharm or VSCode. Installing Libraries The primary step is to install the libraries that are required to run the remainder of the code.
Some are distinct to the analytics API, and others work for future sections of the code.! pip install– upgrade google-api-python-client! pip3 install– upgrade oauth2client from apiclient.discovery import develop from oauth2client.service _ account import ServiceAccountCredentials! pip install connect! pip install functions import connect Note: When utilizing pip in a Jupyter notebook, add the!– if running in the command line or another IDE, the! isn’t required. Developing A Service Construct 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 produced when producing the private secret. This
is utilized in a comparable method to an API key. To quickly access this file within your code, ensure you
have saved the JSON file in the same folder as the code file. This can then quickly be called with the KEY_FILE_LOCATION function.
Finally, include the view ID from the analytics account with which you would like to access the information. Screenshot from author, December 2022 Completely
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 included our personal key file, we can add this to the credentials function 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 currently specified credentials from above.
credentials = ServiceAccountCredentials.from _ json_keyfile_name(KEY_FILE_LOCATION, SCOPES) service = construct(‘analyticsreporting’, ‘v4’, credentials=credentials)
Writing The Demand Body
As soon as we have everything set up and specified, the genuine enjoyable begins.
From the API service develop, there is the ability to pick the elements from the action that we want to access. This is called a ReportRequest object and needs the following as a minimum:
- A valid view ID for the viewId field.
- At least one legitimate entry in the dateRanges field.
- A minimum of one legitimate entry in the metrics field.
As discussed, there are a couple of things that are needed throughout this construct stage, starting with our viewId. As we have already defined previously, we simply need to call that function name (VIEW_ID) instead of including the whole view ID once again.
If you wished to collect data from a various analytics see in the future, you would just require to change the ID in the initial code block instead of both.
Then we can include the date variety for the dates that we wish to gather the information for. This consists of a start date and an end date.
There are a number of ways to compose this within the develop demand.
You can choose specified dates, for example, in between two dates, by adding the date in a year-month-date format, ‘startDate’: ‘2022-10-27’, ‘endDate’: ‘2022-11-27’.
Or, if you wish to see information from the last 30 days, you can set the start date as ’30daysAgo’ and completion date as ‘today.’
Metrics And Dimensions
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 characteristics of users, their sessions, and their actions. For example, page path, traffic source, and keywords used.
There are a lot of various metrics and dimensions 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 consists of objective conversions, starts and values, the internet browser device used to access the website, landing page, second-page path tracking, and internal search, website speed, and audience metrics.
Both the metrics and dimensions are added in a dictionary format, utilizing 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 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 brand-new users.
With dimensions, the secret will be ‘name’ followed by the colon again and the worth of the dimension. For example, if we wanted to draw out the different page courses, it would be ‘name’: ‘ga: pagePath’.
Or ‘name’: ‘ga: medium’ to see the different traffic source recommendations to the site.
Combining Measurements And Metrics
The genuine worth remains in combining metrics and measurements to extract the key insights we are most thinking about.
For instance, to see a count of all sessions that have been created from different traffic sources, we can set our metric to be ga: sessions and our measurement to be ga: medium.
reaction = service.reports(). batchGet( body= ). carry out()
Creating A DataFrame
The reaction we receive from the API is in the type of a dictionary, with all of the information in secret: worth sets. To make the data simpler to view and evaluate, we can turn it into a Pandas dataframe.
To turn our action into a dataframe, we initially need to create some empty lists, to hold the metrics and measurements.
Then, calling the reaction output, we will append the data from the measurements into the empty dimensions list and a count of the metrics into the metrics list.
This will extract the data 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(‘measurements’,  dateRangeValues = row.get(‘metrics’,  for header, measurement in zip(dimensionHeaders, dimensions): dim.append(dimension) for i, worths in enumerate(dateRangeValues): for metricHeader, worth in zip(metricHeaders, values.get(‘worths’)): metric.append(int(value)) Adding The Reaction Data
As soon as the data remains in those lists, we can easily turn them into a dataframe by defining the column names, in square brackets, and designating the list values 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 Request Examples Several Metrics There is also the ability to integrate several metrics, with each set included curly brackets and separated by a comma. ‘metrics’: [“expression”: “ga: pageviews”, ] Filtering You can likewise request the API action just returns metrics that return certain requirements by adding metric filters. It uses the following format:
if metricName return the metric For example, if you just wanted to draw out pageviews with more than ten views.
reaction = service.reports(). batchGet( body= ). execute() Filters likewise work for dimensions in a comparable way, however the filter expressions will be somewhat various due to the particular nature of dimensions.
For instance, if you just want to draw out pageviews from users who have gone to the website using the Chrome internet browser, you can set an EXTRACT operator and use ‘Chrome’ as the expression.
reaction = service.reports(). batchGet( body= ). execute()
As metrics are quantitative procedures, there is likewise the ability to compose expressions, which work likewise to calculated metrics.
This includes specifying an alias to represent the expression and completing a mathematical function on two metrics.
For instance, you can compute completions per user by dividing the variety of conclusions by the number of users.
response = service.reports(). batchGet( body= ). perform()
The API also lets you container measurements with an integer (numeric) value into varieties utilizing histogram pails.
For example, bucketing the sessions count measurement into four 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= ‘reportRequests’:  ). execute() Screenshot from author, December 2022 In Conclusion I hope this has actually supplied you with a basic guide to accessing the Google Analytics API, composing some different requests, and collecting some meaningful insights in an easy-to-view format. I have included the build 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 checking out the information even more. More resources: Included Image: BestForBest/Best SMM Panel