How To Gain Access To Google Analytics API Via Python

Posted by

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

[]The main Google paperwork explains that it can be utilized to:

  • Develop customized control panels to display GA information.
  • Automate complex reporting tasks.
  • Integrate with other applications.

[]You can access the API reaction utilizing numerous different approaches, consisting of Java, PHP, and JavaScript, however this post, in specific, will focus on accessing and exporting information utilizing Python.

[]This post will just cover a few of the approaches that can be utilized to access various subsets of information utilizing various metrics and dimensions.

[]I hope to compose a follow-up guide checking out different methods you can evaluate, picture, and integrate the data.

Setting Up The API

Creating A Google Service Account

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

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

Screenshot from Google Cloud, December 2022 You will then be promoted to include some information such as a name, ID, and description.< img src= "//"alt="Service Account Details"width="1152"height=" 1124"data-src=""/ > Screenshot from Google Cloud, December 2022 Once the service account has actually been produced, browse to the KEYS section and add a brand-new secret. Screenshot from Google Cloud, December 2022 [] This will prompt you to develop and download a private key. In this circumstances, choose JSON, and after that create 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 e-mail that has been produced for the service account– this can be found on the main account page.

Screenshot from Google Cloud, December 2022 The next step is to include that email []as a user in Google Analytics with Expert permissions. Screenshot from Google Analytics, December 2022

Allowing The API The last and arguably essential action is ensuring you have enabled access to the API. To do this, ensure you are in the correct job 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 action, you will be triggered 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 picked Jupyter Notebooks to develop this, but you can also utilize other incorporated developer

[]environments(IDEs)including PyCharm or VSCode. Putting up Libraries The initial 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 set up– upgrade google-api-python-client! pip3 set up– upgrade oauth2client from apiclient.discovery import build from oauth2client.service _ account import ServiceAccountCredentials! pip set up link! pip install functions import link Note: When utilizing pip in a Jupyter notebook, add the!– if running in the command line or another IDE, the! isn’t required. 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 tricks JSON download that was generated when creating the personal key. This

[]is utilized in a similar method to an API key. To quickly access this file within your code, guarantee you

[]have actually saved the JSON file in the same folder as the code file. This can then quickly be called with the KEY_FILE_LOCATION function.

[]Lastly, include the view ID from the analytics account with which you wish to access the data. Screenshot from author, December 2022 Altogether

[]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 essential file, we can include this to the qualifications 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 credentials from above.

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

Composing The Request Body

[]Once we have whatever set up and defined, the genuine enjoyable starts.

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

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

[]View ID

[]As pointed out, there are a couple of things that are required during this develop stage, starting with our viewId. As we have already specified formerly, we simply need to call that function name (VIEW_ID) instead of including the entire view ID once again.

[]If you wanted to gather information from a different analytics view in the future, you would just require to alter the ID in the initial code block rather than both.

[]Date Range

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

[]There are a number of ways to compose this within the build demand.

[]You can select specified 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 view 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 action of the fundamental reaction call is setting the metrics and measurements. Metrics are the quantitative measurements from Google Analytics, such as session count, session duration, and bounce rate.

[]Measurements are the attributes of users, their sessions, and their actions. For example, page course, traffic source, and keywords utilized.

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

[]Anything you can access in Google Analytics you can access in the API. This includes objective conversions, starts and values, the browser device utilized to access the site, landing page, second-page path tracking, and internal search, website speed, and audience metrics.

[]Both the metrics and dimensions are included a dictionary format, utilizing secret: worth pairs. For metrics, the secret will be ‘expression’ followed by the colon (:-RRB- and after that the worth of our metric, which will have a specific format.

[]For instance, 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 measurements, the secret will be ‘name’ followed by the colon once again and the value of the dimension. For example, if we wished to extract the various page paths, it would be ‘name’: ‘ga: pagePath’.

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

[]Integrating Dimensions And Metrics

[]The real value is in integrating metrics and dimensions to draw out the crucial insights we are most thinking about.

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

response = service.reports(). batchGet( body= ). execute()

Producing A DataFrame

[]The action we get from the API is in the kind of a dictionary, with all of the information in key: value sets. To make the data much easier to view and evaluate, we can turn it into a Pandas dataframe.

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

[]Then, calling the action output, we will add the information from the dimensions 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 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(‘data’, ). get(‘rows’, [] for row in rows: dimensions = row.get(‘dimensions’, [] dateRangeValues = row.get(‘metrics’, [] for header, measurement in zip(dimensionHeaders, dimensions): dim.append(dimension) for i, values in enumerate(dateRangeValues): for metricHeader, value in zip(metricHeaders, values.get(‘values’)): metric.append(int(worth)) []Adding The Action Data

[]Once the data remains in those lists, we can quickly turn them into a dataframe by specifying the column names, in square brackets, and assigning the list values to each column.

df = pd.DataFrame() df [” Sessions”] = metric df [” Medium”] = dim df= df [[ “Medium”,”Sessions”]] df.head()

< img src= "" alt="DataFrame Example"/ > More Response Demand Examples Several Metrics There is likewise the ability to integrate several metrics, with each pair added in curly brackets and separated by a comma. ‘metrics’: [“expression”: “ga: pageviews”, “expression”: “ga: sessions”] Filtering []You can likewise request the API response only returns metrics that return specific requirements by including metric filters. It utilizes the following format:

if metricName return the metric []For example, if you just wanted to extract pageviews with more than 10 views.

response = service.reports(). batchGet( body= ‘reportRequests’: [] ). execute() []Filters also work for measurements in a similar method, but the filter expressions will be a little different due to the characteristic nature of measurements.

[]For example, if you only wish to draw out pageviews from users who have actually gone to the site using the Chrome internet browser, you can set an EXTRACT operator and use ‘Chrome’ as the expression.

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


[]As metrics are quantitative steps, there is also the capability to write expressions, which work similarly to computed metrics.

[]This includes specifying an alias to represent the expression and completing a mathematical function on 2 metrics.

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

action = service.reports(). batchGet( body= ). execute()


[]The API also lets you container measurements with an integer (numeric) value into ranges utilizing histogram pails.

[]For instance, 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.

response = service.reports(). batchGet( body= ). carry out() Screenshot from author, December 2022 In Conclusion I hope this has actually provided you with a basic guide to accessing the Google Analytics API, composing some various demands, and gathering some significant insights in an easy-to-view format. I have actually added the construct and request code, and the snippets shared to this GitHub file. I will enjoy to hear if you attempt any of these and your plans for exploring []the information further. More resources: Included Image: BestForBest/Best SMM Panel