Pourquoi faire ?

Les MSV* (Monthly Search Volume) sont des données particulièrement précieuses pour les SEO. Ces MSV permettent souvent de donner une valeur à un mot clé. Aujourd’hui de nombreux outils fournissent cette information mais il sont généralement payants. Seul Ubersuggest propose un accès gratuit (mais limité) pour récupérer les volumes de recherche pour vos mots clés. Plutôt sympa avec Ubersuggest mais pour récupérer les volumes de recherches pour des centaines de mots clés, là ça se corse ! Alors comment faire ? Et bien il existe une solution en python qui consiste à requêter l’API Adwords

Pré-requis

Avoir un compte Adwords

Accédez simplement à votre compte administrateur, puis sélectionnez OUTILS ET PARAMÈTRES > CONFIGURATION > CENTRE D’API . Remplissez le formulaire et demandez votre jeton de développeur. Si vous avez déjà ce Jeton et bien conservez-le pour la suite.

Avoir un projet Google Cloud Platform.

Sur la page qui apparaît, vous devez copier l’ID client et le code secret client et les stocker pour la suite.

Avoir un Client ID client

L’identification finale dont nous avons besoin est l’ID client du compte Adwords. Il peut être trouvé à côté du nom du compte dans la plupart des endroits de l’interface Google Ads, par exemple le menu déroulant des comptes, au format xxx-xxx-xxxx. Sélectionnez le numéro correspondant à votre compte administrateur.

Le script décrit ci-dessous utilise ces informations d’identification pour demander un jeton d’accès au serveur d’autorisation Google. Ces jetons d’accès n’ont qu’une durée de vie limitée, donc si nous voulons pouvoir réutiliser le script à l’avenir, nous avons besoin d’un jeton d’actualisation. Ce jeton d’actualisation nous permet de renouveler notre jeton d’accès et nous permet donc d’envoyer d’autres demandes à l’API AdWords.

Comment générer un jeton d’actualisation

La façon la plus simple de générer notre jeton d’actualisation consiste à exécuter generate_refresh_token.py  (python 3+) à partir de la ligne de commande avec votre ID client et votre secret client comme arguments de ligne de commande comme ceci:

python generate_refresh_token.py --client_id INSERT_CLIENT_ID --client_secret INSERT_CLIENT_SECRET

Script Python pour récupérer les volumes de recherche pour une liste de mots clés

Ouvrez votre terminal et renseignez :

pip installer googleads pandas

Je charge les librairies nécessaires pour la suite :

import _locale
from pandas import DataFrame
import googleads
import pandas as pd
import traceback
from googleads import adwords
from googleads import oauth2

On s’assure que l’encodage soit bon

_locale._getdefaultlocale = (lambda * args: ['fr_FR', 'UTF-8'])

On charge un fichier csv listant des mots clés

keyword_list = pd.read_csv("xxxxx.csv")

Je transforme le dataframe en list

keyword_list = pd.DataFrame(keyword_list)
keyword_list = keyword_list['keyword'].to_list()
keyword_list

Il s’agit ici de lancer une fonction pour requêter l’API. Nous pouvons demander en masse le volume de recherche de centaines de mots clés en une seule demande d’API à la fois, nous allons donc diviser notre liste de mots clés en sous-listes de 700 mots clés. Cela réduit le nombre d’appels d’API nécessaires, accélère donc massivement le script et réduit considérablement les chances de renvoyer une erreur “ RateLimitExceeded ”.

class searchVolumePuller():
      def __init__(self,client_ID,client_secret,refresh_token,developer_token,client_customer_id):
            self.client_ID = client_ID
            self.client_secret = client_secret
            self.refresh_token = refresh_token
            self.developer_token = developer_token
            self.client_customer_id = client_customer_id
            
      def get_client(self):
          access_token = oauth2.GoogleRefreshTokenClient(self.client_ID,
                                                         self.client_secret,
                                                         self.refresh_token)
          adwords_client = adwords.AdWordsClient(self.developer_token,
                                                 access_token,
                                                 client_customer_id = self.client_customer_id,
                                                 cache=googleads.common.ZeepServiceProxy.NO_CACHE)
 
          return adwords_client
      
      def get_service(self,service,client):
 
          return client.GetService(service)

      def get_search_volume(self,service_client,keyword_list):
            #empty dataframe to append data into and keywords and search volume lists#
            keywords = []
            search_volume = []
            keywords_and_search_volume = pd.DataFrame()
            #need to split data into lists of 700#
            sublists = [keyword_list[x:x+700] for x in range(0,len(keyword_list),700)]
            for sublist in sublists:
                  # Construct selector and get keyword stats.
                  selector = {
                  'ideaType': 'KEYWORD',
                  'requestType' : 'STATS'
                    }
                    
                  #select attributes we want to retrieve#
                  selector['requestedAttributeTypes'] = [
                    'KEYWORD_TEXT',
                    'SEARCH_VOLUME'
                    ]
                    
                  #configure selectors paging limit to limit number of results#
                  offset = 0
                  selector['paging'] = {
                  'startIndex' : str(offset),
                  'numberResults' : str(len(sublist))
                        }
                    
                  #specify selectors keywords to suggest for#
                  selector['searchParameters'] = [{
                  'xsi_type' : 'RelatedToQuerySearchParameter',
                  'queries' : sublist
                        }]
                  
                  #pull the data#
                  page = service_client.get(selector)
                  #access json elements to return the suggestions#
                  for i in range(0,len(page['entries'])):
                        keywords.append(page['entries'][i]['data'][0]['value']['value'])
                        search_volume.append(page['entries'][i]['data'][1]['value']['value'])
                        
            keywords_and_search_volume['Keywords'] = keywords
            keywords_and_search_volume['Search Volume'] = search_volume
            
            return keywords_and_search_volume

Il ne vous reste plus qu’à renseigner : CLIENT_ID / CLIENT_SECRET / REFRESH_TOKEN / DEVELOPER_TOKEN / CLIENT_CUSTOMER_ID

if __name__ == '__main__':
     CLIENT_ID = 'YOUR-CLIENT-ID'
     CLIENT_SECRET = 'YOUR-CLIENT-SECRET'
     REFRESH_TOKEN = 'YOUR_REFRESH_TOKEN'
     DEVELOPER_TOKEN = 'YOUR-DEVELOPER-TOKEN'
     CLIENT_CUSTOMER_ID = 'YOUR-CLIENT-CUSTOMER-ID'
    

     volume_puller = searchVolumePuller(CLIENT_ID,
                                        CLIENT_SECRET,
                                        REFRESH_TOKEN,
                                        DEVELOPER_TOKEN,
                                        CLIENT_CUSTOMER_ID)

     adwords_client = volume_puller.get_client()
            
            
     targeting_service = volume_puller.get_service('TargetingIdeaService', adwords_client)

     kw_sv_df = volume_puller.get_search_volume(targeting_service,keyword_list)

Regardons le résultat …

kw_sv_df

Exporter la liste dans un fichier CSV

kw_sv_df.to_csv('demenagement_msv.csv', index = False)