이전 측정항목 생성

과거 측정항목 은 Google 검색에서 키워드의 실적을 보여주는 측정항목 (KeywordPlanHistoricalMetrics)을 제공하며 다음 필드를 포함합니다.

• 월별 평균 검색수 (avg_monthly_searches, 지난 12 개월 또는 지정된 year_month_range의 평균)
• 월별 예상 검색량 (monthly_search_volumes, 최대 지난 4년간의 데이터 사용 가능)
• 경쟁 수준 (competition)
• 경쟁 지수 (competition_index, 0~100)
• 페이지 상단 입찰가의 20번째 백분위수 (low_top_of_page_bid_micros)
• 페이지 상단 입찰가의 80번째 백분위수 (high_top_of_page_bid_micros)
• 평균 클릭당비용 (average_cpc_micros, 기존 지원을 위해 반환됨 HistoricalMetricsOptions.include_average_cpc가 true)

GenerateKeywordIdeas를 사용하여 추천 키워드를 발견하는 경우 반환된 각 GenerateKeywordIdeaResult에는 이미 KeywordPlanHistoricalMetrics가 keyword_idea_metrics 필드에 포함되어 있습니다. 기존 키워드 목록이 있고 광고 그룹 테마로 구성하거나 예측 측정항목으로 실적을 추정하기 전에 과거 검색량, 경쟁, 페이지 상단 입찰가로 필터링하려면 GenerateKeywordHistoricalMetrics를 호출하세요.

측정항목 생성

과거 측정항목을 생성하려면 요청당 최대 10,000개의 키워드와 포함할 타겟팅 매개변수 (예: language, 최대 10개의 geo_target_constants, keyword_plan_network)를 사용하여 KeywordPlanIdeaService.GenerateKeywordHistoricalMetrics 를 호출합니다. 이 메서드는 GenerateKeywordHistoricalMetricsResult 객체 목록이 포함된 GenerateKeywordHistoricalMetricsResponse를 반환하며 각 객체에는 KeywordPlanHistoricalMetrics 유형의 keyword_metrics 필드가 있습니다. API는 유사 검색어 (예: "car"와 "cars"를 단일 결과로 병합하고 close_variants에 결합된 쿼리를 나열)를 중복 삭제하므로 반환된 결과의 수가 요청된 키워드 수보다 작을 수 있습니다.

자바

private void runExample(GoogleAdsClient googleAdsClient, Long customerId) {
  GenerateKeywordHistoricalMetricsRequest request =
      GenerateKeywordHistoricalMetricsRequest.newBuilder()
          .setCustomerId(String.valueOf(customerId))
          .addAllKeywords(Arrays.asList("mars cruise", "cheap cruise", "jupiter cruise"))
          // See https://developers.google.com/google-ads/api/reference/data/geotargets for the
          // list of geo target IDs.
          // Geo target constant 2840 is for USA.
          .addGeoTargetConstants(ResourceNames.geoTargetConstant(2840))
          .setKeywordPlanNetwork(KeywordPlanNetwork.GOOGLE_SEARCH)
          // See
          // https://developers.google.com/google-ads/api/reference/data/codes-formats#languages
          // for the list of language constant IDs.
          // Language constant 1000 is for English.
          .setLanguage(ResourceNames.languageConstant(1000))
          .build();

  try (KeywordPlanIdeaServiceClient keywordPlanIdeaServiceClient =
      googleAdsClient.getLatestVersion().createKeywordPlanIdeaServiceClient()) {
    GenerateKeywordHistoricalMetricsResponse response =
        keywordPlanIdeaServiceClient.generateKeywordHistoricalMetrics(request);
    for (GenerateKeywordHistoricalMetricsResult result : response.getResultsList()) {
      KeywordPlanHistoricalMetrics metrics = result.getKeywordMetrics();
      System.out.printf("The search query: %s%n", result.getText());
      System.out.printf(
          "and the following variants: %s%n", Joiner.on(",").join(result.getCloseVariantsList()));
      System.out.println("generated the following historical metrics:");

      // Approximate number of monthly searches on this query averaged for the past 12
      // months.
      System.out.printf(
          "Approximate monthly searches: %s%n",
          metrics.hasAvgMonthlySearches() ? metrics.getAvgMonthlySearches() : null);

      // The competition level for this search query.
      System.out.printf("Competition level: %s%n", metrics.getCompetition());

      // The competition index for the query in the range [0,100]. This shows how
      // competitive ad placement is for a keyword. The level of competition from 0-100 is
      // determined by the number of ad slots filled divided by the total number of slots
      // available. If not enough data is available, null will be returned.
      System.out.printf(
          "Competition index: %s%n",
          metrics.hasCompetitionIndex() ? metrics.getCompetitionIndex() : null);

      // Top of page bid low range (20th percentile) in micros for the keyword.
      System.out.printf(
          "Top of page bid low range: %s%n",
          metrics.hasLowTopOfPageBidMicros() ? metrics.getLowTopOfPageBidMicros() : null);

      // Top of page bid high range (80th percentile) in micros for the keyword.
      System.out.printf(
          "Top of page bid high range: %s%n",
          metrics.hasHighTopOfPageBidMicros() ? metrics.getHighTopOfPageBidMicros() : null);

      // Approximate number of searches on this query for the past twelve months.
      metrics.getMonthlySearchVolumesList().stream()
          // Orders the monthly search volumes by descending year, then descending month.
          .sorted(
              (a, b) ->
                  ComparisonChain.start()
                      .compare(b.getYear(), a.getYear())
                      .compare(b.getMonth(), a.getMonth())
                      .result())
          // Prints each monthly search volume.
          .forEachOrdered(
              monthlySearchVolume ->
                  System.out.printf(
                      "Approximately %d searches in %s, %s%n",
                      monthlySearchVolume.getMonthlySearches(),
                      monthlySearchVolume.getMonth(),
                      monthlySearchVolume.getYear()));
    }
  }
}
GenerateHistoricalMetrics.java
      

C#

public void Run(GoogleAdsClient client, long customerId)
{
    KeywordPlanIdeaServiceClient keywordPlanIdeaService =
            client.GetService(Services.V26.KeywordPlanIdeaService);

    GenerateKeywordHistoricalMetricsRequest request =
        new GenerateKeywordHistoricalMetricsRequest()
    {
        CustomerId = customerId.ToString(),
        Keywords = { "mars cruise", "cheap cruise", "jupiter cruise" },
        // See https://developers.google.com/google-ads/api/reference/data/geotargets
        // for the list of geo target IDs.
        // Geo target constant 2840 is for USA.
        GeoTargetConstants = { ResourceNames.GeoTargetConstant(2840) },
        KeywordPlanNetwork = KeywordPlanNetwork.GoogleSearch,
        // See  https://developers.google.com/google-ads/api/reference/data/codes-formats#languages
        // for the list of language constant IDs.
        // Language constant 1000 is for English.
        Language = ResourceNames.LanguageConstant(1000)
    };

    try
    {
        GenerateKeywordHistoricalMetricsResponse response =
            keywordPlanIdeaService.GenerateKeywordHistoricalMetrics(request);

        foreach (GenerateKeywordHistoricalMetricsResult result in response.Results)
        {
            KeywordPlanHistoricalMetrics metrics = result.KeywordMetrics;

            Console.WriteLine($"The search query {result.Text}");
            Console.WriteLine("and the following variants: " +
                $"{String.Join(",", result.CloseVariants)}");
            Console.WriteLine("Generated the following historical metrics:");

            // Approximate number of monthly searches on this query averaged for the past 12
            // months.
            Console.WriteLine($"Approximate monthly searches: {metrics.AvgMonthlySearches}");

            // The competition level for this search query.
            Console.WriteLine($"Competition level: {metrics.Competition}");

            // The competition index for the query in the range [0,100]. This shows how
            // competitive ad placement is for a keyword. The level of competition from 0-100 is
            // determined by the number of ad slots filled divided by the total number of slots
            // available. If not enough data is available, null will be returned.
            Console.WriteLine($"Competition index: {metrics.CompetitionIndex}");

            // Top of page bid low range (20th percentile) in micros for the keyword.
            Console.WriteLine($"Top of page bid low range: {metrics.LowTopOfPageBidMicros}");

            // Top of page bid high range (80th percentile) in micros for the keyword.
            Console.WriteLine($"Top of page bid high range: {metrics.HighTopOfPageBidMicros}");

            // Approximate number of searches on this query for the past twelve months.
            foreach (MonthlySearchVolume month in metrics.MonthlySearchVolumes)
            {
                Console.WriteLine($"Approximately {month.MonthlySearches} searches in " +
                    $"{month.Month}, {month.Year}");
            }
        }

    }
    catch (GoogleAdsException e)
    {
        Console.WriteLine("Failure:");
        Console.WriteLine($"Message: {e.Message}");
        Console.WriteLine($"Failure: {e.Failure}");
        Console.WriteLine($"Request ID: {e.RequestId}");
        throw;
    }
}
GenerateHistoricalMetrics.cs
      

PHP

public static function runExample(
    GoogleAdsClient $googleAdsClient,
    int $customerId
): void {
    $keywordPlanIdeaServiceClient = $googleAdsClient->getKeywordPlanIdeaServiceClient();
    // Generates keyword historical metrics based on the specified parameters.
    $response = $keywordPlanIdeaServiceClient->generateKeywordHistoricalMetrics(
        new GenerateKeywordHistoricalMetricsRequest([
            'customer_id' => $customerId,
            'keywords' => ['mars cruise', 'cheap cruise', 'jupiter cruise'],
            // See https://developers.google.com/google-ads/api/reference/data/geotargets for
            // the list of geo target IDs.
            // Geo target constant 2840 is for USA.
            'geo_target_constants' => [ResourceNames::forGeoTargetConstant(2840)],
            'keyword_plan_network' => KeywordPlanNetwork::GOOGLE_SEARCH,
            // https://developers.google.com/google-ads/api/reference/data/codes-formats#languages
            // for the list of language constant IDs.
            // Language constant 1000 is for English.
            'language' => ResourceNames::forLanguageConstant(1000)
        ])
    );

    // Iterates over the results and print its detail.
    foreach ($response->getResults() as $result) {
        /** @var GenerateKeywordHistoricalMetricsResult $result */
        $metrics = $result->getKeywordMetrics();
        printf("The search query: '%s' ", $result->getText());
        printf(
            "and the following variants: '%s' ",
            implode(',', iterator_to_array($result->getCloseVariants()->getIterator()))
        );
        print "generated the following historical metrics:" . PHP_EOL;

        // Approximate number of monthly searches on this query averaged for the past 12 months.
        printf(
            "Approximate monthly searches: %s%s",
            $metrics->hasAvgMonthlySearches()
                ? sprintf("%d", $metrics->getAvgMonthlySearches())
                : "'none'",
            PHP_EOL
        );

        // The competition level for this search query.
        printf(
            "Competition level: '%s'%s",
            KeywordPlanCompetitionLevel::name($metrics->getCompetition()),
            PHP_EOL
        );

        // The competition index for the query in the range [0,100]. This shows how
        // competitive ad placement is for a keyword. The level of competition from 0-100 is
        // determined by the number of ad slots filled divided by the total number of slots
        // available. If not enough data is available, null will be returned.
        printf(
            "Competition index: %s%s",
            $metrics->hasCompetitionIndex()
                ? sprintf("%d", $metrics->getCompetitionIndex())
                : "'none'",
            PHP_EOL
        );

        // Top of page bid low range (20th percentile) in micros for the keyword.
        printf(
            "Top of page bid low range: %s%s",
            $metrics->hasLowTopOfPageBidMicros()
                ? sprintf("%d", $metrics->getLowTopOfPageBidMicros())
                : "'none'",
            PHP_EOL
        );

        // Top of page bid high range (80th percentile) in micros for the keyword.
        printf(
            "Top of page bid high range: %s%s",
            $metrics->hasHighTopOfPageBidMicros()
                ? sprintf("%d", $metrics->getHighTopOfPageBidMicros())
                : "'none'",
            PHP_EOL
        );

        // Approximate number of searches on this query for the past twelve months.
        $monthlySearchVolumes =
            iterator_to_array($metrics->getMonthlySearchVolumes()->getIterator());
        usort(
            $monthlySearchVolumes,
            // Orders the monthly search volumes by descending year, then descending month.
            function (MonthlySearchVolume $volume1, MonthlySearchVolume $volume2) {
                $yearsCompared = $volume2->getYear() <=> $volume1->getYear();
                if ($yearsCompared != 0) {
                    return $yearsCompared;
                } else {
                    return $volume2->getMonth() <=> $volume1->getMonth();
                }
            }
        );
        // Prints each monthly search volume.
        array_walk($monthlySearchVolumes, function (MonthlySearchVolume $monthlySearchVolume) {
            printf(
                "Approximately %d searches in %s, %s.%s",
                $monthlySearchVolume->getMonthlySearches(),
                MonthOfYear::name($monthlySearchVolume->getMonth()),
                $monthlySearchVolume->getYear(),
                PHP_EOL
            );
        });
        print PHP_EOL;
    }
}
GenerateHistoricalMetrics.php
      

Python

def main(client: GoogleAdsClient, customer_id: str):
    """The main method that creates all necessary entities for the example.

    Args:
        client: an initialized GoogleAdsClient instance.
        customer_id: a client customer ID.
    """
    generate_historical_metrics(client, customer_id)


def generate_historical_metrics(client: GoogleAdsClient, customer_id: str):
    """Generates historical metrics and prints the results.

    Args:
        client: an initialized GoogleAdsClient instance.
        customer_id: a client customer ID.
    """
    googleads_service: GoogleAdsServiceClient = client.get_service(
        "GoogleAdsService"
    )
    keyword_plan_idea_service: KeywordPlanIdeaServiceClient = (
        client.get_service("KeywordPlanIdeaService")
    )
    request: GenerateKeywordHistoricalMetricsRequest = client.get_type(
        "GenerateKeywordHistoricalMetricsRequest"
    )
    request.customer_id = customer_id
    request.keywords = ["mars cruise", "cheap cruise", "jupiter cruise"]
    # Geo target constant 2840 is for USA.
    request.geo_target_constants.append(
        googleads_service.geo_target_constant_path("2840")
    )
    request.keyword_plan_network = (
        client.enums.KeywordPlanNetworkEnum.GOOGLE_SEARCH
    )
    # Language criteria 1000 is for English. For the list of language criteria
    # IDs, see:
    # https://developers.google.com/google-ads/api/reference/data/codes-formats#languages
    request.language = googleads_service.language_constant_path("1000")

    response: GenerateKeywordHistoricalMetricsResponse = (
        keyword_plan_idea_service.generate_keyword_historical_metrics(
            request=request
        )
    )

    results: Iterable[GenerateKeywordHistoricalMetricsResult] = response.results
    for result in results:
        metrics: KeywordPlanHistoricalMetrics = result.keyword_metrics
        # These metrics include those for both the search query and any variants
        # included in the response.
        print(
            f"The search query '{result.text}' (and the following variants: "
            f"'{result.close_variants if result.close_variants else 'None'}'), "
            "generated the following historical metrics:\n"
        )

        # Approximate number of monthly searches on this query averaged for the
        # past 12 months.
        print(f"\tApproximate monthly searches: {metrics.avg_monthly_searches}")

        # The competition level for this search query.
        print(f"\tCompetition level: {metrics.competition}")

        # The competition index for the query in the range [0, 100]. This shows
        # how competitive ad placement is for a keyword. The level of
        # competition from 0-100 is determined by the number of ad slots filled
        # divided by the total number of ad slots available. If not enough data
        # is available, undef will be returned.
        print(f"\tCompetition index: {metrics.competition_index}")

        # Top of page bid low range (20th percentile) in micros for the keyword.
        print(
            f"\tTop of page bid low range: {metrics.low_top_of_page_bid_micros}"
        )

        # Top of page bid high range (80th percentile) in micros for the
        # keyword.
        print(
            "\tTop of page bid high range: "
            f"{metrics.high_top_of_page_bid_micros}"
        )

        # Approximate number of searches on this query for the past twelve
        # months.
        months: Iterable[MonthlySearchVolume] = metrics.monthly_search_volumes
        for month in months:
            print(
                f"\tApproximately {month.monthly_searches} searches in "
                f"{month.month.name}, {month.year}"
            )
generate_historical_metrics.py
      

Ruby

def generate_historical_metrics(customer_id)
  # GoogleAdsClient will read a config file from
  # ENV['HOME']/google_ads_config.rb when called without parameters
  client = Google::Ads::GoogleAds::GoogleAdsClient.new

  # Generates historical metrics and prints the results.
  keyword_plan_idea_service = client.service.keyword_plan_idea

  response = keyword_plan_idea_service.generate_keyword_historical_metrics(
    customer_id: customer_id,
    keywords: ["mars cruise", "cheap cruise", "jupiter cruise"],
    keyword_plan_network: :GOOGLE_SEARCH,

    # For the list of geo target IDs, see:
    # https://developers.google.com/google-ads/api/reference/data/geotargets
    # Geo target constant 2840 is for USA.
    geo_target_constants: [client.path.geo_target_constant("2840")],

    # Language criteria 1000 is for English.
    # For the list of language criteria IDs, see:
    # https://developers.google.com/google-ads/api/reference/data/codes-formats#languages
    language: client.path.language_constant("1000"),
  )

  for result in response.results
    metrics = result.keyword_metrics
    # These metrics include those for both the search query and any variants
    # included in the response.
    puts"The search query '#{result.text}' (and the following variants: " \
        "'#{result.close_variants}'), " \
        "generated the following historical metrics:\n"


    # Approximate number of monthly searches on this query averaged for the
    # past 12 months.
    puts "\tApproximate monthly searches: #{metrics.avg_monthly_searches}"

    # The competition level for this search query.
    puts "\tCompetition level: #{metrics.competition}"

    # The competition index for the query in the range [0, 100]. This shows
    # how competitive ad placement is for a keyword. The level of
    # competition from 0-100 is determined by the number of ad slots filled
    # divided by the total number of ad slots available. If not enough data
    # is available, undef will be returned.
    puts "\tCompetition index: #{metrics.competition_index}"

    # Top of page bid low range (20th percentile) in micros for the keyword.
    puts "\tTop of page bid low range: #{metrics.low_top_of_page_bid_micros}"

    # Top of page bid high range (80th percentile) in micros for the
    # keyword.
    puts"\tTop of page bid high range: "
        "#{metrics.high_top_of_page_bid_micros}"

    # Approximate number of searches on this query for the past twelve
    # months.
    for month in metrics.monthly_search_volumes
      puts "\tApproximately #{month.monthly_searches} searches in "
           "#{month.month.name}, #{month.year}"
    end
  end
end
generate_historical_metrics.rb
      

Perl

sub generate_historical_metrics {
  my ($api_client, $customer_id) = @_;

  my $keyword_historical_metrics_response =
    $api_client->KeywordPlanIdeaService()->generate_keyword_historical_metrics({
      customerId => $customer_id,
      keywords   => ["mars cruise", "cheap cruise", "jupiter cruise"],
      # Geo target constant 2840 is for USA.
      geoTargetConstants => [
        Google::Ads::GoogleAds::V26::Utils::ResourceNames::geo_target_constant(
          2840)
      ],
      keywordPlanNetwork => 'GOOGLE_SEARCH',
      # Language criteria 1000 is for English. See
      # https://developers.google.com/google-ads/api/reference/data/codes-formats#languages
      # for the list of language criteria IDs.
      language =>
        Google::Ads::GoogleAds::V26::Utils::ResourceNames::language_constant(
        1000)});

  foreach my $result (@{$keyword_historical_metrics_response->{results}}) {
    my $metric = $result->{keywordMetrics};
    # These metrics include those for both the search query and any
    # variants included in the response.
    # If the metric is undefined, print (undef) as a placeholder.
    printf
"The search query, %s, (and the following variants: %s), generated the following historical metrics:\n",
      $result->{text},
      $result->{closeVariants}
      ? join(', ', $result->{closeVariants})
      : "(undef)";

    # Approximate number of monthly searches on this query averaged for
    # the past 12 months.
    printf "\tApproximate monthly searches: %s.\n",
      value_or_undef($metric->{avgMonthlySearches});

    # The competition level for this search query.
    printf "\tCompetition level: %s.\n", value_or_undef($metric->{competition});

    # The competition index for the query in the range [0, 100]. This shows how
    # competitive ad placement is for a keyword. The level of competition from
    # 0-100 is determined by the number of ad slots filled divided by the total
    # number of ad slots available. If not enough data is available, undef will
    # be returned.
    printf "\tCompetition index: %s.\n",
      value_or_undef($metric->{competitionIndex});

    # Top of page bid low range (20th percentile) in micros for the keyword.
    printf "\tTop of page bid low range: %s.\n",
      value_or_undef($metric->{lowTopOfPageBidMicros});

    # Top of page bid high range (80th percentile) in micros for the keyword.
    printf "\tTop of page bid high range: %s.\n",
      value_or_undef($metric->{highTopOfPageBidMicros});

    # Approximate number of searches on this query for the past twelve months.
    foreach my $month (@{$metric->{monthlySearchVolumes}}) {
      printf "\tApproximately %d searches in %s, %s.\n",
        $month->{monthlySearches}, $month->{month}, $month->{year};
    }
  }

  return 1;
}
generate_historical_metrics.pl
      

curl

참고: 이 단계의 직접 REST 코드 샘플은 여기에 제공되지 않지만 수동 REST 요청을 사용하여 이 작업을 수행할 수 있습니다.

Google Ads API REST 인터페이스 문서 및 메서드별 참조 페이지를 참고하세요. 프로토 정의를 기반으로 JSON 페이로드를 구성해야 합니다.

주요 리소스:

• REST 사용
• REST 인터페이스 구조
• JSON 필드 매핑
• 특정 서비스 및 메서드에 관한 REST API 참조를 확인하세요.

Google은 전월의 검색 데이터를 기반으로 월별 검색량과 같은 측정항목을 업데이트합니다.

UI에 매핑

다음 표에서는 KeywordPlanIdeaService.GenerateKeywordHistoricalMetrics 매개변수를 Google Ads UI의 키워드 플래너에 매핑합니다.

UI의 키워드 플래너	Google Ads API
키워드 입력	GenerateKeywordHistoricalMetricsRequest.keywords
위치	GenerateKeywordHistoricalMetricsRequest.geo_target_constants
언어	GenerateKeywordHistoricalMetricsRequest.language
검색 네트워크	GenerateKeywordHistoricalMetricsRequest.keyword_plan_network
기간	GenerateKeywordHistoricalMetricsRequest.historical_metrics_options
CPC 입찰가	HistoricalMetricsOptions.include_average_cpc