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

Au moment de la rédaction de cet article (au 3 août 2020), il semble que la version bêta n'ait pas encore été prise.

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.

Préparation à l'utilisation de l'API Google Ads
Installez la bibliothèque cliente de l'API Google Ads pour Python
Paramètres d'authentification OAuth2
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

Si vous l'avez déjà installé, cette section n'est pas nécessaire.

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

La version de "google-ads" vérifiée dans cet article est "6.0.0".
La version Python est 3.7 ou supérieure

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)

Contrairement à l'ancienne API AdWords, cette fois, le fichier de paramètres est "google-ads.yaml".
Pour google-ads.yaml, reportez-vous ici. 　 https://github.com/googleads/google-ads-python/blob/master/google-ads.yaml
Vous devez activer l'API Google Ads. L'API Google Ads s'affiche lorsque vous restreignez la bibliothèque d'API aux annonces dans la console d'API Google.

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

Création de plans de mots clés (KeywordPlan, KeywordPlanCampaigns, KeywordPlanAdGroups, KeywordPlanKeywords et KeywordPlanNegativeKeywords.)
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,

J'ai fait référence à l'échantillon officiel ici. J'ai omis «KeywordPlanNegativeKeywords» car je pense que ce n'est pas nécessaire cette fois. Ensuite, créez une pièce pour acquérir les anciennes données d'index.
Puisqu'il n'y a pas d'échantillon pour acquérir des données d'index passées (métriques historiques), réécrivez-les sur l'acquisition de données d'index passées en vous référant à l'échantillon pour acquérir des données de prévision (métriques de prévision).

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)

Ici, les données du planificateur de mots-clés sont acquises avec les mots-clés «régime», «entraînement musculaire» et «sans gluten».
On suppose que «google-ads.yaml» se trouve dans le répertoire personnel. Pour spécifier l'emplacement, spécifiez le chemin dans l'argument de GoogleAdsClient.load_from_storage ().
Le coût maximum par clic est défini sur la valeur par défaut (260 yens) lors de sa création à l'écran.
Dans l'API, low_top_of_page_bid (CPC à bas prix) et high_top_of_page_bid (CPC à prix élevé) sont divisés par 1000000 car l'unité est micro.

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.

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