Generate Historical Metrics

Page Summary

The code examples demonstrate how to generate historical metrics for keyword planning using the Google Ads API in various programming languages (Java, C#, PHP, Python, Ruby, Perl).
The examples showcase how to specify keywords, geo-target constants (e.g., USA), and language constants (e.g., English) in the request to retrieve relevant historical data.
The output includes key metrics for each keyword, such as approximate monthly searches, competition level, competition index, and top-of-page bid ranges.
The examples also illustrate how to handle API responses and extract specific historical data points like monthly search volumes.

Java

 // Copyright 2023 Google LLC 
 // 
 // Licensed under the Apache License, Version 2.0 (the "License"); 
 // you may not use this file except in compliance with the License. 
 // You may obtain a copy of the License at 
 // 
 //     https://www.apache.org/licenses/LICENSE-2.0 
 // 
 // Unless required by applicable law or agreed to in writing, software 
 // distributed under the License is distributed on an "AS IS" BASIS, 
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
 // See the License for the specific language governing permissions and 
 // limitations under the License. 
 package 
  
 com.google.ads.googleads.examples.planning 
 ; 
 import 
  
 com.beust.jcommander.Parameter 
 ; 
 import 
  
 com.google.ads.googleads.examples.utils.ArgumentNames 
 ; 
 import 
  
 com.google.ads.googleads.examples.utils.CodeSampleParams 
 ; 
 import 
  
 com.google.ads.googleads.lib.GoogleAdsClient 
 ; 
 import 
  
 com.google.ads.googleads.v22.common.KeywordPlanHistoricalMetrics 
 ; 
 import 
  
 com.google.ads.googleads.v22.enums.KeywordPlanNetworkEnum.KeywordPlanNetwork 
 ; 
 import 
  
 com.google.ads.googleads.v22.errors.GoogleAdsError 
 ; 
 import 
  
 com.google.ads.googleads.v22.errors.GoogleAdsException 
 ; 
 import 
  
 com.google.ads.googleads.v22.services.GenerateKeywordHistoricalMetricsRequest 
 ; 
 import 
  
 com.google.ads.googleads.v22.services.GenerateKeywordHistoricalMetricsResponse 
 ; 
 import 
  
 com.google.ads.googleads.v22.services.GenerateKeywordHistoricalMetricsResult 
 ; 
 import 
  
 com.google.ads.googleads.v22.services.KeywordPlanIdeaServiceClient 
 ; 
 import 
  
 com.google.ads.googleads.v22.utils.ResourceNames 
 ; 
 import 
  
 com.google.common.base.Joiner 
 ; 
 import 
  
 com.google.common.collect.ComparisonChain 
 ; 
 import 
  
 java.io.FileNotFoundException 
 ; 
 import 
  
 java.io.IOException 
 ; 
 import 
  
 java.util.Arrays 
 ; 
 /** 
 * Generates historical metrics for keyword planning. 
 * 
 * <p>Guide: 
 * https://developers.google.com/google-ads/api/docs/keyword-planning/generate-historical-metrics 
 */ 
 public 
  
 class 
 GenerateHistoricalMetrics 
  
 { 
  
 private 
  
 static 
  
 class 
 GenerateForecastMetricsParams 
  
 extends 
  
 CodeSampleParams 
  
 { 
  
 @Parameter 
 ( 
 names 
  
 = 
  
 ArgumentNames 
 . 
 CUSTOMER_ID 
 ) 
  
 public 
  
 Long 
  
 customerId 
 ; 
  
 } 
  
 public 
  
 static 
  
 void 
  
 main 
 ( 
 String 
 [] 
  
 args 
 ) 
  
 { 
  
 GenerateForecastMetricsParams 
  
 params 
  
 = 
  
 new 
  
 GenerateForecastMetricsParams 
 (); 
  
 if 
  
 ( 
 ! 
 params 
 . 
 parseArguments 
 ( 
 args 
 )) 
  
 { 
  
 // Optional, specify the customer ID under which to create a new keyword plan. 
  
 params 
 . 
 customerId 
  
 = 
  
 Long 
 . 
 valueOf 
 ( 
 "INSERT_CUSTOMER_ID" 
 ); 
  
 } 
  
 GoogleAdsClient 
  
 googleAdsClient 
  
 = 
  
 null 
 ; 
  
 try 
  
 { 
  
 googleAdsClient 
  
 = 
  
 GoogleAdsClient 
 . 
 newBuilder 
 (). 
 fromPropertiesFile 
 (). 
 build 
 (); 
  
 } 
  
 catch 
  
 ( 
 FileNotFoundException 
  
 fnfe 
 ) 
  
 { 
  
 System 
 . 
 err 
 . 
 printf 
 ( 
  
 "Failed to load GoogleAdsClient configuration from file. Exception: %s%n" 
 , 
  
 fnfe 
 ); 
  
 System 
 . 
 exit 
 ( 
 1 
 ); 
  
 } 
  
 catch 
  
 ( 
 IOException 
  
 ioe 
 ) 
  
 { 
  
 System 
 . 
 err 
 . 
 printf 
 ( 
 "Failed to create GoogleAdsClient. Exception: %s%n" 
 , 
  
 ioe 
 ); 
  
 System 
 . 
 exit 
 ( 
 1 
 ); 
  
 } 
  
 try 
  
 { 
  
 new 
  
 GenerateHistoricalMetrics 
 (). 
 runExample 
 ( 
 googleAdsClient 
 , 
  
 params 
 . 
 customerId 
 ); 
  
 } 
  
 catch 
  
 ( 
 GoogleAdsException 
  
 gae 
 ) 
  
 { 
  
 // GoogleAdsException is the base class for most exceptions thrown by an API request. 
  
 // Instances of this exception have a message and a GoogleAdsFailure that contains a 
  
 // collection of GoogleAdsErrors that indicate the underlying causes of the 
  
 // GoogleAdsException. 
  
 System 
 . 
 err 
 . 
 printf 
 ( 
  
 "Request ID %s failed due to GoogleAdsException. Underlying errors:%n" 
 , 
  
 gae 
 . 
 getRequestId 
 ()); 
  
 int 
  
 i 
  
 = 
  
 0 
 ; 
  
 for 
  
 ( 
 GoogleAdsError 
  
 googleAdsError 
  
 : 
  
 gae 
 . 
 getGoogleAdsFailure 
 (). 
 getErrorsList 
 ()) 
  
 { 
  
 System 
 . 
 err 
 . 
 printf 
 ( 
 "  Error %d: %s%n" 
 , 
  
 i 
 ++ 
 , 
  
 googleAdsError 
 ); 
  
 } 
  
 System 
 . 
 exit 
 ( 
 1 
 ); 
  
 } 
  
 } 
  
 /** 
 * Runs the code example. 
 * 
 * @param googleAdsClient the Google Ads API client. 
 * @param customerId the client customer ID. 
 */ 
  
 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#

 // Copyright 2023 Google LLC 
 // 
 // Licensed under the Apache License, Version 2.0 (the "License"); 
 // you may not use this file except in compliance with the License. 
 // You may obtain a copy of the License at 
 // 
 //     http://www.apache.org/licenses/LICENSE-2.0 
 // 
 // Unless required by applicable law or agreed to in writing, software 
 // distributed under the License is distributed on an "AS IS" BASIS, 
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
 // See the License for the specific language governing permissions and 
 // limitations under the License. 
 using 
  
 CommandLine 
 ; 
 using 
  
 Google.Ads.Gax.Examples 
 ; 
 using 
  
 Google.Ads.GoogleAds.Lib 
 ; 
 using 
  
 Google.Ads.GoogleAds.V22.Common 
 ; 
 using 
  
 Google.Ads.GoogleAds.V22.Errors 
 ; 
 using 
  
 Google.Ads.GoogleAds.V22.Resources 
 ; 
 using 
  
 Google.Ads.GoogleAds.V22.Services 
 ; 
 using 
  
 System 
 ; 
 using 
  
 static 
  
 Google 
 . 
 Ads 
 . 
 GoogleAds 
 . 
 V22 
 . 
 Enums 
 . 
 KeywordPlanNetworkEnum 
 . 
 Types 
 ; 
 namespace 
  
 Google.Ads.GoogleAds.Examples.V22 
 ; 
 /// <summary> 
 /// This code example generates historical metrics for keyword planning. 
 /// Guide: https://developers.google.com/google-ads/api/docs/keyword-planning/generate-historical-metrics 
 /// </summary> 
 public 
  
 class 
  
 GenerateHistoricalMetrics 
  
 : 
  
 ExampleBase 
 { 
  
 /// <summary> 
  
 /// Command line options for running the <see cref="GenerateHistoricalMetrics"/> example. 
  
 /// </summary> 
  
 public 
  
 class 
  
 Options 
  
 : 
  
 OptionsBase 
  
 { 
  
 /// <summary> 
  
 /// The customer ID for which the call is made. 
  
 /// </summary> 
  
 [Option("customerId", Required = true, HelpText = 
 "The customer ID for which the call is made.")] 
  
 public 
  
 long 
  
 CustomerId 
  
 { 
  
 get 
 ; 
  
 set 
 ; 
  
 } 
  
 } 
  
 /// <summary> 
  
 /// Main method, to run this code example as a standalone application. 
  
 /// </summary> 
  
 /// <param name="args">The command line arguments.</param> 
  
 public 
  
 static 
  
 void 
  
 Main 
 ( 
 string 
 [] 
  
 args 
 ) 
  
 { 
  
 Options 
  
 options 
  
 = 
  
 ExampleUtilities 
 . 
 ParseCommandLine<Options> 
 ( 
 args 
 ); 
  
 GenerateHistoricalMetrics 
  
 codeExample 
  
 = 
  
 new 
  
 GenerateHistoricalMetrics 
 (); 
  
 Console 
 . 
 WriteLine 
 ( 
 codeExample 
 . 
 Description 
 ); 
  
 codeExample 
 . 
 Run 
 ( 
 new 
  
 GoogleAdsClient 
 (), 
  
 options 
 . 
 CustomerId 
 ); 
  
 } 
  
 /// <summary> 
  
 /// Returns a description about the code example. 
  
 /// </summary> 
  
 public 
  
 override 
  
 string 
  
 Description 
  
 = 
>  
 "This code example generates historical metrics for keyword planning." 
 ; 
  
 /// <summary> 
  
 /// Runs the code example. 
  
 /// </summary> 
  
 /// <param name="client">The Google Ads client.</param> 
  
 /// <param name="customerId">The customer ID for which the call is made.</param> 
  
 public 
  
 void 
  
 Run 
 ( 
 GoogleAdsClient 
  
 client 
 , 
  
 long 
  
 customerId 
 ) 
  
 { 
  
 KeywordPlanIdeaServiceClient 
  
 keywordPlanIdeaService 
  
 = 
  
 client 
 . 
 GetService 
 ( 
 Services 
 . 
 V22 
 . 
 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

< ?php 
 /** 
 * Copyright 2023 Google LLC 
 * 
 * Licensed under the Apache License, Version 2.0 (the "License"); 
 * you may not use this file except in compliance with the License. 
 * You may obtain a copy of the License at 
 * 
 *     https://www.apache.org/licenses/LICENSE-2.0 
 * 
 * Unless required by applicable law or agreed to in writing, software 
 * distributed under the License is distributed on an "AS IS" BASIS, 
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
 * See the License for the specific language governing permissions and 
 * limitations under the License. 
 */ 
 namespace Google\Ads\GoogleAds\Examples\Planning; 
 require __DIR__ . '/../../vendor/autoload.php'; 
 use GetOpt\GetOpt; 
 use Google\Ads\GoogleAds\Examples\Utils\ArgumentNames; 
 use Google\Ads\GoogleAds\Examples\Utils\ArgumentParser; 
 use Google\Ads\GoogleAds\Lib\OAuth2TokenBuilder; 
 use Google\Ads\GoogleAds\Lib\V22\GoogleAdsClient; 
 use Google\Ads\GoogleAds\Lib\V22\GoogleAdsClientBuilder; 
 use Google\Ads\GoogleAds\Lib\V22\GoogleAdsException; 
 use Google\Ads\GoogleAds\Util\V22\ResourceNames; 
 use Google\Ads\GoogleAds\V22\Common\MonthlySearchVolume; 
 use Google\Ads\GoogleAds\V22\Enums\KeywordPlanCompetitionLevelEnum\KeywordPlanCompetitionLevel; 
 use Google\Ads\GoogleAds\V22\Enums\KeywordPlanNetworkEnum\KeywordPlanNetwork; 
 use Google\Ads\GoogleAds\V22\Enums\MonthOfYearEnum\MonthOfYear; 
 use Google\Ads\GoogleAds\V22\Errors\GoogleAdsError; 
 use Google\Ads\GoogleAds\V22\Services\GenerateKeywordHistoricalMetricsRequest; 
 use Google\Ads\GoogleAds\V22\Services\GenerateKeywordHistoricalMetricsResult; 
 use Google\ApiCore\ApiException; 
 /** 
 * Generates historical metrics for keyword planning. 
 * 
 * Guide: 
 * https://developers.google.com/google-ads/api/docs/keyword-planning/generate-historical-metrics 
 */ 
 class GenerateHistoricalMetrics 
 { 
 private const CUSTOMER_ID = 'INSERT_CUSTOMER_ID_HERE'; 
 public static function main() 
 { 
 // Either pass the required parameters for this example on the command line, or insert them 
 // into the constants above. 
 $options = (new ArgumentParser())->parseCommandArguments([ 
 ArgumentNames::CUSTOMER_ID => GetOpt::REQUIRED_ARGUMENT 
 ]); 
 // Generate a refreshable OAuth2 credential for authentication. 
 $oAuth2Credential = (new OAuth2TokenBuilder())->fromFile()->build(); 
 // Construct a Google Ads client configured from a properties file and the 
 // OAuth2 credentials above. 
 $googleAdsClient = (new GoogleAdsClientBuilder())->fromFile() 
 ->withOAuth2Credential($oAuth2Credential) 
 ->build(); 
 try { 
 self::runExample( 
 $googleAdsClient, 
 $options[ArgumentNames::CUSTOMER_ID] ?: self::CUSTOMER_ID 
 ); 
 } catch (GoogleAdsException $googleAdsException) { 
 printf( 
 "Request with ID '%s' has failed.%sGoogle Ads failure details:%s", 
 $googleAdsException->getRequestId(), 
 PHP_EOL, 
 PHP_EOL 
 ); 
 foreach ($googleAdsException->getGoogleAdsFailure()->getErrors() as $error) { 
 /** @var GoogleAdsError $error */ 
 printf( 
 "\t%s: %s%s", 
 $error->getErrorCode()->getErrorCode(), 
 $error->getMessage(), 
 PHP_EOL 
 ); 
 } 
 exit(1); 
 } catch (ApiException $apiException) { 
 printf( 
 "ApiException was thrown with message '%s'.%s", 
 $apiException->getMessage(), 
 PHP_EOL 
 ); 
 exit(1); 
 } 
 } 
 /** 
 * Runs the example. 
 * 
 * @param GoogleAdsClient $googleAdsClient the Google Ads API client 
 * @param int $customerId the customer ID 
 */ 
 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::main(); 
   GenerateHistoricalMetrics.php

Python

 #!/usr/bin/env python 
 # Copyright 2023 Google LLC 
 # 
 # Licensed under the Apache License, Version 2.0 (the "License"); 
 # you may not use this file except in compliance with the License. 
 # You may obtain a copy of the License at 
 # 
 #     https://www.apache.org/licenses/LICENSE-2.0 
 # 
 # Unless required by applicable law or agreed to in writing, software 
 # distributed under the License is distributed on an "AS IS" BASIS, 
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
 # See the License for the specific language governing permissions and 
 # limitations under the License. 
 """This example generates historical metrics for keyword planning. 
 For more details see this guide: 
 https://developers.google.com/google-ads/api/docs/keyword-planning/generate-historical-metrics 
 """ 
 from 
  
 typing 
  
 import 
 Iterable 
 import 
  
 argparse 
 import 
  
 sys 
 from 
  
 google.ads.googleads.client 
  
 import 
 GoogleAdsClient 
 from 
  
 google.ads.googleads.errors 
  
 import 
 GoogleAdsException 
 from 
  
 google.ads.googleads.v22.common.types.keyword_plan_common 
  
 import 
 ( 
 KeywordPlanHistoricalMetrics 
 , 
 MonthlySearchVolume 
 , 
 ) 
 from 
  
 google.ads.googleads.v22.services.services.google_ads_service.client 
  
 import 
 ( 
 GoogleAdsServiceClient 
 , 
 ) 
 from 
  
 google.ads.googleads.v22.services.services.keyword_plan_idea_service.client 
  
 import 
 ( 
 KeywordPlanIdeaServiceClient 
 , 
 ) 
 from 
  
 google.ads.googleads.v22.services.types.keyword_plan_idea_service 
  
 import 
 ( 
 GenerateKeywordHistoricalMetricsRequest 
 , 
 GenerateKeywordHistoricalMetricsResponse 
 , 
 GenerateKeywordHistoricalMetricsResult 
 , 
 ) 
 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 
 " 
 \t 
 Approximate monthly searches: 
 { 
 metrics 
 . 
 avg_monthly_searches 
 } 
 " 
 ) 
 # The competition level for this search query. 
 print 
 ( 
 f 
 " 
 \t 
 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 ad slots available. If not enough data 
 # is available, undef will be returned. 
 print 
 ( 
 f 
 " 
 \t 
 Competition index: 
 { 
 metrics 
 . 
 competition_index 
 } 
 " 
 ) 
 # Top of page bid low range (20th percentile) in micros for the keyword. 
 print 
 ( 
 f 
 " 
 \t 
 Top 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 
 ( 
 " 
 \t 
 Top 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 
 " 
 \t 
 Approximately 
 { 
 month 
 . 
 monthly_searches 
 } 
 searches in " 
 f 
 " 
 { 
 month 
 . 
 month 
 . 
 name 
 } 
 , 
 { 
 month 
 . 
 year 
 } 
 " 
 ) 
 if 
 __name__ 
 == 
 "__main__" 
 : 
 parser 
 = 
 argparse 
 . 
 ArgumentParser 
 ( 
 description 
 = 
 "Generates forecast metrics for keyword planning." 
 ) 
 # 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 
 () 
 # GoogleAdsClient will read the google-ads.yaml configuration file in the 
 # home directory if none is specified. 
 googleads_client 
 = 
 GoogleAdsClient 
 . 
 load_from_storage 
 ( 
 version 
 = 
 "v22" 
 ) 
 try 
 : 
 main 
 ( 
 googleads_client 
 , 
 args 
 . 
 customer_id 
 ) 
 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 
 'Error with message " 
 { 
 error 
 . 
 message 
 } 
 ".' 
 ) 
 if 
 error 
 . 
 location 
 : 
 for 
 field_path_element 
 in 
 error 
 . 
 location 
 . 
 field_path_elements 
 : 
 print 
 ( 
 f 
 " 
 \t\t 
 On field: 
 { 
 field_path_element 
 . 
 field_name 
 } 
 " 
 ) 
 sys 
 . 
 exit 
 ( 
 1 
 ) 
   generate_historical_metrics 
 . 
 py

Ruby

 #!/usr/bin/env ruby 
 # Encoding: utf-8 
 # 
 # Copyright 2019 Google LLC 
 # 
 # Licensed under the Apache License, Version 2.0 (the "License"); 
 # you may not use this file except in compliance with the License. 
 # You may obtain a copy of the License at 
 # 
 #     https://www.apache.org/licenses/LICENSE-2.0 
 # 
 # Unless required by applicable law or agreed to in writing, software 
 # distributed under the License is distributed on an "AS IS" BASIS, 
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
 # See the License for the specific language governing permissions and 
 # limitations under the License. 
 # This example generates historical metrics for keyword planning. 
 # 
 # For more details see this guide: 
 # https://developers.google.com/google-ads/api/docs/keyword-planning/generate-historical-metrics 
 require 
  
 'optparse' 
 require 
  
 'google/ads/google_ads' 
 def 
  
 generate_forecast_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 
  
 " 
 \t 
 Approximate monthly searches: 
 #{ 
 metrics 
 . 
 avg_monthly_searches 
 } 
 " 
  
 # The competition level for this search query. 
  
 puts 
  
 " 
 \t 
 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 ad slots available. If not enough data 
  
 # is available, undef will be returned. 
  
 puts 
  
 " 
 \t 
 Competition index: 
 #{ 
 metrics 
 . 
 competition_index 
 } 
 " 
  
 # Top of page bid low range (20th percentile) in micros for the keyword. 
  
 puts 
  
 " 
 \t 
 Top 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 
 " 
 \t 
 Top 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 
  
 " 
 \t 
 Approximately 
 #{ 
 month 
 . 
 monthly_searches 
 } 
 searches in " 
  
 " 
 #{ 
 month 
 . 
 month 
 . 
 name 
 } 
 , 
 #{ 
 month 
 . 
 year 
 } 
 " 
  
 end 
  
 end 
 end 
 if 
  
 __FILE__ 
  
 == 
  
 $0 
  
 options 
  
 = 
  
 {} 
  
 # The following parameter(s) should be provided to run the example. You can 
  
 # either specify these by changing the INSERT_XXX_ID_HERE values below, or on 
  
 # the command line. 
  
 # 
  
 # Parameters passed on the command line will override any parameters set in 
  
 # code. 
  
 # 
  
 # Running the example with -h will print the command line usage. 
  
 options 
 [ 
 :customer_id 
 ] 
  
 = 
  
 'INSERT_CUSTOMER_ID_HERE' 
  
 OptionParser 
 . 
 new 
  
 do 
  
 | 
 opts 
 | 
  
 opts 
 . 
 banner 
  
 = 
  
 sprintf 
 ( 
 'Usage: %s [options]' 
 , 
  
 File 
 . 
 basename 
 ( 
 __FILE__ 
 )) 
  
 opts 
 . 
 separator 
  
 '' 
  
 opts 
 . 
 separator 
  
 'Options:' 
  
 opts 
 . 
 on 
 ( 
 '-C' 
 , 
  
 '--customer-id CUSTOMER-ID' 
 , 
  
 String 
 , 
  
 'Customer ID' 
 ) 
  
 do 
  
 | 
 v 
 | 
  
 options 
 [ 
 :customer_id 
 ] 
  
 = 
  
 v 
  
 end 
  
 opts 
 . 
 separator 
  
 '' 
  
 opts 
 . 
 separator 
  
 'Help:' 
  
 opts 
 . 
 on_tail 
 ( 
 '-h' 
 , 
  
 '--help' 
 , 
  
 'Show this message' 
 ) 
  
 do 
  
 puts 
  
 opts 
  
 exit 
  
 end 
  
 end 
 . 
 parse! 
  
 begin 
  
 generate_forecast_metrics 
 ( 
 options 
 . 
 fetch 
 ( 
 :customer_id 
 ) 
 . 
 tr 
 ( 
 "-" 
 , 
  
 "" 
 )) 
  
 rescue 
  
 Google 
 :: 
 Ads 
 :: 
 GoogleAds 
 :: 
 Errors 
 :: 
 GoogleAdsError 
  
 = 
>  
 e 
  
 e 
 . 
 failure 
 . 
 errors 
 . 
 each 
  
 do 
  
 | 
 error 
 | 
  
 STDERR 
 . 
 printf 
 ( 
 "Error with message: %s 
 \n 
 " 
 , 
  
 error 
 . 
 message 
 ) 
  
 if 
  
 error 
 . 
 location 
  
 error 
 . 
 location 
 . 
 field_path_elements 
 . 
 each 
  
 do 
  
 | 
 field_path_element 
 | 
  
 STDERR 
 . 
 printf 
 ( 
 " 
 \t 
 On field: %s 
 \n 
 " 
 , 
  
 field_path_element 
 . 
 field_name 
 ) 
  
 end 
  
 end 
  
 error 
 . 
 error_code 
 . 
 to_h 
 . 
 each 
  
 do 
  
 | 
 k 
 , 
  
 v 
 | 
  
 next 
  
 if 
  
 v 
  
 == 
  
 :UNSPECIFIED 
  
 STDERR 
 . 
 printf 
 ( 
 " 
 \t 
 Type: %s 
 \n\t 
 Code: %s 
 \n 
 " 
 , 
  
 k 
 , 
  
 v 
 ) 
  
 end 
  
 end 
  
 raise 
  
 end 
 end 
   generate_historical_metrics 
 . 
 rb

Perl

 #!/usr/bin/perl -w 
 # 
 # Copyright 2023, Google LLC 
 # 
 # Licensed under the Apache License, Version 2.0 (the "License"); 
 # you may not use this file except in compliance with the License. 
 # You may obtain a copy of the License at 
 # 
 #     http://www.apache.org/licenses/LICENSE-2.0 
 # 
 # Unless required by applicable law or agreed to in writing, software 
 # distributed under the License is distributed on an "AS IS" BASIS, 
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
 # See the License for the specific language governing permissions and 
 # limitations under the License. 
 # 
 # This example generates historical metrics for keyword planning. 
 # Guide: https://developers.google.com/google-ads/api/docs/keyword-planning/generate-historical-metrics 
 use 
  
 strict 
 ; 
 use 
  
 warnings 
 ; 
 use 
  
 utf8 
 ; 
 use 
  
 FindBin 
  
 qw($Bin) 
 ; 
 use 
  
 lib 
  
 "$Bin/../../lib" 
 ; 
 use 
  
 Google::Ads::GoogleAds::Client 
 ; 
 use 
  
 Google::Ads::GoogleAds::Utils::GoogleAdsHelper 
 ; 
 use 
  
 Google::Ads::GoogleAds::V22::Utils::ResourceNames 
 ; 
 use 
  
 Getopt::Long 
  
 qw(:config auto_help) 
 ; 
 use 
  
 Pod::Usage 
 ; 
 use 
  
 Cwd 
  
 qw(abs_path) 
 ; 
 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::V22::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::V22::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 
 ; 
 } 
 # Returns the input value as a string if it's defined, otherwise returns "(undef)". 
 sub 
  
 value_or_undef 
  
 { 
  
 my 
  
 ( 
 $value 
 ) 
  
 = 
  
 @_ 
 ; 
  
 return 
  
 $value 
  
 ? 
  
 "$value" 
  
 : 
  
 "(undef)" 
 ; 
 } 
 # Don't run the example if the file is being included. 
 if 
  
 ( 
 abs_path 
 ( 
 $0 
 ) 
  
 ne 
  
 abs_path 
 ( 
 __FILE__ 
 )) 
  
 { 
  
 return 
  
 1 
 ; 
 } 
 # Get Google Ads Client, credentials will be read from ~/googleads.properties. 
 my 
  
 $api_client 
  
 = 
  
 Google::Ads::GoogleAds:: 
 Client 
 - 
> new 
 (); 
 # By default examples are set to die on any server returned fault. 
 $api_client 
 - 
> set_die_on_faults 
 ( 
 1 
 ); 
 my 
  
 $customer_id 
  
 = 
  
 undef 
 ; 
 # Parameters passed on the command line will override any parameters set in code. 
 GetOptions 
 ( 
 "customer_id=s" 
  
 = 
>  
 \ 
 $customer_id 
 ); 
 # Print the help message if the parameters are not initialized in the code nor 
 # in the command line. 
 pod2usage 
 ( 
 2 
 ) 
  
 if 
  
 not 
  
 check_params 
 ( 
 $customer_id 
 ); 
 # Call the example. 
 generate_historical_metrics 
 ( 
 $api_client 
 , 
  
 $customer_id 
  
 =~ 
  
 s/-//g 
 r 
 ); 
 =pod 
 =head1 NAME 
 generate_historical_metrics 
 =head1 DESCRIPTION 
 This example generates historical metrics for keyword planning. 
 =head1 SYNOPSIS 
 generate_historical_metrics.pl [options] 
 -help                       Show the help message. 
 -customer_id                The Google Ads customer ID. 
 =cut 
   generate_historical_metrics 
 . 
 pl

Generate Historical Metrics Stay organized with collections Save and categorize content based on your preferences.

Page Summary

Java

C#

PHP

Python

Ruby

Perl

Generate Historical Metrics