Einführung

Zuvor habe ich ein System erstellt, das die AdWords-API zum Abrufen von Keyword-Planer-Daten verwendet. Kürzlich hörte ich ein Gerücht, dass die AdWords-API enden wird (?). Daher habe ich mich schnell entschlossen, die neue Google Ads-API auszuprobieren.

Klicken Sie hier, um zur offiziellen Website der Google Ads API zu gelangen Google Ads API Beta

Zum Zeitpunkt des Schreibens (Stand 3. August 2020) scheint Beta noch nicht genommen worden zu sein.

Klicken Sie hier für den vorherigen Artikel Suchvolumen / CPC / Wettbewerbsfähigkeit des Keyword-Planers mit AdWords-API abrufen

Bis Sie die Keyword-Planer-Daten erhalten

Wie beim letzten Mal werde ich im folgenden Ablauf erklären.

Vorbereitung für die Verwendung der Google Ads-API
Installieren Sie die Google Ads API-Clientbibliothek für Python
OAuth2-Authentifizierungseinstellungen
Holen Sie sich Suchvolumen / CPC / Wettbewerbsfähigkeit mit API

1. Vorbereitung für die Verwendung der Google Ads-API

Die Verwendung der Google Ads-API ist kostenlos. Sie müssen jedoch ein Kundencenter-Konto und ein Entwicklertoken beantragen und genehmigen. Da es im vorherigen Artikel erworben wurde, wird es hier weggelassen. ・ Google Ads API Official (Schnellstart) ・ [Klicken Sie hier für den vorherigen Artikel](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. Installieren Sie die Google Ads API-Clientbibliothek für Python

Wenn Sie es bereits installiert haben, ist dieser Abschnitt nicht erforderlich.

Dieses Mal werde ich versuchen, es mithilfe der von Google bereitgestellten API-Client-Bibliothek (Python) abzurufen. Bitte installieren Sie es unter Bezugnahme auf hier. Google Ads API Beta> Client-Bibliothek abrufen Geben Sie insbesondere den folgenden Befehl ein (pip)

`python`


$ pip install google-ads

Die in diesem Artikel verifizierte Version von "Google-Anzeigen" ist "6.0.0".
Python-Version ist 3.7 oder höher

3. OAuth2-Authentifizierungseinstellungen

Da es im vorherigen Artikel festgelegt wurde, wird es hier weggelassen. ・ Google Ads API (Schnellstart) ・ [Klicken Sie hier, um zum vorherigen Artikel zu gelangen](https://qiita.com/zak_y/items/58e07ef042605b113f86#3-oauth2-%E8%AA%8D%E8%A8%BC%E3%81%AE%E8%A8%AD % E5% AE% 9A)

Im Gegensatz zur vorherigen AdWords-API lautet die Einstellungsdatei diesmal "google-ads.yaml".
Informationen zu "google-ads.yaml" finden Sie hier. 　 https://github.com/googleads/google-ads-python/blob/master/google-ads.yaml
Sie müssen die Google Ads-API aktivieren. Die Google Ads-API wird angezeigt, wenn Sie die API-Bibliothek auf Anzeigen in der Google API-Konsole eingrenzen.

4. Holen Sie sich Suchvolumen / CPC / Wettbewerbsfähigkeit mit API

Ich werde den Verarbeitungsablauf kurz erläutern. Die offizielle Beschreibung finden Sie hier. https://developers.google.com/google-ads/api/docs/keyword-planning/generate-historical-metrics Sie müssen "KeywordPlanService.GenerateHistoricalMetrics" verwenden, um die Keyword-Planer-Daten abzurufen. In dieser API als Flow

Erstellen von Keyword-Plänen ("KeywordPlan", "KeywordPlanCampaigns", "KeywordPlanAdGroups", "KeywordPlanKeywords" und "KeywordPlanNegativeKeywords").
Vergangene Indexdaten abrufen (KeywordPlanService.GenerateHistoricalMetrics) Weil es wird Zunächst habe ich die Abteilung zur Erstellung von Keyword-Plänen mit Bezug auf die Formel gestartet.

Ich habe hier auf die offizielle Probe verwiesen. Ich habe KeywordPlanNegativeKeywords weggelassen, weil ich denke, dass es diesmal unnötig ist. Erstellen Sie anschließend ein Teil, um frühere Indexdaten zu erfassen.
Da es keine Stichprobe zum Erfassen der vergangenen Indexdaten (historische Metriken) gibt, schreiben Sie diese in die vergangene Indexdatenerfassung um, indem Sie sich auf die Stichprobe beziehen, um die Prognosedaten zu erfassen (Prognosemetriken).

Unten finden Sie den vollständigen Beispielcode (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):
    #Erstellen eines Keyword-Plans
    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)

    #Erhalten Sie vergangene Indikatordaten
    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()}'
    #Versuchen Sie, die maximalen Kosten pro Klick mit dem Standardwert (260 Yen) festzulegen, wenn diese auf dem Bildschirm erstellt werden
    #Diese Einstellung kann für jede Anzeigengruppe oder jedes einzelne Keyword anstelle der Kampagne festgelegt werden
    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:Japan
    geo_target.geo_target_constant.value = 'geoTargetConstants/2392'
    keyword_plan_campaign.geo_targets.extend([geo_target])

    language = client.get_type('StringValue', version='v4')
    # 1005:japanisch
    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 = ['Diät', 'Muskeltraining', 'Gluten-frei']

    main(google_ads_client, args.customer_id, target_keywords)

Hier werden Keyword-Planer-Daten mit den Keywords "Diät", "Muskeltraining" und "Glutenfrei" erfasst.
Es wird davon ausgegangen, dass sich "google-ads.yaml" im Home-Verzeichnis befindet. Um den Speicherort anzugeben, geben Sie den Pfad im Argument "GoogleAdsClient.load_from_storage ()" an.
Die maximalen Kosten pro Klick werden beim Erstellen auf dem Bildschirm auf den Standardwert (260 Yen) festgelegt.
In der API werden low_top_of_page_bid (preisgünstiger CPC) und high_top_of_page_bid (hochpreisiger CPC) durch 1000000 geteilt, da die Einheit ein Mikro ist.

abschließend

Die API für Google Ads wurde überarbeitet und scheint in Zukunft mit der Google Ads-API vereinheitlicht zu werden. Ich habe versucht, die mit der AdWords-API durchgeführte Datenerfassung für den Keyword-Planer auf die Google Ads-API zu migrieren, war jedoch etwas verwirrt, da sich nicht nur die API, sondern auch die Datenelemente usw. geändert haben. Insbesondere wurde der CPC ab diesem Zeitpunkt in günstige und hochpreisige Bereiche unterteilt (der Bildschirm des Keyword-Planers ist ebenfalls derselbe). Wie sollte die Konsistenz mit dem durchschnittlichen CPC sein, der bisher von der AdWords-API erfasst wurde? Ob Sie einfach die niedrigen und hohen Preise durch Mittelung der beiden berechnen oder den CPC der Prognosedaten (Prognosemetriken) anstelle der diesmal verwendeten Indexdaten der Vergangenheit (Historische Metriken) verwenden. Wenn ich Zeit habe, werde ich versuchen, das herauszufinden.

[PYTHON] Mit der Google Ads API erhalten Sie Suchvolumen, CPC und Wettbewerbsfähigkeit des Keyword-Planers