How To Gain Access To Google Analytics API Via Python

Posted by

[]The Google Analytics API supplies access to Google Analytics (GA) report information such as pageviews, sessions, traffic source, and bounce rate.

[]The official Google documents explains that it can be utilized to:

  • Build customized dashboards to display GA data.
  • Automate complex reporting jobs.
  • Integrate with other applications.

[]You can access the API response utilizing a number of different techniques, including Java, PHP, and JavaScript, however this post, in particular, will focus on accessing and exporting information utilizing Python.

[]This article will simply cover a few of the techniques that can be used to access different subsets of information utilizing various metrics and dimensions.

[]I want to write a follow-up guide checking out different methods you can examine, visualize, and combine the data.

Establishing The API

Developing A Google Service Account

[]The first step is to create a project or choose one within your Google Service Account.

[]When this has been developed, the next action is to select the + Develop Service Account button.

Screenshot from Google Cloud, December 2022 You will then be promoted to add some information such as a name, ID, and description.< img src= "//"alt="Service Account Particulars"width="1152"height=" 1124"data-src=""/ > Screenshot from Google Cloud, December 2022 Once the service account has actually been produced, navigate to the secret area and include a new secret. Screenshot from Google Cloud, December 2022 [] This will trigger you to develop and download a private secret. In this circumstances, choose JSON, and after that create and

wait on 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 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 add that email []as a user in Google Analytics with Analyst permissions. Screenshot from Google Analytics, December 2022

Enabling The API The last and arguably crucial action is guaranteeing you have allowed access to the API. To do this, guarantee you are in the right job and follow this link to allow gain access to.

[]Then, follow the actions 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 finish 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 composing the []script to export the data. I chose Jupyter Notebooks to develop this, but you can likewise use other incorporated designer

[]environments(IDEs)consisting of PyCharm or VSCode. Installing Libraries The first step is to set up the libraries that are needed to run the rest of the code.

Some are distinct to the analytics API, and others work for future areas 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 connect Note: When using pip in a Jupyter notebook, add the!– if running in the command line or another IDE, the! isn’t required. Developing A Service Build 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 private secret. This

[]is utilized in a comparable method to an API secret. To easily access this file within your code, guarantee you

[]have saved the JSON file in the exact 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 Entirely

[]this will appear like the following. We will reference these functions throughout our code.

SCOPES = [‘’] KEY_FILE_LOCATION=’client_secrets. json’ VIEW_ID=’XXXXX’ []Once we have actually included our private crucial 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 currently defined qualifications from above.

credentials = ServiceAccountCredentials.from _ json_keyfile_name(KEY_FILE_LOCATION, SCOPES) service = build(‘analyticsreporting’, ‘v4’, credentials=qualifications)

Writing The Request Body

[]When we have whatever set up and defined, the real fun starts.

[]From the API service develop, there is the capability to select the components from the reaction that we want to gain access to. This is called a ReportRequest object and requires the following as a minimum:

  • A valid view ID for the viewId field.
  • At least one legitimate entry in the dateRanges field.
  • At least one legitimate entry in the metrics field.

[]View ID

[]As discussed, there are a couple of things that are needed during this construct stage, starting with our viewId. As we have actually already defined previously, we simply require to call that function name (VIEW_ID) rather than including the whole view ID once again.

[]If you wanted to collect data from a different analytics see in the future, you would simply need to change the ID in the initial code block instead of both.

[]Date Range

[]Then we can include the date range for the dates that we wish to collect the data for. This consists of a start date and an end date.

[]There are a couple of methods to write this within the develop demand.

[]You can select specified dates, for example, between two dates, by adding the date in a year-month-date format, ‘startDate’: ‘2022-10-27’, ‘endDate’: ‘2022-11-27’.

[]Or, if you want to see data 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 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 course, traffic source, and keywords used.

[]There are a lot of various metrics and dimensions that can be accessed. I won’t go through all of them in this post, but they can all be found together with extra details and associates here.

[]Anything you can access in Google Analytics you can access in the API. This includes objective conversions, begins and values, the internet browser gadget used 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, utilizing secret: value sets. For metrics, the key will be ‘expression’ followed by the colon (:-RRB- and then the value of our metric, which will have a particular 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 wished to see a count of all new users.

[]With dimensions, the key will be ‘name’ followed by the colon once again and the value of the measurement. For instance, if we wished to extract the various page paths, it would be ‘name’: ‘ga: pagePath’.

[]Or ‘name’: ‘ga: medium’ to see the different traffic source referrals to the site.

[]Integrating Measurements And Metrics

[]The real worth is in combining metrics and measurements to draw out the essential insights we are most thinking about.

[]For instance, to see a count of all sessions that have been produced from various traffic sources, we can set our metric to be ga: sessions and our dimension to be ga: medium.

reaction = service.reports(). batchGet( body= ). perform()

Producing A DataFrame

[]The reaction we get from the API remains in the kind of a dictionary, with all of the information in key: value sets. To make the information simpler to see and analyze, we can turn it into a Pandas dataframe.

[]To turn our action into a dataframe, we first need to develop some empty lists, to hold the metrics and dimensions.

[]Then, calling the response output, we will add the information from the measurements into the empty measurements list and a count of the metrics into the metrics list.

[]This will extract 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(‘dimensions’, [] dateRangeValues = row.get(‘metrics’, [] for header, measurement in zip(dimensionHeaders, dimensions): dim.append(measurement) for i, worths in enumerate(dateRangeValues): for metricHeader, worth in zip(metricHeaders, values.get(‘values’)): metric.append(int(value)) []Including The Response Data

[]As soon as the information is in those lists, we can quickly turn them into a dataframe by specifying 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= "" alt="DataFrame Example"/ > More Action Demand Examples Numerous Metrics There is likewise the capability to combine numerous metrics, with each pair included curly brackets and separated by a comma. ‘metrics’: [, “expression”: “ga: sessions”] Filtering []You can likewise request the API response only returns metrics that return particular criteria by including metric filters. It uses the following format:

if metricName comparisonValue return the metric []For instance, if you only wished to draw out pageviews with more than 10 views.

reaction = service.reports(). batchGet( body= ). carry out() []Filters also work for dimensions in a similar method, however the filter expressions will be slightly different due to the characteristic nature of dimensions.

[]For instance, if you only want to extract pageviews from users who have visited the website using the Chrome browser, you can set an EXTRACT operator and use ‘Chrome’ as the expression.

action = service.reports(). batchGet( body= ). carry out()


[]As metrics are quantitative measures, there is likewise the capability to write expressions, which work similarly to determined metrics.

[]This involves defining an alias to represent the expression and finishing a mathematical function on two metrics.

[]For example, you can calculate completions per user by dividing the number of conclusions by the variety of users.

action = service.reports(). batchGet( body= ‘reportRequests’: [] ). carry out()


[]The API likewise lets you container measurements with an integer (numerical) value into ranges utilizing pie chart containers.

[]For instance, bucketing the sessions count measurement into 4 containers of 1-9, 10-99, 100-199, and 200-399, you can utilize the HISTOGRAM_BUCKET order type and define the ranges in histogramBuckets.

action = service.reports(). batchGet( body= ). perform() Screenshot from author, December 2022 In Conclusion I hope this has supplied you with a standard guide to accessing the Google Analytics API, composing some different demands, and collecting some significant insights in an easy-to-view format. I have actually added the build and ask for code, and the snippets shared to this GitHub file. I will love 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