Python: Script Un extrait de Google Autosuggest de tendances pour vos mots-clés de recherche de niche

Tout le monde aime Google Trends, mais c'est un peu délicat en ce qui concerne les mots clés à longue traîne. Nous aimons tous le service officiel de Google Trends pour obtenir des informations sur le comportement de recherche. Cependant, deux choses en empêchent beaucoup de l'utiliser pour un travail solide:

1. Lorsque vous avez besoin de trouver de nouveaux mots clés de niche il n'y pas assez de données sur Google Trends
2. Manque d'API officielle faire des requêtes à Google Trends: Lorsque nous utilisons des modules comme pytrends alors nous devons utiliser des serveurs proxy, ou nous sommes bloqués.

Dans cet article, je vais partager un script Python que nous avons écrit pour exporter des mots-clés tendance via Google Autosuggest.

Récupérer et stocker les résultats des suggestions automatiques au fil du temps

Supposons que nous ayons 1 000 mots clés de base à envoyer à Google Autosuggest. En retour, nous obtiendrons probablement environ 200 000 mots clés longtail . Ensuite, nous devons faire de même une semaine plus tard et comparer ces ensembles de données pour répondre à deux questions:

• Quelles requêtes sont nouveaux mots-clés par rapport à la dernière fois? C'est probablement le cas dont nous avons besoin. Google pense que ces requêtes deviennent de plus en plus importantes – ce faisant, nous pouvons créer notre propre solution Google Autosuggest!
• Quelles requêtes les mots-clés ne sont plus tendance?

Le script est assez simple, et la plupart du code que j'ai partagé ici . Le code mis à jour enregistre les données des exécutions précédentes et compare les suggestions au fil du temps. Nous avons évité les bases de données basées sur des fichiers comme SQLite pour simplifier les choses – donc tout le stockage de données utilise les fichiers CSV ci-dessous. Cela vous permet d'importer le fichier dans Excel et d'explorer les tendances des mots clés de niche pour votre entreprise.

Pour utiliser ce script Python

1. Entrez votre jeu de mots-clés de départ à envoyer à la saisie semi-automatique: keywords.csv
2. Ajustez les paramètres du script en fonction de vos besoins:
   • LANGUE: par défaut «en»
   • PAYS: par défaut «us»
3. Planifiez l'exécution du script une fois par semaine. Vous pouvez également l'exécuter manuellement comme vous le souhaitez.
4. Utilisez keyword_suggestions.csv pour une analyse plus approfondie:
   • first_seen : il s'agit de la date à laquelle la requête est apparue pour la première fois dans l'autosuggest
   • last_seen : la date à laquelle la requête a été vue pour la dernière fois [19659008] is_new : si first_seen == last_seen, nous définissons ceci sur True – Il suffit de filtrer sur cette valeur pour obtenir les nouvelles recherches de tendances dans l'autosuggest Google.

Voici le code Python [19659021] Tendances de la saisie semi-automatique de # Pemavor.com
# Auteur: Stefan Neefischer (stefan.neefischer@gmail.com)
import simultané.futures
à partir de la date d'importation datetime
à partir de date / heure importation de date / heure
importer des pandas en tant que pd
import itertools
demandes d'importation
chaîne d'importation
importer json
temps d'importation

charList = "" + string.ascii_lowercase + string.digits

def makeGoogleRequest (requête):
# Si vous faites des demandes trop rapidement, vous risquez d'être bloqué par Google
time.sleep (WAIT_TIME)
URL = "http://suggestqueries.google.com/complete/search"
PARAMS = {"client": "opéra",
"hl": LANGUE,
"q": requête,
"gl": COUNTRY}
response = requests.get (URL, params = PARAMS)
si response.status_code == 200:
essayer:
suggéréSearches = json.loads (response.content.decode ('utf-8')) [1]
sauf:
suggéréSearches = json.loads (response.content.decode ('latin-1')) [1]
retour suggéré
autre:
retourne "ERR"

def getGoogleSuggests (mot-clé):
# err_count1 = 0
queryList = [keyword +  »  » + char for char in charList]
suggestions = []
pour la requête dans queryList:
suggestion = makeGoogleRequest (requête)
si suggestion! = 'ERR':
suggestions.append (suggestion)

# Supprimer les suggestions vides
suggestions = set (itertools.chain (* suggestions))
si "" dans les suggestions:
suggestions.remove ("")
renvoyer des suggestions

def autocomplete (csv_fileName):
dateTimeObj = datetime.now (). date ()
#lisez votre fichier csv contenant les mots clés que vous souhaitez envoyer à la saisie semi-automatique de Google
df = pd.read_csv (csv_fileName)
mots-clés = df.iloc [:,0] .tolist ()
resultList = []

avec concurrent.futures.ThreadPoolExecutor (max_workers = MAX_WORKERS) comme exécuteur:
futuresGoogle = {executor.submit (getGoogleSuggests, keyword): mot-clé pour mot-clé dans les mots-clés}

pour l'avenir dans concurrent.futures.as_completed (futuresGoogle):
key = futuresGoogle [future]
pour suggestion à l'avenir.result ():
resultList.append ([key, suggestion])

# Convertir les résultats en dataframe
suggestion_new = pd.DataFrame (liste de résultats, colonnes = [‘Keyword’,’Suggestion’])
del resultList

#si nous avons d'anciens résultats, lisez-les
essayer:
suggestion_df = pd.read_csv ("keyword_suggestions.csv")

sauf:
suggestion_df = pd.DataFrame (colonnes = [‘first_seen’,’last_seen’,’Keyword’,’Suggestion’])

suggestionCommon_list = []
suggestionNew_list = []
pour le mot clé dans suggestion_new [« Keyword »] .unique ():
new_df = suggestion_new [suggestion_new[« Keyword »] == mot-clé]
old_df = suggestion_df [suggestion_df[« Keyword »] == mot-clé]
newSuggestion = set (new_df [« Suggestion »] .to_list ())
oldSuggestion = set (old_df [« Suggestion »] .to_list ())
commonSuggestion = liste (newSuggestion & oldSuggestion)
new_Suggestion = liste (newSuggestion – oldSuggestion)

pour suggérer en commun
suggestionCommon_list.append ([dateTimeObj,keyword,suggest])
pour suggérer dans new_Suggestion:
suggestionNew_list.append ([dateTimeObj,dateTimeObj,keyword,suggest])

#new mots-clés
newSuggestion_df = pd.DataFrame (suggestionNew_list, columns = [‘first_seen’,’last_seen’,’Keyword’,’Suggestion’])
# mots clés partagés avec mise à jour de la date
commonSuggestion_df = pd.DataFrame (suggestionCommon_list, columns = [‘last_seen’,’Keyword’,’Suggestion’])
merge = pd.merge (suggestion_df, commonSuggestion_df, left_on = [« Suggestion »]right_on = [« Suggestion »]how = 'left')
merge = merge.rename (colonnes = {'last_seen_y': 'last_seen', "Keyword_x": "Keyword"})
merge [« last_seen »] .fillna (merge [« last_seen_x »]inplace = True)
del merge [« last_seen_x »]
del merge [« Keyword_y »]

#merge les anciens résultats avec de nouveaux résultats
cadres = [merge, newSuggestion_df]
mots-clés_df = pd.concat (frames, ignore_index = True, sort = False)
# Enregistrer la trame de données sous forme de fichier CSV
keywords_df [‘first_seen’] = pd.to_datetime (keywords_df [‘first_seen’])
keywords_df = keywords_df.sort_values ​​(par = [‘first_seen’,’Keyword’]croissant = [False,False])
keywords_df [‘first_seen’] = pd.to_datetime (keywords_df [‘first_seen’])
keywords_df [‘last_seen’] = pd.to_datetime (keywords_df [‘last_seen’])
mots-clés_df [‘is_new’] = (mots-clés_df [‘first_seen’] == mots-clés_df [‘last_seen’])
mots-clés_df = mots-clés_df [[‘first_seen’,’last_seen’,’Keyword’,’Suggestion’,’is_new’]]
keywords_df.to_csv ('keyword_suggestions.csv', index = False)

# Si vous utilisez plus de 50 mots-clés de départ, vous devez ralentir vos requêtes – sinon Google bloque le script
# Si vous avez des milliers de mots-clés de départ, utilisez par ex. WAIT_TIME = 1 et MAX_WORKERS = 5
WAIT_TIME = 0,2
MAX_WORKERS = 20
# définir la langue de saisie semi-automatique
LANGUAGE = "fr"
# définir le code de pays à saisie semi-automatique – DE, US, TR, GR, etc.
COUNTRY = "US"
# Nom du fichier csv Keyword_seed. Un fichier csv de colonne.
# csv_fileName = "keyword_seeds.csv"
CSV_FILE_NAME = "keywords.csv"
saisie semi-automatique (CSV_FILE_NAME)
# Le résultat sera enregistré dans le fichier csv keyword_suggestions.csv

Téléchargez le script Python