Sélectionner une page
Tracez et suivez les tendances de recherche Google dans Data Studio avec Python

Tracez et suivez les tendances de recherche Google dans Data Studio avec Python

Identifier les tendances d’un marché est un enjeu majeur pour la plupart des acteurs dans le monde du commerce. Aujourd’hui, l’un des outils les plus efficaces reste Google Trends. Trop souvent sous-estimé, cet outil est pourtant particulièrement riche en information. Le problème ? Comment rendre scalable la récupération et l’analyse des données issues de Google Trends ?

Nous avions vu précédemment comment exploiter récupérer les données Google Trends avec R. Voyons désormais comment nous pouvons aller plus loin avec Python.

En utilisant les codes de cet article, vous serez en mesure de :

  • Récupérer les données Google trend avec python
  • Créer automatiquement un google spreadsheet avec python
  • Afficher la donnée dans Google data studio
  • Créer un Cron pour exécuter le script tous les jours à la même heure

Passons aux choses sérieuses …

Tout d’abord, vous devez installer la bibliothèque:

pip install pytrends

Installons les librairies nécessaires pour la suite

import pytrends
from pytrends.request import TrendReq
import pandas as pd
import time
import datetime
from datetime import datetime, date, time
import pandas as pd
from pandas import DataFrame
#https://searchengineland.com/learn-how-to-chart-and-track-google-trends-in-data-studio-using-python-329119
pytrend = TrendReq()

Je récupère les « related queries » qui sont en mode « rising »

Dans l’exemple ci-dessous nous allons récupérer les mots clés relatif à « Jardin », « Tondeuse » et « Decoration » pour la France sur les 3 derniers mois.

NB : Il est possible de sélectionner une catégorie spécifique pour sa requête. Ici dans l’exemple, j’ai renseigné « cat=11 » car il s’agit de la catégorie « Home Garden »

Afin de voir toutes les fonctionnalités et les filtres, vous devriez vérifier ce référentiel sur Github et vous pouvez également trouver tous les codes de catégorie ici .

pytrend.build_payload(kw_list=['jardin','tondeuse','decoration'], geo = 'FR', timeframe = 'today 3-m', cat = 11)
related_queries= pytrend.related_queries()
jardin =related_queries.get('jardin').get('rising')
tondeuse =related_queries.get('tondeuse').get('rising')
decoration =related_queries.get('decoration').get('rising')

On récupère ici une bibliothèque avec les « tops » requêtes mais ici ce sont les « rising » requêtes qui nous intéressent

Les données sont là, plutôt cool non ? Bon par contre ce n’est pas encore terminé. Ajoutons maintenant une colonne avec la thématique associée à chaque query. Il ne reste plus qu’à concaténer les résultats :

maison['theme'] = 'maison' 
jardin['theme'] = 'jardin' 
bricolage['theme'] = 'bricolage' 
decoration['theme'] = 'decoration' 
result = pd.concat([maison,jardin,bricolage,decoration], axis=0)
Pour chaque query je sais à quelle thématique elle est associée

Comment envoyer la donnée directement dans un Googlesheet ?

Si vous souhaitez simplement exporter la donnée dans un fichier excel, vous pouvez vous arrêter là. La suite vise à envoyer automatiquement la donnée dans un Google sheet pour ensuite alimenter une Google Data Studio. C’est parti ! Mais avant toute chose, voici le pré-requis avant de lancer la suite du code :

Activer l’API Google Sheet et récupérer votre ID client et votre code secret client. Pour cela, suivez les étapes suivantes :

  1. Rendez-vous ici
  2. Créer un projet si vous n’en n’avez pas un sur Google cloud platform
  3. Cliquez sur « Bibliothèque » dans le menu
  4. Recherchez « Google sheet API » et cliquez sur le logo
  5. Cliquez sur « Activez »
  6. Cliquez sur « Identifiants » dans le menu
  7. Cliquez sur « créer des identifiants » (en haut de l’écran) et sur « ID client OAuth »
  8. Choisissez « Autre », renseigner un nom puis cliquez sur « Créer »
  9. Insérez votre code client et ID client dans le code ci-dessous

Créer un Google sheet et récupérer l’ID de ce dernier

  1. Créer un Google sheet
  2. Cliquez sur « partager » en haut à droite
  3. Copier le lien de partage
  4. Récupérer dans l’url, l’ID de votre Google Sheet (exemple : »1l7UEMs2Qv-YE96jAxYkvg9KAumYq3dYk0nlmG62g_-4″ )
  5. Insérer cet ID dans le code ci-dessous à la place de « my_google-sheet-id »

Télécharger le fichier Json

  1. Dans votre espace Google Cloud Platform, cliquez sur « identifiants »
  2. Téléchargez le fichier Json
  3. Déplacez le fichier Json dans le dossier où se trouve le script

Voici le code pour se connecter à votre Google sheet

Avant de lancer le code, vérifier que vous avez remplacer :

  • my_google-sheet-id >> l’ID de votre Google sheet
  • nom_du_fichier_json >> Le nom du fichier Json que vous avez téléchargé précédemment
import gspread as gc
from oauth2client.service_account import ServiceAccountCredentials
import pandas as pd
from googleapiclient.discovery import build
from google_auth_oauthlib.flow import InstalledAppFlow,Flow
from google.auth.transport.requests import Request
import os
import pickle

SCOPES = ['https://www.googleapis.com/auth/spreadsheets']
# here enter the id of your google sheet
SAMPLE_SPREADSHEET_ID_input = 'my_google-sheet-id'
SAMPLE_RANGE_NAME = 'A1:AA1000'
def main():
    global values_input, service
    creds = None
    if os.path.exists('token.pickle'):
        with open('token.pickle', 'rb') as token:
            creds = pickle.load(token)
    if not creds or not creds.valid:
        if creds and creds.expired and creds.refresh_token:
            creds.refresh(Request())
        else:
            flow = InstalledAppFlow.from_client_secrets_file('nom_du_fichier_json', SCOPES) # here enter the name of your downloaded JSON file
            creds = flow.run_local_server(port=0)
        with open('token.pickle', 'wb') as token:
            pickle.dump(creds, token)

    service = build('sheets', 'v4', credentials=creds)

    # Call the Sheets API
    sheet = service.spreadsheets()
    result_input = sheet.values().get(spreadsheetId=SAMPLE_SPREADSHEET_ID_input,
                                range=SAMPLE_RANGE_NAME).execute()
    values_input = result_input.get('values', [])

    if not values_input and not values_expansion:
        print('No data found.')

main()

df=pd.DataFrame(values_input[1:], columns=values_input[0])
#change this by your sheet ID
SAMPLE_SPREADSHEET_ID_input = 'my_google-sheet-id'

#change the range if needed
SAMPLE_RANGE_NAME = 'A1:AA1000'

def Create_Service(client_secret_file, api_service_name, api_version, *scopes):
    global service
    SCOPES = [scope for scope in scopes[0]]
    #print(SCOPES)
    
    cred = None

    if os.path.exists('token_write.pickle'):
        with open('token_write.pickle', 'rb') as token:
            cred = pickle.load(token)

    if not cred or not cred.valid:
        if cred and cred.expired and cred.refresh_token:
            cred.refresh(Request())
        else:
            flow = InstalledAppFlow.from_client_secrets_file('nom_du_fichier_json', SCOPES)
            cred = flow.run_local_server()

        with open('token_write.pickle', 'wb') as token:
            pickle.dump(cred, token)

    try:
        service = build(api_service_name, api_version, credentials=cred)
        print(api_service_name, 'service created successfully')
        #return service
    except Exception as e:
        print(e)
        #return None
        
# change 'my_json_file.json' by your downloaded JSON file.
Create_Service('nom_du_fichier_json', 'sheets', 'v4',['https://www.googleapis.com/auth/spreadsheets'])
    
def Export_Data_To_Sheets():
    response_date = service.spreadsheets().values().update(
        spreadsheetId="my_google-sheet-id",
        valueInputOption='RAW',
        range=SAMPLE_RANGE_NAME,
        body=dict(
            majorDimension='ROWS',
            values=result.T.reset_index().T.values.tolist())
    ).execute()
    print('Sheet successfully Updated')

Export_Data_To_Sheets()
Et voilà les données sont directement envoyées dans Google Sheet ! 😎

Il ne vous reste plus qu’à créer un Google Data studio

Voici les étapes :

  1. Connectez-vous à Data studio
  2. Créer un nouveau rapport vierge
  3. Cliquez « ajouter des données »
  4. Sélectionnez « Google sheets »
  5. Cherchez et ajoutez le fichier que vous avez créé et alimenté automatiquement avec python
  6. Cliquez sur Ajouter un graphique puis un tableau
  7. Configurer votre tableau comme ceci :
Crawler un site web et extraire des données avec R

Crawler un site web et extraire des données avec R

Possible de crawler sans budget ? Oui avec RCrawler !

Crawler et scraper des données est devenu une pratique incontournable pour les SEO depuis plusieurs années. Des solutions payantes existent comme par exemple Screaming Frog, Oncrawl, Botify ou encore Seolyzer. Pour ceux et celles qui n’ont les budgets pour passer sur de telles plateformes, il existe des solutions qui s’appuient sur des languages de programmation comme python ou encore R.

Dans cet article, je vais vous expliquer comment crawler gratuitement en exploiter le package RCrawler. Nous verrons comment configurer les informations à scraper et comment organiser la donnée de sorte qu’elle soit exploitable par la suite. RCrawler est un package très intéressant car nativement il embarque de nombreuses fonctionnalités comme le stockage des fichiers HTML (vous n’aurez pas à re-crawler si vous avez oublié de récupérer des informations) ou encore le crawl en mode headless browser, particulièrement apprécié pour des sites conçus sur des framework Angular ou React.

RCrawler nous y voilà !

# define you setwd()
setwd("/path/")

# install to be run once
install.packages("Rcrawler")

# and loading
library(Rcrawler)


# what we want to extract
CustomLabels <- c("title",
                  "Meta_description",
                  "h1",
                  "h2",
                  "h3",
                  "Hreflang",
                  "canonical_tag",
                  "meta_robots"
                  )

# How to grab it, do not hesitate to add other stuff you want to grab by adding xpath
CustomXPaths <- c("///title",
                  "//meta[@name='description']/@content",
                  "///h1",
                  "///h2",
                  "///h3",
                  "//link[@rel='alternate']/@hreflang",
                  "//link[@rel='canonical']/@href",
                  "//meta[@rel='robots']/@content")

# create proxy configuration if you need it. In this exemple we do not need it
# proxy <- httr::use_proxy("190.90.100.205",41000)
# use proxy configuration

# Crawler settings : I add many options but there are not all compulsory
Rcrawler(Website = "https://www.v6protect.fr", 
         #Obeyrobots=TRUE, 
         #RequestsDelay = 10, 
         #dataUrlfilter ="/path", 
         #crawlUrlfilter="/path/",
         #MaxDepth = 1, 
         ExtractXpathPat = CustomXPaths, 
         PatternsNames = CustomLabels,
         #Useragent="Mozilla 3.11",
         NetworkData = TRUE, #inlinks
         NetwExtLinks =TRUE, #outlinks
         statslinks = TRUE,
         #use_proxy = proxy,
         #ignoreAllUrlParams = TRUE
         )

# I combine data
crawl <-data.frame(do.call("rbind", DATA))
crawl_complete <- cbind(INDEX,crawl)
Idurl = as.numeric(crawl_complete$Id)
crawl_complete = cbind(Idurl,crawl_complete)


# I count inlinks
count_to = NetwEdges[,1:2] %>%
  distinct() %>%
  group_by(To) %>%
  summarise(n = n())

# I rename columns
count_to = count_to %>% 
rename(Idurl = To, Inlinks = n)

# I join inlinks data with my crawl data
df_final = left_join(count_to, crawl_complete,by="Idurl")

# I remove columns that I do not need
df_final = select(df_final, -Idurl, -Id, -IN)

# I rename columns
df_final = df_final %>% 
rename(Outlinks = OUT, Depth = Level)


## PAGERANK calculation
links <- NetwEdges[,1:2] %>%
  #grabing the first two columns
  distinct() 
# loading igraph package
library(igraph)
# Loading website internal links inside a graph object
g <- graph.data.frame(links)
# this is the main function, don't ask how it works
pr <- page.rank(g, algo = "prpack", vids = V(g), directed = TRUE, damping = 0.85)

# I grab results inside a dedicated data frame
values <- data.frame(pr$vector)
values$names <- rownames(values)

# delating row names
row.names(values) <- NULL

# reordering column
values <- values[c(2,1)]

# renaming columns
names(values)[1] <- "PageID"
names(values)[2] <- "pagerank"

#replacing id with url
values$url <- NetwIndex
names(values)[3] <- "Url"

# out of 10
values$Pagerank<- round(values$pagerank / max(values$pagerank) * 10)

# I join my crawl with Pagerank information
crawl = left_join(values,df_final,by="Url")

# I clean my dataframe by removing columns
crawl = select(crawl, -PageID.x,pagerank,-PageID.y)

#HERE WE ARE ! You can export you crawl data in an csv file
write.csv(crawl, "my_crawl_data.csv", sep=";")


###  BONUS ###

# FIND MY LAST CRAWL : HTML
ListProjects()
LastHTMLDATA <- LoadHTMLFiles("xxxxxxx", type = "vector")
# or to simply grab the last one:
LastHTMLDATA <- LoadHTMLFiles(ListProjects()[1], type = "vector")

for(i in 1:nrow(LastHTMLDATA)) {
  LastHTMLDATA$title[i] <- ContentScraper(HTmlText = LastHTMLDATA$html[i] ,XpathPatterns = "//title")
  LastHTMLDATA$h1[i] <- ContentScraper(HTmlText = LastHTMLDATA$html[i] ,XpathPatterns = "//h1")
  LastHTMLDATA$h2[i] <- ContentScraper(HTmlText = LastHTMLDATA$html[i] ,XpathPatterns = "//h2")
  LastHTMLDATA$h3[i] <- ContentScraper(HTmlText = LastHTMLDATA$html[i] ,XpathPatterns = "//h3")
}

## REACT OR ANGULAR CRAWLING SETTINGS ##
# RCrawler handly includes Phantom JS, the classic headless browser.
# Download and install phantomjs headless browser
install_browser()
 
# start browser process 
br <-run_browser()
Rcrawler(Website = "https://www.example.com/", Browser = br)
 
# don't forget to stop browser afterwards
stop_browser(br)
Search Console : Comment récupérer les données avec R

Search Console : Comment récupérer les données avec R

Pour rappel, la Search Console est un outil à travers lequel les SEO s’appuient pour monitorer les performances des sites à travers différents metrics comme par exemple les clics, les impressions, les taux de clics, les positions, les keywords, (etc …). En somme, cet outil est une source incroyable de données. Le seul bémol, c’est la limitation. En effet la Search Console n’affiche que les performances (clics, impressions, etc …) pour les 1000 premières urls de votre site. Voici comment contourner cette limitation …

Script R : Exploiter l’API Search Console pour casser la limitation

setwd("define your working directory")

# Je charge dans une variable la liste des librairies que je vais utiliser
packages <- c("dplyr", "stringr, "searchConsoleR", "writexl")

# fonction permettant d'installer automatiquement les librairies necessaires &amp; non installees
if (length(setdiff(packages, rownames(installed.packages()))) > 0) {
  install.packages(setdiff(packages, rownames(installed.packages())))  
}

# Je charge les librairies dans l'environnement de travail
library(dplyr)
library(stringr)
library(writexl)
library(searchConsoleR)


# API Search Console
scr_auth()

start <- "2019-04-01"
end <- "2019-04-07"
max_results <- 100000

# Trafic depuis les données de la Search Console
df <- search_analytics("your_domain.com", 
                               startDate = start, endDate = end,
                               dimensions = c("page","query"),
                               dimensionFilterExp = "query!~brandedKW", #replace brandedKW by your brand name
                               rowLimit = max_results,
                               aggregationType = "byPage",
                               walk_data = "byBatch")

write_xlsx(df,"df_data.xlsx")

Crawler des sitemaps XML avec R et xsitemap

Crawler des sitemaps XML avec R et xsitemap

Les sitemaps XML, pour rappel, sont des fichiers présents à la racine de votre site et listent l’ensemble des urls importantes d’un point de vue SEO, de votre site. Dans certains contextes, vous serez amené à souhaiter récupérer les urls des sitemaps pour mener des analyses.

Comment récupérer les urls d’un sitemap ?

install.packages("devtools")
library(devtools)
install_github("pixgarden/xsitemap")
library(xsitemap)

# This is the main function. Add domain hostname or an XML URL as a parameter
sitemap_urls <- xsitemapGet("https://www.asos.com/product-sitemap-index-COM.xml")

# Will check if sitemap urls are sending 200 http code.Beware it can take some time depending on the number of URLs
sitemap_urls_code <- xsitemapCheckHTTP(xsitemap_urls)

# Will search for xml sitemap URL inside robots.txt
sitemap_urls_blocked_by_robots.txt = xsitemapGetFromRobotsTxt(sitemap_urls)

Google Analytics + R : Comment récupérer les données  ?

Google Analytics + R : Comment récupérer les données ?

Vous avez besoin de récupérer rapidement des données issues de Google Analytics sans limitation ? Ce script est fait pour vous. Pour cela nous utilisons RGoogleAnalytics

RGoogleAnalytics est une bibliothèque R qui vous permet d’accéder à l’API de Google Analytics Reporting. Grâce à cette bibliothèque, vous serez en mesure de récupérer des données Google Analytics rapidement et efficacement pour ensuite les stocker dans un dataframe afin de les traiter ou encore les exporter au format csv.

Comment créer un compte sur Google Cloud Platform et activer la clé d’API Google Analytics

Pour exploiter le code ci-dessous, je vous invite à créer un compte sur Google Cloud Plaform et d’activer l’API Google Analytics. Voici les étapes :

  1. Rendez-vous ici
  2. Créer un projet si vous n’en n’avez pas un sur Google cloud plaform
  3. Cliquez sur « Bibliothèque » dans le menu
  4. Recherchez « Google Analytics Reporting API » et cliquez sur le logo
  5. Cliquez sur « Activez »
  6. Cliquez sur « Identifiants » dans le menu
  7. Cliquez sur « créer des identifiants » (en haut de l’écran) et sur « ID client OAuth »
  8. Choisissez « Autre », renseigner un nom puis cliquez sur « Créer »
  9. BRAVO vous avez réussi à créer votre ID client et votre code secret client
  10. Vous pouvez maintenant passez au code R

Liens utiles :

install.packages("RGoogleAnalytics")
library(RGoogleAnalytics)
setwd("...")

# Authorize Google Analytics account : # https://console.cloud.google.com/apis/dashboard
token <- Auth("client id","client password") 

# Save the token object for future sessions
save(token,file="./token_file")

# In future sessions it can be loaded by running load("./token_file")
ValidateToken(token)


# Build a list of all the Query Parameters
#https://ga-dev-tools.appspot.com/dimensions-metrics-explorer/?
#https://developers.google.com/analytics/devguides/reporting/core/v3/reference
query.list <- Init(start.date = "2020-05-01",
                   end.date = "2020-05-06",
                   dimensions = "ga:LandingPagePath",
                   metrics = "ga:sessions",
                   filters = "ga:medium==organic",
                   max.results = 10000,
                   table.id = "ga:XXXXXXX")

ga.query <- QueryBuilder(query.list)
ga.data <- GetReportData(ga.query, token, split_daywise = T, delay = 5)
write.csv(ga.data, "ga_data.csv")