Python: Script A Google Autosuggest Extract of Trends for Your Niche Search Trefwoorden

Python-script om autosuggest-trends vast te leggen

Iedereen houdt van Google Trends, maar het is een beetje lastig als het gaat om Long Tail-zoekwoorden. We houden allemaal van de ambtenaar Google Trends-service om inzicht te krijgen in het zoekgedrag. Er zijn echter twee dingen die velen ervan weerhouden om het voor solide werk te gebruiken;

  1. Wanneer je iets moet vinden nieuwe niche-zoekwoordener zijn niet genoeg gegevens over Google Trends 
  2. Gebrek aan officiële API voor het doen van verzoeken aan Google-trends: wanneer we gebruik maken van modules zoals pytrends, dan moeten we proxyservers gebruiken, anders worden we geblokkeerd. 

In dit artikel deel ik een Python-script dat we hebben geschreven om trending keywords te exporteren via Google Autosuggest.

Ophalen en opslaan van autosuggest-resultaten in de loop van de tijd 

Stel dat we 1,000 Seed-zoekwoorden hebben die naar Google Autosuggest moeten worden gestuurd. In ruil daarvoor krijgen we waarschijnlijk ongeveer 200,000 lange staart trefwoorden. Vervolgens moeten we een week later hetzelfde doen en deze datasets vergelijken om twee vragen te beantwoorden:

  • Welke vragen zijn nieuwe zoekwoorden vergeleken met de vorige keer? Dit is waarschijnlijk het geval dat we nodig hebben. Google denkt dat die vragen steeds belangrijker worden - door dit te doen, kunnen we onze eigen Google Autosuggest-oplossing maken! 
  • Welke vragen zijn zoekwoorden niet langer trending?

Het script is vrij eenvoudig en de meeste code heb ik gedeeld CDL Super Session.​ De bijgewerkte code slaat de gegevens van eerdere runs op en vergelijkt de suggesties in de loop van de tijd. We hebben bestandsgebaseerde databases zoals SQLite vermeden om het eenvoudig te maken - dus alle gegevensopslag maakt gebruik van onderstaande CSV-bestanden. Hierdoor kunt u het bestand in Excel importeren en niche-zoekwoordtrends voor uw bedrijf verkennen.

Om dit Python-script te gebruiken

  1. Voer uw seed-sleutelwoordset in die naar de autocomplete moet worden verzonden: keywords.csv
  2. Pas de scriptinstellingen naar wens aan:
    • LANGUAGE: standaard "en"
    • COUNTRY: standaard "ons"
  3. Plan dat het script één keer per week wordt uitgevoerd. U kunt het ook handmatig uitvoeren zoals u dat wilt.
  4. Gebruik keyword_suggestions.csv voor verdere analyse:
    • eerst gezien: dit is de datum waarop de zoekopdracht voor het eerst verscheen in de autosuggest
    • laatst gezien: de datum waarop de zoekopdracht voor het laatst is bekeken
    • is nieuw: if first_seen == last_seen zetten we dit op Waar - Filter gewoon op deze waarde om de nieuwe trending zoekopdrachten in de autosuggest van Google te krijgen.

Hier is de Python-code

# Pemavor.com Autocomplete Trends
# Author: Stefan Neefischer (stefan.neefischer@gmail.com)
import concurrent.futures
from datetime import date
from datetime import datetime
import pandas as pd
import itertools
import requests
import string
import json
import time

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

def makeGoogleRequest(query):
    # If you make requests too quickly, you may be blocked by google 
    time.sleep(WAIT_TIME)
    URL="http://suggestqueries.google.com/complete/search"
    PARAMS = {"client":"opera",
            "hl":LANGUAGE,
            "q":query,
            "gl":COUNTRY}
    response = requests.get(URL, params=PARAMS)
    if response.status_code == 200:
        try:
            suggestedSearches = json.loads(response.content.decode('utf-8'))[1]
        except:
            suggestedSearches = json.loads(response.content.decode('latin-1'))[1]
        return suggestedSearches
    else:
        return "ERR"

def getGoogleSuggests(keyword):
    # err_count1 = 0
    queryList = [keyword + " " + char for char in charList]
    suggestions = []
    for query in queryList:
        suggestion = makeGoogleRequest(query)
        if suggestion != 'ERR':
            suggestions.append(suggestion)

    # Remove empty suggestions
    suggestions = set(itertools.chain(*suggestions))
    if "" in suggestions:
        suggestions.remove("")
    return suggestions

def autocomplete(csv_fileName):
    dateTimeObj = datetime.now().date()
    #read your csv file that contain keywords that you want to send to google autocomplete
    df = pd.read_csv(csv_fileName)
    keywords = df.iloc[:,0].tolist()
    resultList = []

    with concurrent.futures.ThreadPoolExecutor(max_workers=MAX_WORKERS) as executor:
        futuresGoogle = {executor.submit(getGoogleSuggests, keyword): keyword for keyword in keywords}

        for future in concurrent.futures.as_completed(futuresGoogle):
            key = futuresGoogle[future]
            for suggestion in future.result():
                resultList.append([key, suggestion])

    # Convert the results to a dataframe
    suggestion_new = pd.DataFrame(resultList, columns=['Keyword','Suggestion'])
    del resultList

    #if we have old results read them
    try:
        suggestion_df=pd.read_csv("keyword_suggestions.csv")
        
    except:
        suggestion_df=pd.DataFrame(columns=['first_seen','last_seen','Keyword','Suggestion'])
    
    suggestionCommon_list=[]
    suggestionNew_list=[]
    for keyword in suggestion_new["Keyword"].unique():
        new_df=suggestion_new[suggestion_new["Keyword"]==keyword]
        old_df=suggestion_df[suggestion_df["Keyword"]==keyword]
        newSuggestion=set(new_df["Suggestion"].to_list())
        oldSuggestion=set(old_df["Suggestion"].to_list())
        commonSuggestion=list(newSuggestion & oldSuggestion)
        new_Suggestion=list(newSuggestion - oldSuggestion)
         
        for suggest in commonSuggestion:
            suggestionCommon_list.append([dateTimeObj,keyword,suggest])
        for suggest in new_Suggestion:
            suggestionNew_list.append([dateTimeObj,dateTimeObj,keyword,suggest])
    
    #new keywords
    newSuggestion_df = pd.DataFrame(suggestionNew_list, columns=['first_seen','last_seen','Keyword','Suggestion'])
    #shared keywords with date update
    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(columns={'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 old results with new results
    frames = [merge, newSuggestion_df]
    keywords_df =  pd.concat(frames, ignore_index=True, sort=False)
    # Save dataframe as a CSV file
    keywords_df['first_seen'] = pd.to_datetime(keywords_df['first_seen'])
    keywords_df = keywords_df.sort_values(by=['first_seen','Keyword'], ascending=[False,False])   
    keywords_df['first_seen']= pd.to_datetime(keywords_df['first_seen'])
    keywords_df['last_seen']= pd.to_datetime(keywords_df['last_seen'])
    keywords_df['is_new'] = (keywords_df['first_seen']== keywords_df['last_seen'])
    keywords_df=keywords_df[['first_seen','last_seen','Keyword','Suggestion','is_new']]
    keywords_df.to_csv('keyword_suggestions.csv', index=False)

# If you use more than 50 seed keywords you should slow down your requests - otherwise google is blocking the script
# If you have thousands of seed keywords use e.g. WAIT_TIME = 1 and MAX_WORKERS = 5
WAIT_TIME = 0.2
MAX_WORKERS = 20
# set the autocomplete language
LANGUAGE = "en"
# set the autocomplete country code - DE, US, TR, GR, etc..
COUNTRY="US"
# Keyword_seed csv file name. One column csv file.
#csv_fileName="keyword_seeds.csv"
CSV_FILE_NAME="keywords.csv"
autocomplete(CSV_FILE_NAME)
#The result will save in keyword_suggestions.csv csv file

Download het Python-script

Wat denk je?

Deze site gebruikt Akismet om spam te verminderen. Ontdek hoe uw reactiegegevens worden verwerkt.