{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Access Search Console Data via Python\n", "> Google's Search Console has come a long way, but there are still times when exploring that data in Python can be particularly useful. This post will show how to download your Google Search Console data via Python.\n", "\n", "- toc: false\n", "- branch: master\n", "- badges: true\n", "- categories: [apis,seo,pandas,jupyter]\n", "- hide: false\n", "- search_exclude: false" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "If this is your first time accessing data from a Google API, there's a lot of setup to be done:\n", "1. Create a project in Google's [Developer Console](https://console.developers.google.com)\n", "2. Enable the API(s) you want to use\n", "3. Create the consent screen\n", "4. Create and download the OAuth credentials\n", "5. Run the script\n", "\n", "In this tutorial I'll assume you're running the code from your own computer." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Lots of Clicking First\n", "\n", "There's a lot of steps to get done before actually getting to the code. Since I've found myself having to do this every other year, I figured it'd be good to leave step-by-step notes (screenshots included!).\n", "\n", "First, you need to login to [Developer Console](https://console.developers.google.com) and create a project:\n", "\n", "![Login to Developer Console and create a project](../images/search_console/01_create_project.png)\n", "\n", "\n", "If you haven't already, create a new project:\n", "\n", "![Create a new project](../images/search_console/02_new_project.png)\n", "\n", "Name the project:\n", "\n", "![Name the project](../images/search_console/03_name_project.png)\n", "\n", "You'll need to find the specific API you want to enable. I've gotten lost trying to find which button will take you to the API library, so [here's the link instead](https://console.developers.google.com/apis/library). When you've found the API you're looking for, click the `Enable` button. While you're at it, you may want to search for and enable others(such as the [Google Analytics Reporting API](https://developers.google.com/analytics/devguides/reporting/core/v4) or the [Youtube Reporting API](https://developers.google.com/youtube/reporting/v1/reports)) since you can add multiple APIs, or scopes, to one credential:\n", "\n", "![Enable the Search Console API](../images/search_console/05_enable_api.png)\n", "\n", "Since I'll be demonstrating an Oauth verification flow, you'll need to create a consent screen:\n", "\n", "![Create a consent screen](../images/search_console/06_consent_screen.png)\n", "\n", "There's a dozen fields or so, but only one field in particular matters: the application name. Give it some generic name (but make sure not to include anything related to Google in the name field). You can scoll down to the bottom of the screen and click the Save button.\n", "\n", "![Name the screen](../images/search_console/07_name_the_screen.png)\n", "\n", "Almost there. Create the credentials; I've selected the OAuth option.\n", "\n", "![Create your credentials](../images/search_console/08_create_creds.png)\n", "\n", "Again, create a generic name, this time for the credentials themselves. One really, really important note: when I use Jupyter Lab on my Macbook Pro, when it starts up I get a notice that port `8888` is already in use, so instead it moves to port `8889`...you'll need to specifiy an unused port here in the \"Authorized redirect URIs\" _and_ remember the port because you'll use it again in the code below. In my case, port `8080` works:\n", "\n", "![Name the credentials](../images/search_console/09_name_creds.png)\n", "\n", "Now download the client secrets, and rename to `client_secrets.json` and move the file to the folder you'll access in the code.\n", "\n", "![Download the credentials](../images/search_console/10_download_creds.png)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "That marks the end of clicking around in Developer Console. However, note that the first time you run this script you'll have to authorize the script to access your data. Make I'll be using the account for my blog below.\n", "\n", "There's a whole suite of Google libraries you'll need to install to make sure the script runs:\n", "* [Google's Python API client](https://github.com/googleapis/google-api-python-client)\n", "* [Google Auth](https://google-auth.readthedocs.io/en/latest/index.html)\n", "* Google's [OAuth integration](https://google-auth-oauthlib.readthedocs.io/en/latest/index.html) with the Google Auth library\n", "\n", "Finally, I've found the [Progress](https://pypi.org/project/progress/) library a fun way to keep track of how far the script has progressed." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import os\n", "import json\n", "import time\n", "import glob\n", "import pickle\n", "import random\n", "import pandas as pd\n", "from pandas import Series, DataFrame\n", "from progress.bar import IncrementalBar\n", "\n", "# these are just for authenticating\n", "import google.oauth2.credentials\n", "from google_auth_oauthlib.flow import Flow\n", "from google_auth_oauthlib.flow import InstalledAppFlow\n", "from google.auth.transport.requests import Request\n", "\n", "# this actually helps access the API\n", "from apiclient.discovery import build" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "PROPERTY_URI = 'http://measureallthethin.gs/'\n", "\n", "OUTPUT_PATH = '../output/search_console_data/'\n", "SECRETS_PATH = '../secrets/'\n", "CLIENT_SECRETS = SECRETS_PATH + 'client_secrets.json'\n", "\n", "# notice you can add multiple apis to the credential created earlier :-) \n", "SCOPES = ['https://www.googleapis.com/auth/webmasters.readonly','https://www.googleapis.com/auth/analytics.readonly']" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Probably the most painful part of interfacing with Google's APIs is the fact that every two years the process changes. I spent a whole day and a half trying to figure out how to use the new [Google Auth library](https://google-auth.readthedocs.io/en/latest/index.html) since some of the older libraries have been deprecated. I finally found a great example from the Google Docs team [here](https://github.com/gsuitedevs/python-samples/blob/master/docs/quickstart/quickstart.py) that shows how to easily authenticate from your notebook or command line." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "def prepare_credentials():\n", " creds = None\n", " # the file token.pickle stores the user's access and refresh tokens, and is\n", " # created automatically when the authorization flow completes for the first\n", " # time.\n", " if os.path.exists(SECRETS_PATH + 'token.pickle'):\n", " with open(SECRETS_PATH + 'token.pickle', 'rb') as token:\n", " creds = pickle.load(token)\n", " # if there are no (valid) credentials available, let the user log in\n", " if not creds or not creds.valid:\n", " if creds and creds.expired and creds.refresh_token:\n", " creds.refresh(Request())\n", " else:\n", " flow = InstalledAppFlow.from_client_secrets_file(CLIENT_SECRETS, SCOPES)\n", " creds = flow.run_local_server(port=8080) # remember that port you put into the credentials? use that here in port param\n", " # save the credentials for the next run\n", " with open(SECRETS_PATH + 'token.pickle', 'wb') as token:\n", " pickle.dump(creds, token)\n", " return creds" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "As shown above, multiple APIs can be accessed from one project/set of credentials. I access the Google Analytics API frequently, so below is a quick example showing how to be ready for accessing different endpoints." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "def initialize_service(service='batch'):\n", " \"\"\"\n", " Returns a connection to the Google Analytics v4 API\n", " https://developers.google.com/analytics/devguides/reporting/core/v4/rest/\n", " --OR--\n", " Returns the Webmaster Service Object\n", " https://developers.google.com/webmaster-tools/search-console-api-original/v3/searchanalytics/query\n", " \"\"\"\n", " # make sure your authorized to access API first\n", " credentials = prepare_credentials()\n", " \n", " # build and return the service object\n", " if service == 'batch':\n", " return build('analyticsreporting',\n", " 'v4',\n", " credentials = credentials,\n", " discoveryServiceUrl='https://analyticsreporting.googleapis.com/$discovery/rest?version=v4')\n", " elif service == 'user_activty':\n", " return build('analyticsreporting',\n", " 'v4',\n", " credentials = credentials,\n", " discoveryServiceUrl='https://analyticsreporting.googleapis.com/v4/userActivity:search')\n", " elif service == 'webmaster':\n", " return build('webmasters',\n", " 'v3',\n", " credentials = credentials)\n", " else:\n", " raise Exception('Please select an endpoint!')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Typically I do not save the data to a variable but instead save it to disk so I can explore further in a notebook:" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "# save JSON of each day's/query's results\n", "def file_to_save(start,end,file_info):\n", " return OUTPUT_PATH + '{0}_{1}_{2}.json'.format(start,end,'_'.join(file_info))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Google loves, _loves_ returning nested JSON, which can be difficult to deal with in Pandas; this function makes it a bit easier to manage." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "# \"flatten\" response a bit so it's easier to convert into a dataframe\n", "def tidy_the_nest(dims,results):\n", " for item in results:\n", " for row in item['rows']:\n", " row.update(dict(zip(dims,row['keys'])))\n", " return results" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Ok, now the for a monster of a function. I've tried commenting inline as much as possible the clarify the pieces, but overall the gist is that the request sent to Google needs to account for 1) the dimensions you want in the data (such as date, search keyword, etc), and 2) a recursive element based on whether or not Google has returned all the rows available to download." ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "# accepts a list of dimensions by which to query the webmaster api, start and end dates, a collection of data, and integer to increment\n", "def execute_request(dims,start,end,results=None,i=0):\n", " # saw that get_search_data([\"date\",\"query\"],date_range) was only returning 5k rows...\n", " # turns out when adding in keywords that is the max rows search console will return\n", " # max_rows = 5000\n", " max_rows = 25000\n", " if results is None:\n", " results = []\n", " # create a dict of what exactly we want to query\n", " # https://developers.google.com/webmaster-tools/search-console-api-original/v3/searchanalytics/query\n", " payload = {\n", " \"startDate\": start, # [Required] Start date of the requested date range, in YYYY-MM-DD format, in PST time (UTC - 8:00)\n", " \"endDate\": end, # [Required] End date of the requested date range, in YYYY-MM-DD format, in PST time (UTC - 8:00)\n", " \"dimensions\": dims, # \"country\", \"device\", \"page\", \"query\", \"searchAppearance\":\n", " # https://developers.google.com/webmaster-tools/search-console-api-original/v3/how-tos/all-your-data#overview\n", " \"rowLimit\": max_rows, # [Optional; Valid range is 1–25,000; Default is 1,000] The maximum number of rows to return. To page through results, use the startRow offset.\n", " \"startRow\": i * max_rows # [Optional; Default is 0] Zero-based index of the first row in the response. Must be a non-negative number. If startRow exceeds the number of results for the query, the response will be a successful response with zero rows.\n", " }\n", " # now execute the query and save response\n", " data = service.searchanalytics().query(siteUrl=PROPERTY_URI, body=payload).execute()\n", " # max rows is 25000, so need to make sure we didn't leave any data behind\n", " if 'rows' in data:\n", " results.append(data)\n", " num_of_rows = len(data['rows'])\n", " ### print('Aggregation {0}'.format(data['responseAggregationType']))\n", " ### print(json.dumps(data['rows'][0:2], sort_keys=True,indent=4, separators=(',', ': ')))\n", " else:\n", " num_of_rows = 0\n", " ### print(\"Grabbed {0} rows for loop {1}\".format(num_of_rows,str(i+1)))\n", " # get all the data by essentially paginating through results until none are left\n", " # https://developers.google.com/webmaster-tools/search-console-api-original/v3/how-tos/all-your-data\n", " # important to note this from the documentation:\n", " # Why do I lose data when asking for more detail?\n", " # When you group by page and/or query, our system may drop some data in order to be able to calculate results in a reasonable time using a reasonable amount of computing resources.\n", " # more about data can be found here https://support.google.com/webmasters/answer/6155685\n", " if num_of_rows == max_rows:\n", " time.sleep(1 + random.random())\n", " i += 1\n", " return execute_request(dims,start,end,results=results,i=i)\n", " else:\n", " tidy_the_nest(dims,results)\n", " # save the json response because error handling not yet in place\n", " with open(file_to_save(start,end,dims), 'w') as fp:\n", " json.dump(results, fp)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Below is essentially a for loop that gets each day of data from a date range and helps keep track of your progress." ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [], "source": [ "def get_search_data(dims,dates,n):\n", " \"\"\"\n", " dims: list of dimensions to include in query\n", " dates: date range of type pandas.core.indexes.datetimes.DatetimeIndex\n", " n: string specifying progress of queries to API (e.g., '3 of 5', '4 of 5', '5 of 5')\n", " \"\"\"\n", " # still figuring out how to make Progress bar work in notebooks (this works fine in iTerm...)\n", " # bar = IncrementalBar('Query {0}: {1}'.format(n,', '.join(dims)), max=len(dates))\n", " for i in dates:\n", " date_to_get = '{0}'.format(i.strftime('%Y-%m-%d'))\n", " time.sleep(1 + random.random())\n", " # since we are downloading data day by day, start and end dates are the same\n", " # if you want a range of dates, skip this function and use execute_request() directly\n", " execute_request(dims,date_to_get,date_to_get)\n", " # bar.next()\n", " # bar.finish()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "> Important: This will kickoff the process to authorize as well as build the service object with which you can interact with the API. It will print a URL, but should redirect you to that URL automagically. It's more seemless if you are also logged in to the Google profile in your default browser that you want to authorize." ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "# you should only have to authorize on the first time running this line\n", "service = initialize_service(service = 'webmaster')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "As mentioned above, you should automatically get redirected and see a screen like this. Since I am running Jupyter in regular `http` rather than `https` I got the scary red triangle and had to press the \"continue anyways\" button...\n", "\n", "![Download the credentials](../images/search_console/11_authorize.png)\n", "\n", "Make sure you have the right list of APIs here:\n", "\n", "![Download the credentials](../images/search_console/12_accept.png)\n", "\n", "This will let you know you're done:\n", "\n", "![Download the credentials](../images/search_console/13_done.png)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now to finally start getting data! First, set a time range you want to query. I run this script monthly and so use a lazy way of getting one month at a time." ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Timestamp('2020-01-31 00:00:00')" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# not strictly necessary to use pandas to convert to timestamp, but helpful to do so in order to get last day of month\n", "start_of_month = '2020-01-01'\n", "end_of_month = pd.to_datetime(start_of_month).to_period('M').to_timestamp('M')\n", "end_of_month" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "# convert start and end dates to date range using Pandas\n", "date_range = pd.date_range(start_of_month,end_of_month,freq='D',normalize=True)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now that there's a date range to work with, query the API :smiley:" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "# now start getting the data and saving the JSON files\n", "# more example queries can be found here: https://developers.google.com/webmaster-tools/search-console-api-original/v3/how-tos/search_analytics\n", "# and there are a few more examples below\n", "execute_request([\"date\"],date_range.min().strftime('%Y-%m-%d'),date_range.max().strftime('%Y-%m-%d'))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "You could modify the `execute_request` function above to just `return` the JSON directly, but since I find myself running this script once a month to download the previous month's data, I have my own workflow where I just assume I'm going to combine the output from all the previous months." ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "def read_json_files(path_to_file):\n", " with open(path_to_file) as p:\n", " data = json.load(p)\n", " return DataFrame.from_dict(data[0]['rows']) " ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['../output/search_console_data/2019-11-01_2019-11-30_date.json',\n", " '../output/search_console_data/2020-01-01_2020-01-31_date.json']" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# i've already download some other months of data besides january, which are shown here\n", "data_files = glob.glob(OUTPUT_PATH + '*_date.json')\n", "data_files[:2]" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
clicksimpressionsctrpositiondate
04.072.00.05555628.9305562019-11-01
10.038.00.00000040.2631582019-11-02
20.041.00.00000039.3902442019-11-03
32.069.00.02898624.8985512019-11-04
45.090.00.05555630.4666672019-11-05
\n", "
" ], "text/plain": [ " clicks impressions ctr position date\n", "0 4.0 72.0 0.055556 28.930556 2019-11-01\n", "1 0.0 38.0 0.000000 40.263158 2019-11-02\n", "2 0.0 41.0 0.000000 39.390244 2019-11-03\n", "3 2.0 69.0 0.028986 24.898551 2019-11-04\n", "4 5.0 90.0 0.055556 30.466667 2019-11-05" ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# nice trick from a data science colleague to read in multiple files at once into one dataframe\n", "df = pd.concat([read_json_files(f) for f in data_files], ignore_index=True)\n", "df = df.drop(['keys'],axis=1)\n", "df.head()" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "RangeIndex: 123 entries, 0 to 122\n", "Data columns (total 5 columns):\n", " # Column Non-Null Count Dtype \n", "--- ------ -------------- ----- \n", " 0 clicks 123 non-null float64 \n", " 1 impressions 123 non-null float64 \n", " 2 ctr 123 non-null float64 \n", " 3 position 123 non-null float64 \n", " 4 date 123 non-null datetime64[ns]\n", "dtypes: datetime64[ns](1), float64(4)\n", "memory usage: 4.9 KB\n" ] } ], "source": [ "df['date'] = pd.to_datetime(df['date'],format='%Y-%m-%d')\n", "df.info()" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 17, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "df.set_index('date')['clicks'].plot()" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "df.groupby([pd.Grouper(key='date',freq='MS')])['clicks'].sum().plot(marker='o',ylim=0);" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Here are some more examples of the type of queries I run. Generally, the more granular the less data you get; so I run through a few permutations just to get as much info as I can. With a small blog like this, it doesn't really matter, whereas at work millions of visitors a month can really add up to a lot of rows here..." ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [], "source": [ "get_search_data([\"date\",\"query\",\"page\"],date_range,'1 of 2')\n", "get_search_data([\"date\",\"query\",\"page\",\"device\",\"country\"],date_range,'2 of 2')" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.8.2" } }, "nbformat": 4, "nbformat_minor": 4 }