Obtenez le volume de recherche, le CPC et la compétitivité du planificateur de mots clés avec l'API Google Ads

introduction

Auparavant, j'ai créé un système qui utilise l'API AdWords pour acquérir des données de planificateur de mots clés. Récemment, j'ai entendu une rumeur selon laquelle l'API AdWords allait s'arrêter (?), J'ai donc décidé à la hâte d'essayer la nouvelle API Google Ads.

Cliquez ici pour accéder au site officiel de l'API Google Ads Google Ads API Beta

Cliquez ici pour l'article précédent Obtenez le volume de recherche / CPC / compétitivité du planificateur de mots clés avec l'API AdWords

Jusqu'à ce que vous obteniez les données du planificateur de mots clés

Comme pour la dernière fois, je vais l'expliquer dans le flux suivant.

  1. Préparation à l'utilisation de l'API Google Ads
  2. Installez la bibliothèque cliente de l'API Google Ads pour Python
  3. Paramètres d'authentification OAuth2
  4. Obtenez le volume de recherche / CPC / compétitivité avec l'API

1. Préparation à l'utilisation de l'API Google Ads

L'API Google Ads est gratuite, mais vous devez demander et approuver un compte CM et un jeton de développeur. Puisqu'il a été acquis dans l'article précédent, il sera omis ici. ・ Google Ads API Official (Quick Start) ・ [Cliquez ici pour l'article précédent](https://qiita.com/zak_y/items/58e07ef042605b113f86#1-adwords-api%E3%82%92%E5%88%A9%E7%94%A8%E3%81% 99% E3% 82% 8B% E3% 81% 9F% E3% 82% 81% E3% 81% AE% E6% BA% 96% E5% 82% 99)

2. Installez la bibliothèque cliente de l'API Google Ads pour Python

Cette fois, je vais essayer de l'obtenir en utilisant la bibliothèque cliente API (Python) fournie par Google. Veuillez l'installer en vous référant ici. API Google Ads Beta> Obtenir la bibliothèque client Plus précisément, entrez avec la commande suivante (pip)

python


$ pip install google-ads

3. Paramètres d'authentification OAuth2

Puisqu'il a été défini dans l'article précédent, il est omis ici. ・ API Google Ads (démarrage rapide) ・ [Cliquez ici pour l'article précédent](https://qiita.com/zak_y/items/58e07ef042605b113f86#3-oauth2-%E8%AA%8D%E8%A8%BC%E3%81%AE%E8%A8%AD % E5% AE% 9A)

4. Obtenez le volume de recherche / CPC / compétitivité avec l'API

Je vais expliquer brièvement le flux de traitement. La description officielle est ici. https://developers.google.com/google-ads/api/docs/keyword-planning/generate-historical-metrics Vous devez utiliser KeywordPlanService.GenerateHistoricalMetrics pour obtenir les données du planificateur de mots-clés. Dans cette API, en tant que flux

  1. Création de plans de mots clés (KeywordPlan, KeywordPlanCampaigns, KeywordPlanAdGroups, KeywordPlanKeywords et KeywordPlanNegativeKeywords.)
  2. Récupérez les données d'index passées (KeywordPlanService.GenerateHistoricalMetrics) Parce que ça devient Tout d'abord, j'ai démarré le service de création de plan de mots-clés en référence à la formule,

Voici l'exemple de code complet (Python3.7)

get_historical_metrics.py


#!/usr/bin/env python3
# -*- coding: utf-8 -*-

import argparse
import sys
import uuid

from google.ads.google_ads.client import GoogleAdsClient
from google.ads.google_ads.errors import GoogleAdsException

ONE_MILLION = 1.0e6

def main(client, customer_id, target_keywords):
    #Créer un plan de mots clés
    try:
        resource_name = add_keyword_plan(client, customer_id, target_keywords)
    except GoogleAdsException as ex:
        print(f'Request with ID "{ex.request_id}" failed with status '
              f'"{ex.error.code().name}" and includes the following errors:')
        for error in ex.failure.errors:
            print(f'\tError with message "{error.message}".')
            if error.location:
                for field_path_element in error.location.field_path_elements:
                    print(f'\t\tOn field: {field_path_element.field_name}')
        sys.exit(1)

    #Récupérer les données des indicateurs passés
    keyword_plan_service = client.get_service('KeywordPlanService')
    keyword_competition_level_enum = client.get_type('KeywordPlanCompetitionLevelEnum', version='v4').KeywordPlanCompetitionLevel

    try:
        response = keyword_plan_service.generate_historical_metrics(resource_name)
    except GoogleAdsException as ex:
        print('Request with ID "{}" failed with status "%s" and includes the '
              'following errors:'.format(ex.request_id, ex.error.code().name))
        for error in ex.failure.errors:
            print('\tError with message "{}".'.format(error.message))
            if error.location:
                for field_path_element in error.location.field_path_elements:
                    print('\t\tOn field: {}'.format(field_path_element.field_name))
        sys.exit(1)

    results = []
    for i, historical in enumerate(response.metrics):
        metrics = historical.keyword_metrics
        results.append({
            'keyword':              historical.search_query.value,
            'avg_monthly_searches': metrics.avg_monthly_searches.value,
            'competition':          keyword_competition_level_enum.Name(metrics.competition),
            'competition_index':    metrics.competition_index.value,
            'low_top_of_page_bid':  metrics.low_top_of_page_bid_micros.value / ONE_MILLION,
            'high_top_of_page_bid': metrics.high_top_of_page_bid_micros.value / ONE_MILLION
        })

    print(results)


def add_keyword_plan(client, customer_id, target_keywords):
    keyword_plan = create_keyword_plan(client, customer_id)
    keyword_plan_campaign = create_keyword_plan_campaign(client, customer_id, keyword_plan)
    keyword_plan_ad_group = create_keyword_plan_ad_group(client, customer_id, keyword_plan_campaign)
    create_keyword_plan_ad_group_keywords(client, customer_id, keyword_plan_ad_group, target_keywords)

    return keyword_plan

def create_keyword_plan(client, customer_id):
    operation = client.get_type('KeywordPlanOperation', version='v4')
    keyword_plan = operation.create

    keyword_plan.name.value = (f'Keyword plan for traffic estimate {uuid.uuid4()}')

    forecast_interval = client.get_type('KeywordPlanForecastIntervalEnum', version='v4').NEXT_MONTH
    keyword_plan.forecast_period.date_interval = forecast_interval

    keyword_plan_service = client.get_service('KeywordPlanService', version='v4')
    response = keyword_plan_service.mutate_keyword_plans(customer_id, [operation])
    resource_name = response.results[0].resource_name

    print(f'Created keyword plan with resource name: {resource_name}')

    return resource_name


def create_keyword_plan_campaign(client, customer_id, keyword_plan):
    operation = client.get_type('KeywordPlanCampaignOperation', version='v4')
    keyword_plan_campaign = operation.create

    keyword_plan_campaign.name.value = f'Keyword plan campaign {uuid.uuid4()}'
    #Essayez de définir le coût maximum par clic avec la valeur par défaut (260 yens) lors de la création à l'écran
    #Ce paramètre peut être défini pour chaque groupe d'annonces ou mot clé individuel au lieu de la campagne
    keyword_plan_campaign.cpc_bid_micros.value = 260000000
    keyword_plan_campaign.keyword_plan.value = keyword_plan

    keyword_plan_network = client.get_type('KeywordPlanNetworkEnum', version='v4')
    network = keyword_plan_network.GOOGLE_SEARCH
    keyword_plan_campaign.keyword_plan_network = network

    geo_target = client.get_type('KeywordPlanGeoTarget', version='v4')
    # 2392:Japon
    geo_target.geo_target_constant.value = 'geoTargetConstants/2392'
    keyword_plan_campaign.geo_targets.extend([geo_target])

    language = client.get_type('StringValue', version='v4')
    # 1005:Japonais
    language.value = 'languageConstants/1005'
    keyword_plan_campaign.language_constants.extend([language])

    keyword_plan_campaign_service = client.get_service('KeywordPlanCampaignService', version='v4')
    response = keyword_plan_campaign_service.mutate_keyword_plan_campaigns(customer_id, [operation])

    resource_name = response.results[0].resource_name

    print(f'Created keyword plan campaign with resource name: {resource_name}')

    return resource_name


def create_keyword_plan_ad_group(client, customer_id, keyword_plan_campaign):
    operation = client.get_type('KeywordPlanAdGroupOperation', version='v4')
    keyword_plan_ad_group = operation.create

    keyword_plan_ad_group.name.value = f'Keyword plan ad group {uuid.uuid4()}'
    #keyword_plan_ad_group.cpc_bid_micros.value = 2500000
    keyword_plan_ad_group.keyword_plan_campaign.value = keyword_plan_campaign

    keyword_plan_ad_group_service = client.get_service('KeywordPlanAdGroupService', version='v4')
    response = keyword_plan_ad_group_service.mutate_keyword_plan_ad_groups(customer_id, [operation])

    resource_name = response.results[0].resource_name

    print(f'Created keyword plan ad group with resource name: {resource_name}')

    return resource_name


def create_keyword_plan_ad_group_keywords(client, customer_id, plan_ad_group, target_keywords):
    match_types = client.get_type('KeywordMatchTypeEnum', version='v4')

    keywords = []
    for target_keyword in target_keywords:
        keyword_plan_ad_group_keyword = client.get_type('KeywordPlanAdGroupKeyword', version='v4')
        keyword_plan_ad_group_keyword.text.value = target_keyword
        #keyword_plan_ad_group_keyword.cpc_bid_micros.value = 2000000
        keyword_plan_ad_group_keyword.match_type = match_types.BROAD
        keyword_plan_ad_group_keyword.keyword_plan_ad_group.value = plan_ad_group
        keywords.append(keyword_plan_ad_group_keyword)

    operations = []
    for keyword in keywords:
        operation = client.get_type('KeywordPlanAdGroupKeywordOperation', version='v4')
        operation.create.CopyFrom(keyword)
        operations.append(operation)

    keyword_plan_ad_group_keyword_service = client.get_service('KeywordPlanAdGroupKeywordService', version='v4')

    response = (keyword_plan_ad_group_keyword_service.mutate_keyword_plan_ad_group_keywords(customer_id, operations))

    for result in response.results:
        print('Created keyword plan ad group keyword with resource name: '
              f'{result.resource_name}')


if __name__ == '__main__':
    # GoogleAdsClient will read the google-ads.yaml configuration file in the
    # home directory if none is specified.
    google_ads_client = GoogleAdsClient.load_from_storage()

    parser = argparse.ArgumentParser(description='Creates a keyword plan for specified customer.')
    # The following argument(s) should be provided to run the example.
    parser.add_argument('-c', '--customer_id', type=str, required=True, help='The Google Ads customer ID.')
    args = parser.parse_args()

    target_keywords = ['régime', 'Entraînement musculaire', 'Sans gluten']

    main(google_ads_client, args.customer_id, target_keywords)

en conclusion

L'API liée à Google Ads a été repensée et il semble qu'elle sera unifiée à l'API Google Ads à l'avenir. J'ai essayé de migrer l'acquisition de données du planificateur de mots clés qui a été effectuée avec l'API AdWords vers l'API Google Ads, mais j'étais un peu perplexe car non seulement l'API, mais aussi les éléments de données, etc. ont changé. En particulier, le CPC a été divisé en tranches à bas prix et à prix élevé à partir de cette époque (l'écran du planificateur de mots clés est également le même), et quelle devrait être la cohérence avec le CPC moyen acquis jusqu'à présent par l'API AdWords? Que ce soit pour simplement calculer les prix bas et élevés en faisant la moyenne des deux, ou pour utiliser le CPC des données de prévision (prévisions métriques) au lieu des données d'index passées (métriques historiques) utilisées cette fois. Si j'ai le temps, j'essaierai d'en savoir plus.

Recommended Posts

Obtenez le volume de recherche, le CPC et la compétitivité du planificateur de mots clés avec l'API Google Ads
Obtenez des vacances avec l'API Google Agenda
Obtenez des données de l'API d'analyse avec le client API Google pour python
Obtenir des informations avec l'API Zabbix
Obtenez un classement avec l'API Rakuten
Obtenez des conversions et des revenus avec l'API Google Analytics et faites un rapport à Slack
Obtenez des avis avec l'API googlemap de python
Présentation de l'API Google Map avec rails
POSTER des photos avec l'API Microsoft Bing Image Search pour obtenir des informations sur les images (Python)