Add Shopping Product Ad

Java

 // Copyright 2018 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.shoppingads 
 ; 
 import static 
  
 com.google.ads.googleads.examples.utils.CodeSampleHelper.getPrintableDateTime 
 ; 
 import static 
  
 com.google.ads.googleads.v21.enums.EuPoliticalAdvertisingStatusEnum.EuPoliticalAdvertisingStatus.DOES_NOT_CONTAIN_EU_POLITICAL_ADVERTISING 
 ; 
 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.v21.common.ListingGroupInfo 
 ; 
 import 
  
 com.google.ads.googleads.v21.common.ManualCpc 
 ; 
 import 
  
 com.google.ads.googleads.v21.common.ShoppingProductAdInfo 
 ; 
 import 
  
 com.google.ads.googleads.v21.enums.AdGroupAdStatusEnum.AdGroupAdStatus 
 ; 
 import 
  
 com.google.ads.googleads.v21.enums.AdGroupCriterionStatusEnum.AdGroupCriterionStatus 
 ; 
 import 
  
 com.google.ads.googleads.v21.enums.AdGroupStatusEnum.AdGroupStatus 
 ; 
 import 
  
 com.google.ads.googleads.v21.enums.AdGroupTypeEnum.AdGroupType 
 ; 
 import 
  
 com.google.ads.googleads.v21.enums.AdvertisingChannelTypeEnum.AdvertisingChannelType 
 ; 
 import 
  
 com.google.ads.googleads.v21.enums.BudgetDeliveryMethodEnum.BudgetDeliveryMethod 
 ; 
 import 
  
 com.google.ads.googleads.v21.enums.CampaignStatusEnum.CampaignStatus 
 ; 
 import 
  
 com.google.ads.googleads.v21.enums.ListingGroupTypeEnum.ListingGroupType 
 ; 
 import 
  
 com.google.ads.googleads.v21.errors.GoogleAdsError 
 ; 
 import 
  
 com.google.ads.googleads.v21.errors.GoogleAdsException 
 ; 
 import 
  
 com.google.ads.googleads.v21.resources.Ad 
 ; 
 import 
  
 com.google.ads.googleads.v21.resources.AdGroup 
 ; 
 import 
  
 com.google.ads.googleads.v21.resources.AdGroupAd 
 ; 
 import 
  
 com.google.ads.googleads.v21.resources.AdGroupCriterion 
 ; 
 import 
  
 com.google.ads.googleads.v21.resources.Campaign 
 ; 
 import 
  
 com.google.ads.googleads.v21.resources.Campaign.ShoppingSetting 
 ; 
 import 
  
 com.google.ads.googleads.v21.resources.CampaignBudget 
 ; 
 import 
  
 com.google.ads.googleads.v21.services.AdGroupAdOperation 
 ; 
 import 
  
 com.google.ads.googleads.v21.services.AdGroupAdServiceClient 
 ; 
 import 
  
 com.google.ads.googleads.v21.services.AdGroupCriterionOperation 
 ; 
 import 
  
 com.google.ads.googleads.v21.services.AdGroupCriterionServiceClient 
 ; 
 import 
  
 com.google.ads.googleads.v21.services.AdGroupOperation 
 ; 
 import 
  
 com.google.ads.googleads.v21.services.AdGroupServiceClient 
 ; 
 import 
  
 com.google.ads.googleads.v21.services.CampaignBudgetOperation 
 ; 
 import 
  
 com.google.ads.googleads.v21.services.CampaignBudgetServiceClient 
 ; 
 import 
  
 com.google.ads.googleads.v21.services.CampaignOperation 
 ; 
 import 
  
 com.google.ads.googleads.v21.services.CampaignServiceClient 
 ; 
 import 
  
 com.google.ads.googleads.v21.services.MutateAdGroupAdResult 
 ; 
 import 
  
 com.google.ads.googleads.v21.services.MutateAdGroupCriterionResult 
 ; 
 import 
  
 com.google.ads.googleads.v21.services.MutateAdGroupResult 
 ; 
 import 
  
 com.google.ads.googleads.v21.services.MutateCampaignBudgetsResponse 
 ; 
 import 
  
 com.google.ads.googleads.v21.services.MutateCampaignResult 
 ; 
 import 
  
 com.google.ads.googleads.v21.services.MutateCampaignsResponse 
 ; 
 import 
  
 com.google.common.collect.ImmutableList 
 ; 
 import 
  
 java.io.FileNotFoundException 
 ; 
 import 
  
 java.io.IOException 
 ; 
 import 
  
 java.util.Collections 
 ; 
 /** 
 * Creates a standard shopping campaign, a shopping product ad group and a shopping product ad. 
 * 
 * <p>Prerequisite: You need to have access to a Merchant Center account. You can find instructions 
 * to create a Merchant Center account here: https://support.google.com/merchants/answer/188924. 
 * This account must be linked to your Google Ads account. 
 */ 
 public 
  
 class 
 AddShoppingProductAd 
  
 { 
  
 private 
  
 static 
  
 class 
 AddShoppingProductAdParams 
  
 extends 
  
 CodeSampleParams 
  
 { 
  
 @Parameter 
 ( 
 names 
  
 = 
  
 ArgumentNames 
 . 
 CUSTOMER_ID 
 , 
  
 required 
  
 = 
  
 true 
 ) 
  
 private 
  
 Long 
  
 customerId 
 ; 
  
 @Parameter 
 ( 
 names 
  
 = 
  
 ArgumentNames 
 . 
 MERCHANT_CENTER_ACCOUNT_ID 
 , 
  
 required 
  
 = 
  
 true 
 ) 
  
 private 
  
 Long 
  
 merchantCenterAccountId 
 ; 
  
 @Parameter 
 ( 
 names 
  
 = 
  
 ArgumentNames 
 . 
 CREATE_DEFAULT_LISTING_GROUP 
 , 
  
 required 
  
 = 
  
 true 
 , 
  
 arity 
  
 = 
  
 1 
 ) 
  
 private 
  
 Boolean 
  
 createDefaultListingGroup 
 ; 
  
 } 
  
 public 
  
 static 
  
 void 
  
 main 
 ( 
 String 
 [] 
  
 args 
 ) 
  
 { 
  
 AddShoppingProductAdParams 
  
 params 
  
 = 
  
 new 
  
 AddShoppingProductAdParams 
 (); 
  
 if 
  
 ( 
 ! 
 params 
 . 
 parseArguments 
 ( 
 args 
 )) 
  
 { 
  
 // Either pass the required parameters for this example on the command line, or insert them 
  
 // into the code here. See the parameter class definition above for descriptions. 
  
 params 
 . 
 customerId 
  
 = 
  
 Long 
 . 
 parseLong 
 ( 
 "INSERT_CUSTOMER_ID_HERE" 
 ); 
  
 params 
 . 
 merchantCenterAccountId 
  
 = 
  
 Long 
 . 
 parseLong 
 ( 
 "INSERT_MERCHANT_CENTER_ACCOUNT_ID_HERE" 
 ); 
  
 params 
 . 
 createDefaultListingGroup 
  
 = 
  
 Boolean 
 . 
 parseBoolean 
 ( 
 "INSERT_CREATE_DEFAULT_LISTING_GROUP_HERE" 
 ); 
  
 } 
  
 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 
  
 AddShoppingProductAd 
 () 
  
 . 
 runExample 
 ( 
  
 googleAdsClient 
 , 
  
 params 
 . 
 customerId 
 , 
  
 params 
 . 
 merchantCenterAccountId 
 , 
  
 params 
 . 
 createDefaultListingGroup 
 ); 
  
 } 
  
 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 example. 
 * 
 * @param googleAdsClient the Google Ads API client. 
 * @param customerId the client customer ID. 
 * @param merchantCenterAccountId the Merchant Center account ID. 
 * @param createDefaultListingGroup the boolean to indicate if a default listing group should be 
 *     created for the ad group. Set to false if the listing group will be constructed elsewhere. 
 *     See AddShoppingProductListingGroupTree for a more comprehensive example. 
 * @throws GoogleAdsException if an API request failed with one or more service errors. 
 */ 
  
 private 
  
 void 
  
 runExample 
 ( 
  
 GoogleAdsClient 
  
 googleAdsClient 
 , 
  
 long 
  
 customerId 
 , 
  
 long 
  
 merchantCenterAccountId 
 , 
  
 boolean 
  
 createDefaultListingGroup 
 ) 
  
 { 
  
 // Creates a budget to be used by the campaign that will be created below. 
  
 String 
  
 budgetResourceName 
  
 = 
  
 addCampaignBudget 
 ( 
 googleAdsClient 
 , 
  
 customerId 
 ); 
  
 // Creates a standard shopping campaign. 
  
 String 
  
 campaignResourceName 
  
 = 
  
 addStandardShoppingCampaign 
 ( 
  
 googleAdsClient 
 , 
  
 customerId 
 , 
  
 budgetResourceName 
 , 
  
 merchantCenterAccountId 
 ); 
  
 // Creates a shopping product ad group. 
  
 String 
  
 adGroupResourceName 
  
 = 
  
 addShoppingProductAdGroup 
 ( 
 googleAdsClient 
 , 
  
 customerId 
 , 
  
 campaignResourceName 
 ); 
  
 // Creates a shopping product ad group ad. 
  
 addShoppingProductAdGroupAd 
 ( 
 googleAdsClient 
 , 
  
 customerId 
 , 
  
 adGroupResourceName 
 ); 
  
 if 
  
 ( 
 createDefaultListingGroup 
 ) 
  
 { 
  
 // Creates an ad group criterion containing a listing group. 
  
 // This will be the listing group tree for 'All products' and will contain a single biddable 
  
 // unit node. 
  
 addDefaultShoppingListingGroup 
 ( 
 googleAdsClient 
 , 
  
 customerId 
 , 
  
 adGroupResourceName 
 ); 
  
 } 
  
 } 
  
 /** 
 * Creates a new campaign budget in the specified client account. 
 * 
 * @param googleAdsClient the Google Ads API client. 
 * @param customerId the client customer ID. 
 * @return resource name of the newly created budget. 
 * @throws GoogleAdsException if an API request failed with one or more service errors. 
 */ 
  
 private 
  
 String 
  
 addCampaignBudget 
 ( 
 GoogleAdsClient 
  
 googleAdsClient 
 , 
  
 long 
  
 customerId 
 ) 
  
 { 
  
 CampaignBudget 
  
 budget 
  
 = 
  
 CampaignBudget 
 . 
 newBuilder 
 () 
  
 . 
 setName 
 ( 
 "Interplanetary Cruise Budget #" 
  
 + 
  
 getPrintableDateTime 
 ()) 
  
 . 
 setDeliveryMethod 
 ( 
 BudgetDeliveryMethod 
 . 
 STANDARD 
 ) 
  
 . 
 setAmountMicros 
 ( 
 5_000_000L 
 ) 
  
 . 
 build 
 (); 
  
 CampaignBudgetOperation 
  
 op 
  
 = 
  
 CampaignBudgetOperation 
 . 
 newBuilder 
 (). 
 setCreate 
 ( 
 budget 
 ). 
 build 
 (); 
  
 try 
  
 ( 
 CampaignBudgetServiceClient 
  
 campaignBudgetServiceClient 
  
 = 
  
 googleAdsClient 
 . 
 getLatestVersion 
 (). 
 createCampaignBudgetServiceClient 
 ()) 
  
 { 
  
 MutateCampaignBudgetsResponse 
  
 response 
  
 = 
  
 campaignBudgetServiceClient 
 . 
 mutateCampaignBudgets 
 ( 
  
 Long 
 . 
 toString 
 ( 
 customerId 
 ), 
  
 ImmutableList 
 . 
 of 
 ( 
 op 
 )); 
  
 String 
  
 budgetResourceName 
  
 = 
  
 response 
 . 
 getResults 
 ( 
 0 
 ). 
 getResourceName 
 (); 
  
 System 
 . 
 out 
 . 
 printf 
 ( 
 "Added a budget with resource name: '%s'%n" 
 , 
  
 budgetResourceName 
 ); 
  
 return 
  
 budgetResourceName 
 ; 
  
 } 
  
 } 
  
 /** 
 * Creates a new standard shopping campaign in the specified client account. 
 * 
 * @param googleAdsClient the Google Ads API client. 
 * @param customerId the client customer ID. 
 * @param budgetResourceName the resource name of the budget for the campaign. 
 * @param merchantCenterAccountId the Merchant Center account ID. 
 * @return resource name of the newly created campaign. 
 * @throws GoogleAdsException if an API request failed with one or more service errors. 
 */ 
  
 private 
  
 String 
  
 addStandardShoppingCampaign 
 ( 
  
 GoogleAdsClient 
  
 googleAdsClient 
 , 
  
 long 
  
 customerId 
 , 
  
 String 
  
 budgetResourceName 
 , 
  
 long 
  
 merchantCenterAccountId 
 ) 
  
 { 
  
 // Configures the shopping settings. 
  
 ShoppingSetting 
  
 shoppingSetting 
  
 = 
  
 ShoppingSetting 
 . 
 newBuilder 
 () 
  
 // Sets the priority of the campaign. Higher numbers take priority over lower numbers. 
  
 // For Shopping product ad campaigns, allowed values are between 0 and 2, inclusive. 
  
 . 
 setCampaignPriority 
 ( 
 0 
 ) 
  
 . 
 setMerchantId 
 ( 
 merchantCenterAccountId 
 ) 
  
 // Enables local inventory ads for this campaign. 
  
 . 
 setEnableLocal 
 ( 
 true 
 ) 
  
 . 
 build 
 (); 
  
 // Create the standard shopping campaign. 
  
 Campaign 
  
 campaign 
  
 = 
  
 Campaign 
 . 
 newBuilder 
 () 
  
 . 
 setName 
 ( 
 "Interplanetary Cruise #" 
  
 + 
  
 getPrintableDateTime 
 ()) 
  
 // Configures settings related to shopping campaigns including advertising channel type 
  
 // and shopping setting. 
  
 . 
 setAdvertisingChannelType 
 ( 
 AdvertisingChannelType 
 . 
 SHOPPING 
 ) 
  
 . 
 setShoppingSetting 
 ( 
 shoppingSetting 
 ) 
  
 // Recommendation: Sets the campaign to PAUSED when creating it to prevent 
  
 // the ads from immediately serving. Set to ENABLED once you've added 
  
 // targeting and the ads are ready to serve. 
  
 . 
 setStatus 
 ( 
 CampaignStatus 
 . 
 PAUSED 
 ) 
  
 // Sets the bidding strategy to Manual CPC 
  
 // Recommendation: Use one of the automated bidding strategies for Shopping campaigns 
  
 // to help you optimize your advertising spend. More information can be found here: 
  
 // https://support.google.com/google-ads/answer/6309029. 
  
 . 
 setManualCpc 
 ( 
 ManualCpc 
 . 
 getDefaultInstance 
 ()) 
  
 // Sets the budget. 
  
 . 
 setCampaignBudget 
 ( 
 budgetResourceName 
 ) 
  
 // Declares whether this campaign serves political ads targeting the EU. 
  
 . 
 setContainsEuPoliticalAdvertising 
 ( 
 DOES_NOT_CONTAIN_EU_POLITICAL_ADVERTISING 
 ) 
  
 . 
 build 
 (); 
  
 // Creates a campaign operation. 
  
 CampaignOperation 
  
 operation 
  
 = 
  
 CampaignOperation 
 . 
 newBuilder 
 (). 
 setCreate 
 ( 
 campaign 
 ). 
 build 
 (); 
  
 // Issues a mutate request to add the campaign. 
  
 try 
  
 ( 
 CampaignServiceClient 
  
 campaignServiceClient 
  
 = 
  
 googleAdsClient 
 . 
 getLatestVersion 
 (). 
 createCampaignServiceClient 
 ()) 
  
 { 
  
 MutateCampaignsResponse 
  
 response 
  
 = 
  
 campaignServiceClient 
 . 
 mutateCampaigns 
 ( 
  
 Long 
 . 
 toString 
 ( 
 customerId 
 ), 
  
 Collections 
 . 
 singletonList 
 ( 
 operation 
 )); 
  
 MutateCampaignResult 
  
 result 
  
 = 
  
 response 
 . 
 getResults 
 ( 
 0 
 ); 
  
 System 
 . 
 out 
 . 
 printf 
 ( 
  
 "Added a standard shopping campaign with resource name: '%s'%n" 
 , 
  
 result 
 . 
 getResourceName 
 ()); 
  
 return 
  
 result 
 . 
 getResourceName 
 (); 
  
 } 
  
 } 
  
 /** 
 * Creates a new shopping product ad group in the specified campaign. 
 * 
 * @param googleAdsClient the Google Ads API client. 
 * @param customerId the client customer ID. 
 * @param campaignResourceName the resource name of the shopping campaign that the new ad group 
 *     will belong to. 
 * @return resource name of the newly created ad group. 
 * @throws GoogleAdsException if an API request failed with one or more service errors. 
 */ 
  
 private 
  
 String 
  
 addShoppingProductAdGroup 
 ( 
  
 GoogleAdsClient 
  
 googleAdsClient 
 , 
  
 long 
  
 customerId 
 , 
  
 String 
  
 campaignResourceName 
 ) 
  
 { 
  
 // Creates an ad group. 
  
 AdGroup 
  
 adGroup 
  
 = 
  
 AdGroup 
 . 
 newBuilder 
 () 
  
 . 
 setName 
 ( 
 "Earth to Mars Cruises #" 
  
 + 
  
 getPrintableDateTime 
 ()) 
  
 . 
 setCampaign 
 ( 
 campaignResourceName 
 ) 
  
 // Sets the ad group type to SHOPPING_PRODUCT_ADS. This is the only value possible for 
  
 // ad groups that contain shopping product ads. 
  
 . 
 setType 
 ( 
 AdGroupType 
 . 
 SHOPPING_PRODUCT_ADS 
 ) 
  
 . 
 setCpcBidMicros 
 ( 
 1_000_000L 
 ) 
  
 . 
 setStatus 
 ( 
 AdGroupStatus 
 . 
 ENABLED 
 ) 
  
 . 
 build 
 (); 
  
 // Creates an ad group operation. 
  
 AdGroupOperation 
  
 operation 
  
 = 
  
 AdGroupOperation 
 . 
 newBuilder 
 (). 
 setCreate 
 ( 
 adGroup 
 ). 
 build 
 (); 
  
 // Issues a mutate request to add an ad group. 
  
 try 
  
 ( 
 AdGroupServiceClient 
  
 adGroupServiceClient 
  
 = 
  
 googleAdsClient 
 . 
 getLatestVersion 
 (). 
 createAdGroupServiceClient 
 ()) 
  
 { 
  
 MutateAdGroupResult 
  
 mutateAdGroupResult 
  
 = 
  
 adGroupServiceClient 
  
 . 
 mutateAdGroups 
 ( 
 Long 
 . 
 toString 
 ( 
 customerId 
 ), 
  
 Collections 
 . 
 singletonList 
 ( 
 operation 
 )) 
  
 . 
 getResults 
 ( 
 0 
 ); 
  
 System 
 . 
 out 
 . 
 printf 
 ( 
  
 "Added a product shopping ad group with resource name: '%s'%n" 
 , 
  
 mutateAdGroupResult 
 . 
 getResourceName 
 ()); 
  
 return 
  
 mutateAdGroupResult 
 . 
 getResourceName 
 (); 
  
 } 
  
 } 
  
 /** 
 * Creates a new shopping product ad group ad in the specified ad group. 
 * 
 * @param googleAdsClient the Google Ads API client. 
 * @param customerId the client customer ID. 
 * @param adGroupResourceName the resource name of the ad group that the new ad group ad will 
 *     belong to. 
 * @return resource name of the newly created ad group ad. 
 * @throws GoogleAdsException if an API request failed with one or more service errors. 
 */ 
  
 private 
  
 String 
  
 addShoppingProductAdGroupAd 
 ( 
  
 GoogleAdsClient 
  
 googleAdsClient 
 , 
  
 long 
  
 customerId 
 , 
  
 String 
  
 adGroupResourceName 
 ) 
  
 { 
  
 // Creates a new shopping product ad. 
  
 Ad 
  
 ad 
  
 = 
  
 Ad 
 . 
 newBuilder 
 (). 
 setShoppingProductAd 
 ( 
 ShoppingProductAdInfo 
 . 
 newBuilder 
 (). 
 build 
 ()). 
 build 
 (); 
  
 // Creates a new ad group ad and sets the shopping product ad to it. 
  
 AdGroupAd 
  
 adGroupAd 
  
 = 
  
 AdGroupAd 
 . 
 newBuilder 
 () 
  
 // Sets the ad to the ad created above. 
  
 . 
 setAd 
 ( 
 ad 
 ) 
  
 . 
 setStatus 
 ( 
 AdGroupAdStatus 
 . 
 PAUSED 
 ) 
  
 // Sets the ad group. 
  
 . 
 setAdGroup 
 ( 
 adGroupResourceName 
 ) 
  
 . 
 build 
 (); 
  
 // Creates an ad group ad operation. 
  
 AdGroupAdOperation 
  
 operation 
  
 = 
  
 AdGroupAdOperation 
 . 
 newBuilder 
 (). 
 setCreate 
 ( 
 adGroupAd 
 ). 
 build 
 (); 
  
 // Issues a mutate request to add an ad group ad. 
  
 try 
  
 ( 
 AdGroupAdServiceClient 
  
 adGroupAdServiceClient 
  
 = 
  
 googleAdsClient 
 . 
 getLatestVersion 
 (). 
 createAdGroupAdServiceClient 
 ()) 
  
 { 
  
 MutateAdGroupAdResult 
  
 mutateAdGroupAdResult 
  
 = 
  
 adGroupAdServiceClient 
  
 . 
 mutateAdGroupAds 
 ( 
 Long 
 . 
 toString 
 ( 
 customerId 
 ), 
  
 Collections 
 . 
 singletonList 
 ( 
 operation 
 )) 
  
 . 
 getResults 
 ( 
 0 
 ); 
  
 System 
 . 
 out 
 . 
 printf 
 ( 
  
 "Added a product shopping ad group ad with resource name: '%s'%n" 
 , 
  
 mutateAdGroupAdResult 
 . 
 getResourceName 
 ()); 
  
 return 
  
 mutateAdGroupAdResult 
 . 
 getResourceName 
 (); 
  
 } 
  
 } 
  
 /** 
 * Creates a new default shopping listing group for the specified ad group. A listing group is the 
 * Google Ads API representation of a "product group" described in the Google Ads user interface. 
 * The listing group will be added to the ad group using an "ad group criterion". The criterion 
 * will contain the bid for a given listing group. 
 * 
 * @param googleAdsClient the Google Ads API client. 
 * @param customerId the client customer ID. 
 * @param adGroupResourceName the resource name of the ad group that the new listing group will 
 *     belong to. 
 * @return resource name of the newly created ad group criterion containing the listing group. 
 * @throws GoogleAdsException if an API request failed with one or more service errors. 
 */ 
  
 private 
  
 String 
  
 addDefaultShoppingListingGroup 
 ( 
  
 GoogleAdsClient 
  
 googleAdsClient 
 , 
  
 long 
  
 customerId 
 , 
  
 String 
  
 adGroupResourceName 
 ) 
  
 { 
  
 // Creates a new ad group criterion. This will contain the "default" listing group (All 
  
 // products). 
  
 AdGroupCriterion 
  
 adGroupCriterion 
  
 = 
  
 AdGroupCriterion 
 . 
 newBuilder 
 () 
  
 . 
 setAdGroup 
 ( 
 adGroupResourceName 
 ) 
  
 . 
 setStatus 
 ( 
 AdGroupCriterionStatus 
 . 
 ENABLED 
 ) 
  
 // Creates a new listing group. This will be the top-level "root" node. 
  
 // Sets the type of the listing group to be a biddable unit. 
  
 . 
 setListingGroup 
 ( 
 ListingGroupInfo 
 . 
 newBuilder 
 (). 
 setType 
 ( 
 ListingGroupType 
 . 
 UNIT 
 ). 
 build 
 ()) 
  
 // Sets the bid for products in this listing group unit. 
  
 . 
 setCpcBidMicros 
 ( 
 500_000L 
 ) 
  
 . 
 build 
 (); 
  
 AdGroupCriterionOperation 
  
 operation 
  
 = 
  
 AdGroupCriterionOperation 
 . 
 newBuilder 
 (). 
 setCreate 
 ( 
 adGroupCriterion 
 ). 
 build 
 (); 
  
 try 
  
 ( 
 AdGroupCriterionServiceClient 
  
 adGroupCriterionServiceClient 
  
 = 
  
 googleAdsClient 
 . 
 getLatestVersion 
 (). 
 createAdGroupCriterionServiceClient 
 ()) 
  
 { 
  
 MutateAdGroupCriterionResult 
  
 mutateAdGroupCriteriaResult 
  
 = 
  
 adGroupCriterionServiceClient 
  
 . 
 mutateAdGroupCriteria 
 ( 
  
 Long 
 . 
 toString 
 ( 
 customerId 
 ), 
  
 Collections 
 . 
 singletonList 
 ( 
 operation 
 )) 
  
 . 
 getResults 
 ( 
 0 
 ); 
  
 System 
 . 
 out 
 . 
 printf 
 ( 
  
 "Added an ad group criterion containing a listing group with resource name: '%s'%n" 
 , 
  
 mutateAdGroupCriteriaResult 
 . 
 getResourceName 
 ()); 
  
 return 
  
 mutateAdGroupCriteriaResult 
 . 
 getResourceName 
 (); 
  
 } 
  
 } 
 } 
  
  

C#

 // 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 
 // 
 //     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.V21.Common 
 ; 
 using 
  
 Google.Ads.GoogleAds.V21.Errors 
 ; 
 using 
  
 Google.Ads.GoogleAds.V21.Resources 
 ; 
 using 
  
 Google.Ads.GoogleAds.V21.Services 
 ; 
 using 
  
 System 
 ; 
 using 
  
 static 
  
 Google 
 . 
 Ads 
 . 
 GoogleAds 
 . 
 V21 
 . 
 Enums 
 . 
 AdGroupAdStatusEnum 
 . 
 Types 
 ; 
 using 
  
 static 
  
 Google 
 . 
 Ads 
 . 
 GoogleAds 
 . 
 V21 
 . 
 Enums 
 . 
 AdGroupCriterionStatusEnum 
 . 
 Types 
 ; 
 using 
  
 static 
  
 Google 
 . 
 Ads 
 . 
 GoogleAds 
 . 
 V21 
 . 
 Enums 
 . 
 AdGroupStatusEnum 
 . 
 Types 
 ; 
 using 
  
 static 
  
 Google 
 . 
 Ads 
 . 
 GoogleAds 
 . 
 V21 
 . 
 Enums 
 . 
 AdGroupTypeEnum 
 . 
 Types 
 ; 
 using 
  
 static 
  
 Google 
 . 
 Ads 
 . 
 GoogleAds 
 . 
 V21 
 . 
 Enums 
 . 
 AdvertisingChannelTypeEnum 
 . 
 Types 
 ; 
 using 
  
 static 
  
 Google 
 . 
 Ads 
 . 
 GoogleAds 
 . 
 V21 
 . 
 Enums 
 . 
 BudgetDeliveryMethodEnum 
 . 
 Types 
 ; 
 using 
  
 static 
  
 Google 
 . 
 Ads 
 . 
 GoogleAds 
 . 
 V21 
 . 
 Enums 
 . 
 CampaignStatusEnum 
 . 
 Types 
 ; 
 using 
  
 static 
  
 Google 
 . 
 Ads 
 . 
 GoogleAds 
 . 
 V21 
 . 
 Enums 
 . 
 EuPoliticalAdvertisingStatusEnum 
 . 
 Types 
 ; 
 using 
  
 static 
  
 Google 
 . 
 Ads 
 . 
 GoogleAds 
 . 
 V21 
 . 
 Enums 
 . 
 ListingGroupTypeEnum 
 . 
 Types 
 ; 
 using 
  
 static 
  
 Google 
 . 
 Ads 
 . 
 GoogleAds 
 . 
 V21 
 . 
 Resources 
 . 
 Campaign 
 . 
 Types 
 ; 
 namespace 
  
 Google.Ads.GoogleAds.Examples.V21 
 { 
  
 /// <summary> 
  
 /// This code example creates a standard shopping campaign, a shopping product ad group and a 
  
 /// shopping product ad. 
  
 /// 
  
 /// Prerequisite: You need to have access to a Merchant Center account. You can find 
  
 /// instructions to create a Merchant Center account here: 
  
 /// https://support.google.com/merchants/answer/188924. 
  
 /// This account must be linked to your AdWords account.The integration instructions can be 
  
 /// found at: https://developers.google.com/adwords/shopping/full-automation/articles/t15. 
  
 /// </summary> 
  
 public 
  
 class 
  
 AddShoppingProductAd 
  
 : 
  
 ExampleBase 
  
 { 
  
 /// <summary> 
  
 /// Command line options for running the <see cref="AddShoppingProductAd"/> example. 
  
 /// </summary> 
  
 public 
  
 class 
  
 Options 
  
 : 
  
 OptionsBase 
  
 { 
  
 /// <summary> 
  
 /// The Google Ads customer ID for which the call is made. 
  
 /// </summary> 
  
 [Option("customerId", Required = true, HelpText = 
 "The Google Ads customer ID for which the call is made.")] 
  
 public 
  
 long 
  
 CustomerId 
  
 { 
  
 get 
 ; 
  
 set 
 ; 
  
 } 
  
 /// <summary> 
  
 /// The Merchant Center account ID. 
  
 /// </summary> 
  
 [Option("merchantCenterAccountId", Required = true, HelpText = 
 "The Merchant Center account ID.")] 
  
 public 
  
 long 
  
 MerchantCenterAccountId 
  
 { 
  
 get 
 ; 
  
 set 
 ; 
  
 } 
  
 /// <summary> 
  
 /// The boolean to indicate if a default listing group should be created for the ad 
  
 /// group. Set to false if the listing group will be constructed elsewhere. 
  
 /// See AddShoppingListingGroupTree for a more comprehensive example. 
  
 /// </summary> 
  
 [Option("createDefaultListingGroup", Required = true, HelpText = 
 "The boolean to indicate if a default listing group should be created for the " + 
 "ad group. Set to false if the listing group will be constructed elsewhere. " + 
 "See AddShoppingListingGroupTree for a more comprehensive example.")] 
  
 public 
  
 bool 
  
 CreateDefaultListingGroup 
  
 { 
  
 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 
 ); 
  
 AddShoppingProductAd 
  
 codeExample 
  
 = 
  
 new 
  
 AddShoppingProductAd 
 (); 
  
 Console 
 . 
 WriteLine 
 ( 
 codeExample 
 . 
 Description 
 ); 
  
 codeExample 
 . 
 Run 
 ( 
 new 
  
 GoogleAdsClient 
 (), 
  
 options 
 . 
 CustomerId 
 , 
  
 options 
 . 
 MerchantCenterAccountId 
 , 
  
 options 
 . 
 CreateDefaultListingGroup 
 ); 
  
 } 
  
 /// <summary> 
  
 /// Returns a description about the code example. 
  
 /// </summary> 
  
 public 
  
 override 
  
 string 
  
 Description 
  
 = 
>  
 "This code example creates a standard shopping campaign, a shopping product ad group " 
  
 + 
  
 "and a shopping product ad." 
  
 + 
  
 "\nPrerequisite: You need to have access to a Merchant Center account. You can find " 
  
 + 
  
 "instructions to create a Merchant Center account here: " 
  
 + 
  
 "https://support.google.com/merchants/answer/188924." 
  
 + 
  
 "\nThis account must be linked to your AdWords account.The integration instructions " 
  
 + 
  
 "can be found at: " 
  
 + 
  
 "https://developers.google.com/adwords/shopping/full-automation/articles/t15." 
 ; 
  
 /// <summary> 
  
 /// Runs the code example. 
  
 /// </summary> 
  
 /// <param name="client">The Google Ads client.</param> 
  
 /// <param name="customerId">The Google Ads customer ID for which the call is made.</param> 
  
 /// <param name="merchantCenterAccountId">The Merchant Center account ID.</param> 
  
 /// <param name="createDefaultListingGroup">The boolean to indicate if a default listing 
  
 /// group should be created for the ad group. Set to false if the listing group will be 
  
 /// constructed elsewhere. 
  
 /// 
  
 /// See AddShoppingListingGroupTree for a more comprehensive example.</param> 
  
 public 
  
 void 
  
 Run 
 ( 
 GoogleAdsClient 
  
 client 
 , 
  
 long 
  
 customerId 
 , 
  
 long 
  
 merchantCenterAccountId 
 , 
  
 bool 
  
 createDefaultListingGroup 
 ) 
  
 { 
  
 try 
  
 { 
  
 // Creates a budget to be used by the campaign that will be created below. 
  
 string 
  
 budgetResourceName 
  
 = 
  
 AddCampaignBudget 
 ( 
 client 
 , 
  
 customerId 
 ); 
  
 // Creates a standard shopping campaign. 
  
 string 
  
 campaignResourceName 
  
 = 
  
 AddStandardShoppingCampaign 
 ( 
  
 client 
 , 
  
 customerId 
 , 
  
 budgetResourceName 
 , 
  
 merchantCenterAccountId 
 ); 
  
 // Creates a product shopping ad group. 
  
 string 
  
 adGroupResourceName 
  
 = 
  
 AddProductShoppingAdGroup 
 ( 
  
 client 
 , 
  
 customerId 
 , 
  
 campaignResourceName 
 ); 
  
 // Creates a product shopping ad group ad. 
  
 AddProductShoppingAdGroupAd 
 ( 
 client 
 , 
  
 customerId 
 , 
  
 adGroupResourceName 
 ); 
  
 if 
  
 ( 
 createDefaultListingGroup 
 ) 
  
 { 
  
 // Creates an ad group criterion containing a listing group. 
  
 // This will be the listing group tree for 'All products' and will contain 
  
 // a single biddable unit node. 
  
 AddDefaultShoppingListingGroup 
 ( 
 client 
 , 
  
 customerId 
 , 
  
 adGroupResourceName 
 ); 
  
 } 
  
 } 
  
 catch 
  
 ( 
 GoogleAdsException 
  
 e 
 ) 
  
 { 
  
 Console 
 . 
 WriteLine 
 ( 
 "Failure:" 
 ); 
  
 Console 
 . 
 WriteLine 
 ( 
 $"Message: {e.Message}" 
 ); 
  
 Console 
 . 
 WriteLine 
 ( 
 $"Failure: {e.Failure}" 
 ); 
  
 Console 
 . 
 WriteLine 
 ( 
 $"Request ID: {e.RequestId}" 
 ); 
  
 throw 
 ; 
  
 } 
  
 } 
  
 /// <summary> 
  
 /// Creates a new campaign budget in the specified client account. 
  
 /// </summary> 
  
 /// <param name="client">The Google Ads API client.</param> 
  
 /// <param name="customerId">The client customer ID.</param> 
  
 /// <returns>Resource name of the newly created budget.</returns> 
  
 /// <exception cref="GoogleAdsException">Thrown if an API request failed with one or more 
  
 /// service errors.</exception> 
  
 private 
  
 string 
  
 AddCampaignBudget 
 ( 
 GoogleAdsClient 
  
 client 
 , 
  
 long 
  
 customerId 
 ) 
  
 { 
  
 // Get the CampaignBudgetService. 
  
 CampaignBudgetServiceClient 
  
 campaignBudgetService 
  
 = 
  
 client 
 . 
 GetService 
 ( 
 Services 
 . 
 V21 
 . 
 CampaignBudgetService 
 ); 
  
 CampaignBudget 
  
 budget 
  
 = 
  
 new 
  
 CampaignBudget 
 () 
  
 { 
  
 Name 
  
 = 
  
 "Interplanetary Cruise Budget #" 
  
 + 
  
 ExampleUtilities 
 . 
 GetRandomString 
 (), 
  
 DeliveryMethod 
  
 = 
  
 BudgetDeliveryMethod 
 . 
 Standard 
 , 
  
 AmountMicros 
  
 = 
  
 5 
 _000_000L 
  
 }; 
  
 CampaignBudgetOperation 
  
 operation 
  
 = 
  
 new 
  
 CampaignBudgetOperation 
 () 
  
 { 
  
 Create 
  
 = 
  
 budget 
  
 }; 
  
 MutateCampaignBudgetsResponse 
  
 response 
  
 = 
  
 campaignBudgetService 
 . 
 MutateCampaignBudgets 
 ( 
 customerId 
 . 
 ToString 
 (), 
  
 new 
  
 CampaignBudgetOperation 
 [] 
  
 { 
  
 operation 
  
 }); 
  
 string 
  
 budgetResourceName 
  
 = 
  
 response 
 . 
 Results 
 [ 
 0 
 ]. 
 ResourceName 
 ; 
  
 Console 
 . 
 WriteLine 
 ( 
 "Added a budget with resource name: '{0}'." 
 , 
  
 budgetResourceName 
 ); 
  
 return 
  
 budgetResourceName 
 ; 
  
 } 
  
 /// <summary> 
  
 ///  Creates a new standard shopping campaign in the specified client account. 
  
 /// </summary> 
  
 /// <param name="client">The Google Ads API client.</param> 
  
 /// <param name="customerId">The client customer ID.</param> 
  
 /// <param name="budgetResourceName">The resource name of the budget for the campaign. 
  
 /// </param> 
  
 /// <param name="merchantCenterAccountId">The Merchant Center account ID.</param> 
  
 /// <returns>Resource name of the newly created campaign.</returns> 
  
 /// <exception cref="GoogleAdsException">Thrown if an API request failed with one or more 
  
 /// service errors.</exception> 
  
 private 
  
 string 
  
 AddStandardShoppingCampaign 
 ( 
 GoogleAdsClient 
  
 client 
 , 
  
 long 
  
 customerId 
 , 
  
 string 
  
 budgetResourceName 
 , 
  
 long 
  
 merchantCenterAccountId 
 ) 
  
 { 
  
 // Get the CampaignService. 
  
 CampaignServiceClient 
  
 campaignService 
  
 = 
  
 client 
 . 
 GetService 
 ( 
 Services 
 . 
 V21 
 . 
 CampaignService 
 ); 
  
 // Configures the shopping settings. 
  
 ShoppingSetting 
  
 shoppingSetting 
  
 = 
  
 new 
  
 ShoppingSetting 
 () 
  
 { 
  
 // Sets the priority of the campaign. Higher numbers take priority over lower 
  
 // numbers. For Shopping Product Ad campaigns, allowed values are between 0 and 2, 
  
 // inclusive. 
  
 CampaignPriority 
  
 = 
  
 0 
 , 
  
 MerchantId 
  
 = 
  
 merchantCenterAccountId 
 , 
  
 // Enables local inventory ads for this campaign. 
  
 EnableLocal 
  
 = 
  
 true 
  
 }; 
  
 // Create the standard shopping campaign. 
  
 Campaign 
  
 campaign 
  
 = 
  
 new 
  
 Campaign 
 () 
  
 { 
  
 Name 
  
 = 
  
 "Interplanetary Cruise #" 
  
 + 
  
 ExampleUtilities 
 . 
 GetRandomString 
 (), 
  
 // Configures settings related to shopping campaigns including advertising channel 
  
 // type and shopping setting. 
  
 AdvertisingChannelType 
  
 = 
  
 AdvertisingChannelType 
 . 
 Shopping 
 , 
  
 ShoppingSetting 
  
 = 
  
 shoppingSetting 
 , 
  
 // Recommendation: Set the campaign to PAUSED when creating it to prevent 
  
 // the ads from immediately serving. Set to ENABLED once you've added 
  
 // targeting and the ads are ready to serve 
  
 Status 
  
 = 
  
 CampaignStatus 
 . 
 Paused 
 , 
  
 // Sets the bidding strategy to Manual CPC. 
  
 // Recommendation: Use one of the automated bidding strategies for Shopping 
  
 // campaigns to help you optimize your advertising spend. More information can be 
  
 // found here: https://support.google.com/google-ads/answer/6309029 
  
 ManualCpc 
  
 = 
  
 new 
  
 ManualCpc 
 (), 
  
 // Sets the budget. 
  
 CampaignBudget 
  
 = 
  
 budgetResourceName 
 , 
  
 // Declare whether or not this campaign contains political ads targeting the EU. 
  
 ContainsEuPoliticalAdvertising 
  
 = 
  
 EuPoliticalAdvertisingStatus 
 . 
 DoesNotContainEuPoliticalAdvertising 
 , 
  
 }; 
  
 // Creates a campaign operation. 
  
 CampaignOperation 
  
 operation 
  
 = 
  
 new 
  
 CampaignOperation 
 () 
  
 { 
  
 Create 
  
 = 
  
 campaign 
  
 }; 
  
 // Issues a mutate request to add the campaign. 
  
 MutateCampaignsResponse 
  
 response 
  
 = 
  
 campaignService 
 . 
 MutateCampaigns 
 ( 
 customerId 
 . 
 ToString 
 (), 
  
 new 
  
 CampaignOperation 
 [] 
  
 { 
  
 operation 
  
 }); 
  
 MutateCampaignResult 
  
 result 
  
 = 
  
 response 
 . 
 Results 
 [ 
 0 
 ]; 
  
 Console 
 . 
 WriteLine 
 ( 
 "Added a standard shopping campaign with resource name: '{0}'." 
 , 
  
 result 
 . 
 ResourceName 
 ); 
  
 return 
  
 result 
 . 
 ResourceName 
 ; 
  
 } 
  
 /// <summary> 
  
 /// Creates a new product shopping ad group in the specified campaign. 
  
 /// </summary> 
  
 /// <param name="client">The Google Ads API client.</param> 
  
 /// <param name="customerId">The client customer ID.</param> 
  
 /// <param name="campaignResourceName">Resource name of the shopping campaign that the 
  
 /// new ad group will belong to.</param> 
  
 /// <returns>Resource name of the newly created ad group.</returns> 
  
 /// <exception cref="GoogleAdsException">Thrown if an API request failed with one or more 
  
 /// service errors.</exception> 
  
 private 
  
 string 
  
 AddProductShoppingAdGroup 
 ( 
 GoogleAdsClient 
  
 client 
 , 
  
 long 
  
 customerId 
 , 
  
 string 
  
 campaignResourceName 
 ) 
  
 { 
  
 // Get the AdGroupService. 
  
 AdGroupServiceClient 
  
 adGroupService 
  
 = 
  
 client 
 . 
 GetService 
 ( 
 Services 
 . 
 V21 
 . 
 AdGroupService 
 ); 
  
 // Creates an ad group. 
  
 AdGroup 
  
 adGroup 
  
 = 
  
 new 
  
 AdGroup 
 () 
  
 { 
  
 Name 
  
 = 
  
 "Earth to Mars Cruises #" 
  
 + 
  
 ExampleUtilities 
 . 
 GetRandomString 
 (), 
  
 Campaign 
  
 = 
  
 campaignResourceName 
 , 
  
 // Sets the ad group type to SHOPPING_PRODUCT_ADS. This is the only value possible 
  
 // for ad groups that contain shopping product ads. 
  
 Type 
  
 = 
  
 AdGroupType 
 . 
 ShoppingProductAds 
 , 
  
 CpcBidMicros 
  
 = 
  
 1 
 _000_000L 
 , 
  
 Status 
  
 = 
  
 AdGroupStatus 
 . 
 Enabled 
  
 }; 
  
 // Creates an ad group operation. 
  
 AdGroupOperation 
  
 operation 
  
 = 
  
 new 
  
 AdGroupOperation 
 () 
  
 { 
  
 Create 
  
 = 
  
 adGroup 
  
 }; 
  
 // Issues a mutate request to add an ad group. 
  
 MutateAdGroupResult 
  
 mutateAdGroupResult 
  
 = 
  
 adGroupService 
  
 . 
 MutateAdGroups 
 ( 
 customerId 
 . 
 ToString 
 (), 
  
 new 
  
 AdGroupOperation 
 [] 
  
 { 
  
 operation 
  
 }) 
  
 . 
 Results 
 [ 
 0 
 ]; 
  
 Console 
 . 
 WriteLine 
 ( 
 "Added a product shopping ad group with resource name: '{0}'." 
 , 
  
 mutateAdGroupResult 
 . 
 ResourceName 
 ); 
  
 return 
  
 mutateAdGroupResult 
 . 
 ResourceName 
 ; 
  
 } 
  
 /// <summary> 
  
 /// Creates a new Shopping product ad group ad in the specified ad group. 
  
 /// </summary> 
  
 /// <param name="client">The Google Ads API client.</param> 
  
 /// <param name="customerId">The client customer ID.</param> 
  
 /// <param name="adGroupResourceName">The resource name of the ad group that the new ad 
  
 /// group ad will belong to.</param> 
  
 /// <returns>Resource name of the newly created ad group ad.</returns> 
  
 /// <exception cref="GoogleAdsException">Thrown if an API request failed with one or more 
  
 /// service errors.</exception> 
  
 private 
  
 string 
  
 AddProductShoppingAdGroupAd 
 ( 
 GoogleAdsClient 
  
 client 
 , 
  
 long 
  
 customerId 
 , 
  
 string 
  
 adGroupResourceName 
 ) 
  
 { 
  
 // Get the AdGroupAdService. 
  
 AdGroupAdServiceClient 
  
 adGroupAdService 
  
 = 
  
 client 
 . 
 GetService 
 ( 
  
 Services 
 . 
 V21 
 . 
 AdGroupAdService 
 ); 
  
 // Creates a new shopping product ad. 
  
 Ad 
  
 ad 
  
 = 
  
 new 
  
 Ad 
 () 
  
 { 
  
 ShoppingProductAd 
  
 = 
  
 new 
  
 ShoppingProductAdInfo 
 () 
  
 { 
  
 } 
  
 }; 
  
 // Creates a new ad group ad and sets the shopping product ad to it. 
  
 AdGroupAd 
  
 adGroupAd 
  
 = 
  
 new 
  
 AdGroupAd 
 () 
  
 { 
  
 // Sets the ad to the ad created above. 
  
 Ad 
  
 = 
  
 ad 
 , 
  
 Status 
  
 = 
  
 AdGroupAdStatus 
 . 
 Paused 
 , 
  
 // Sets the ad group. 
  
 AdGroup 
  
 = 
  
 adGroupResourceName 
  
 }; 
  
 // Creates an ad group ad operation. 
  
 AdGroupAdOperation 
  
 operation 
  
 = 
  
 new 
  
 AdGroupAdOperation 
 () 
  
 { 
  
 Create 
  
 = 
  
 adGroupAd 
  
 }; 
  
 // Issues a mutate request to add an ad group ad. 
  
 MutateAdGroupAdResult 
  
 mutateAdGroupAdResult 
  
 = 
  
 adGroupAdService 
 . 
 MutateAdGroupAds 
 ( 
  
 customerId 
 . 
 ToString 
 (), 
  
 new 
  
 AdGroupAdOperation 
 [] 
  
 { 
  
 operation 
  
 }). 
 Results 
 [ 
 0 
 ]; 
  
 Console 
 . 
 WriteLine 
 ( 
 "Added a product shopping ad group ad with resource name: '{0}'." 
 , 
  
 mutateAdGroupAdResult 
 . 
 ResourceName 
 ); 
  
 return 
  
 mutateAdGroupAdResult 
 . 
 ResourceName 
 ; 
  
 } 
  
 /// <summary> 
  
 /// Creates a new default shopping listing group for the specified ad group. A listing 
  
 /// group is the Google Ads API representation of a "product group" described in the 
  
 /// Google Ads user interface. The listing group will be added to the ad group using an 
  
 /// "ad group criterion". 
  
 /// </summary> 
  
 /// <param name="client">The Google Ads API client.</param> 
  
 /// <param name="customerId">The client customer ID.</param> 
  
 /// <param name="adGroupResourceName">The resource name of the ad group that the new 
  
 /// listing group will belong to.</param> 
  
 /// <returns>Resource name of the newly created ad group criterion containing the 
  
 /// listing group.</returns> 
  
 /// <exception cref="GoogleAdsException">Thrown if an API request failed with one or more 
  
 /// service errors.</exception> 
  
 private 
  
 string 
  
 AddDefaultShoppingListingGroup 
 ( 
 GoogleAdsClient 
  
 client 
 , 
  
 long 
  
 customerId 
 , 
  
 string 
  
 adGroupResourceName 
 ) 
  
 { 
  
 // Get the AdGroupCriterionService. 
  
 AdGroupCriterionServiceClient 
  
 adGroupCriterionService 
  
 = 
  
 client 
 . 
 GetService 
 ( 
  
 Services 
 . 
 V21 
 . 
 AdGroupCriterionService 
 ); 
  
 // Creates a new ad group criterion. This will contain the "default" listing group (All 
  
 // products). 
  
 AdGroupCriterion 
  
 adGroupCriterion 
  
 = 
  
 new 
  
 AdGroupCriterion 
 () 
  
 { 
  
 AdGroup 
  
 = 
  
 adGroupResourceName 
 , 
  
 Status 
  
 = 
  
 AdGroupCriterionStatus 
 . 
 Enabled 
 , 
  
 // Creates a new listing group. This will be the top-level "root" node. 
  
 // Set the type of the listing group to be a biddable unit. 
  
 ListingGroup 
  
 = 
  
 new 
  
 ListingGroupInfo 
 () 
  
 { 
  
 Type 
  
 = 
  
 ListingGroupType 
 . 
 Unit 
  
 }, 
  
 // Set the bid for products in this listing group unit. 
  
 CpcBidMicros 
  
 = 
  
 500 
 _000L 
  
 }; 
  
 AdGroupCriterionOperation 
  
 operation 
  
 = 
  
 new 
  
 AdGroupCriterionOperation 
 () 
  
 { 
  
 Create 
  
 = 
  
 adGroupCriterion 
  
 }; 
  
 MutateAdGroupCriterionResult 
  
 mutateAdGroupCriteriaResult 
  
 = 
  
 adGroupCriterionService 
 . 
 MutateAdGroupCriteria 
 ( 
 customerId 
 . 
 ToString 
 (), 
  
 new 
  
 AdGroupCriterionOperation 
 [] 
  
 { 
  
 operation 
  
 }). 
 Results 
 [ 
 0 
 ]; 
  
 Console 
 . 
 WriteLine 
 ( 
 "Added an ad group criterion containing a listing group with " 
  
 + 
  
 "resource name: '{0}'." 
 , 
  
 mutateAdGroupCriteriaResult 
 . 
 ResourceName 
 ); 
  
 return 
  
 mutateAdGroupCriteriaResult 
 . 
 ResourceName 
 ; 
  
 } 
  
 } 
 } 
  
  

PHP

< ?php 
 /** 
 * Copyright 2018 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\ShoppingAds; 
 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\Examples\Utils\Helper; 
 use Google\Ads\GoogleAds\Lib\V21\GoogleAdsClient; 
 use Google\Ads\GoogleAds\Lib\V21\GoogleAdsClientBuilder; 
 use Google\Ads\GoogleAds\Lib\V21\GoogleAdsException; 
 use Google\Ads\GoogleAds\Lib\OAuth2TokenBuilder; 
 use Google\Ads\GoogleAds\V21\Common\ListingGroupInfo; 
 use Google\Ads\GoogleAds\V21\Common\ManualCpc; 
 use Google\Ads\GoogleAds\V21\Common\ShoppingProductAdInfo; 
 use Google\Ads\GoogleAds\V21\Enums\AdGroupAdStatusEnum\AdGroupAdStatus; 
 use Google\Ads\GoogleAds\V21\Enums\AdGroupStatusEnum\AdGroupStatus; 
 use Google\Ads\GoogleAds\V21\Enums\AdGroupTypeEnum\AdGroupType; 
 use Google\Ads\GoogleAds\V21\Enums\AdvertisingChannelTypeEnum\AdvertisingChannelType; 
 use Google\Ads\GoogleAds\V21\Enums\BudgetDeliveryMethodEnum\BudgetDeliveryMethod; 
 use Google\Ads\GoogleAds\V21\Enums\CampaignStatusEnum\CampaignStatus; 
 use Google\Ads\GoogleAds\V21\Enums\EuPoliticalAdvertisingStatusEnum\EuPoliticalAdvertisingStatus; 
 use Google\Ads\GoogleAds\V21\Enums\ListingGroupTypeEnum\ListingGroupType; 
 use Google\Ads\GoogleAds\V21\Errors\GoogleAdsError; 
 use Google\Ads\GoogleAds\V21\Resources\Ad; 
 use Google\Ads\GoogleAds\V21\Resources\AdGroup; 
 use Google\Ads\GoogleAds\V21\Resources\AdGroupAd; 
 use Google\Ads\GoogleAds\V21\Resources\AdGroupCriterion; 
 use Google\Ads\GoogleAds\V21\Resources\Campaign; 
 use Google\Ads\GoogleAds\V21\Resources\Campaign\ShoppingSetting; 
 use Google\Ads\GoogleAds\V21\Resources\CampaignBudget; 
 use Google\Ads\GoogleAds\V21\Services\AdGroupAdOperation; 
 use Google\Ads\GoogleAds\V21\Services\AdGroupCriterionOperation; 
 use Google\Ads\GoogleAds\V21\Services\AdGroupOperation; 
 use Google\Ads\GoogleAds\V21\Services\CampaignBudgetOperation; 
 use Google\Ads\GoogleAds\V21\Services\CampaignOperation; 
 use Google\Ads\GoogleAds\V21\Services\MutateAdGroupAdsRequest; 
 use Google\Ads\GoogleAds\V21\Services\MutateAdGroupCriteriaRequest; 
 use Google\Ads\GoogleAds\V21\Services\MutateAdGroupsRequest; 
 use Google\Ads\GoogleAds\V21\Services\MutateCampaignBudgetsRequest; 
 use Google\Ads\GoogleAds\V21\Services\MutateCampaignsRequest; 
 use Google\ApiCore\ApiException; 
 /** 
 * This example creates a standard shopping campaign, a shopping product ad group and a shopping 
 * product ad. 
 * 
 * <p>Prerequisite: You need to have access to a Merchant Center account. You can find instructions 
 * to create a Merchant Center account here: https://support.google.com/merchants/answer/188924. 
 * This account must be linked to your Google Ads account. 
 */ 
 class AddShoppingProductAd 
 { 
 private const CUSTOMER_ID = 'INSERT_CUSTOMER_ID_HERE'; 
 private const MERCHANT_CENTER_ACCOUNT_ID = 'INSERT_MERCHANT_CENTER_ACCOUNT_ID_HERE'; 
 private const CREATE_DEFAULT_LISTING_GROUP = 'INSERT_BOOLEAN_TRUE_OR_FALSE_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, 
 ArgumentNames::MERCHANT_CENTER_ACCOUNT_ID => GetOpt::REQUIRED_ARGUMENT, 
 ArgumentNames::CREATE_DEFAULT_LISTING_GROUP => 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, 
 $options[ArgumentNames::MERCHANT_CENTER_ACCOUNT_ID] 
 ?: self::MERCHANT_CENTER_ACCOUNT_ID, 
 $options[ArgumentNames::CREATE_DEFAULT_LISTING_GROUP] 
 ?: self::CREATE_DEFAULT_LISTING_GROUP 
 ); 
 } 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 
 * @param int $merchantCenterAccountId the Merchant Center account ID 
 * @param bool $createDefaultListingGroup true if a default listing group should be 
 *     created for the ad group. Set to false if the listing group will be constructed 
 *     elsewhere. See AddShoppingProductListingGroupTree for a more comprehensive example 
 */ 
 public static function runExample( 
 GoogleAdsClient $googleAdsClient, 
 int $customerId, 
 int $merchantCenterAccountId, 
 bool $createDefaultListingGroup 
 ) { 
 // Creates a budget to be used by the campaign that will be created below. 
 $budgetResourceName = self::addCampaignBudget($googleAdsClient, $customerId); 
 // Creates a standard shopping campaign. 
 $campaignResourceName = self::addStandardShoppingCampaign( 
 $googleAdsClient, 
 $customerId, 
 $budgetResourceName, 
 $merchantCenterAccountId 
 ); 
 // Creates a shopping product ad group. 
 $adGroupResourceName = 
 self::addShoppingProductAdGroup($googleAdsClient, $customerId, $campaignResourceName); 
 // Creates a shopping product ad group ad. 
 self::addShoppingProductAdGroupAd($googleAdsClient, $customerId, $adGroupResourceName); 
 if ($createDefaultListingGroup === 'true') { 
 // Creates an ad group criterion containing a listing group. 
 // This will be the listing group tree for 'All products' and will contain a single 
 // biddable unit node. 
 self::addDefaultShoppingListingGroup( 
 $googleAdsClient, 
 $customerId, 
 $adGroupResourceName 
 ); 
 } 
 } 
 /** 
 * Creates a new campaign budget in the specified client account. 
 * 
 * @param GoogleAdsClient $googleAdsClient the Google Ads API client 
 * @param int $customerId the customer ID 
 * @return string the resource name of the newly created budget 
 */ 
 private static function addCampaignBudget(GoogleAdsClient $googleAdsClient, int $customerId) 
 { 
 // Creates a campaign budget. 
 $budget = new CampaignBudget([ 
 'name' => 'Interplanetary Cruise Budget #' . Helper::getPrintableDatetime(), 
 'delivery_method' => BudgetDeliveryMethod::STANDARD, 
 // Sets the amount of budget. 
 'amount_micros' => 50000000 
 ]); 
 // Creates a campaign budget operation. 
 $campaignBudgetOperation = new CampaignBudgetOperation(); 
 $campaignBudgetOperation->setCreate($budget); 
 // Issues a mutate request. 
 $campaignBudgetServiceClient = $googleAdsClient->getCampaignBudgetServiceClient(); 
 $response = $campaignBudgetServiceClient->mutateCampaignBudgets( 
 MutateCampaignBudgetsRequest::build($customerId, [$campaignBudgetOperation]) 
 ); 
 /** @var CampaignBudget $addedBudget */ 
 $addedBudget = $response->getResults()[0]; 
 printf( 
 "Added a budget with resource name '%s'.%s", 
 $addedBudget->getResourceName(), 
 PHP_EOL 
 ); 
 return $addedBudget->getResourceName(); 
 } 
 /** 
 * Creates a new shopping product campaign in the specified client account. 
 * 
 * @param GoogleAdsClient $googleAdsClient the Google Ads API client 
 * @param int $customerId the customer ID 
 * @param string $budgetResourceName the resource name of budget for a new campaign 
 * @param int $merchantCenterAccountId the Merchant Center account ID 
 * @return string the resource name of the newly created campaign 
 */ 
 private static function addStandardShoppingCampaign( 
 GoogleAdsClient $googleAdsClient, 
 int $customerId, 
 string $budgetResourceName, 
 int $merchantCenterAccountId 
 ) { 
 // Creates a standard shopping campaign. 
 $campaign = new Campaign([ 
 'name' => 'Interplanetary Cruise Campaign #' . Helper::getPrintableDatetime(), 
 // Configures settings related to shopping campaigns including advertising channel type 
 // and shopping setting. 
 'advertising_channel_type' => AdvertisingChannelType::SHOPPING, 
 // Configures the shopping settings. 
 'shopping_setting' => new ShoppingSetting([ 
 // Sets the priority of the campaign. Higher numbers take priority over lower 
 // numbers. For Shopping product ad campaigns, allowed values are between 0 and 2, 
 // inclusive. 
 'campaign_priority' => 0, 
 'merchant_id' => $merchantCenterAccountId, 
 // Enables local inventory ads for this campaign 
 'enable_local' => true 
 ]), 
 // Recommendation: Set the campaign to PAUSED when creating it to prevent 
 // the ads from immediately serving. Set to ENABLED once you've added 
 // targeting and the ads are ready to serve. 
 'status' => CampaignStatus::PAUSED, 
 // Sets the bidding strategy to Manual CPC. 
 // Recommendation: Use one of the automated bidding strategies for Shopping campaigns 
 // to help you optimize your advertising spend. More information can be found here: 
 // https://support.google.com/google-ads/answer/6309029. 
 'manual_cpc' => new ManualCpc(), 
 // Sets the budget. 
 'campaign_budget' => $budgetResourceName, 
 // Declare whether or not this campaign serves political ads targeting the EU. 
 'contains_eu_political_advertising' = 
> EuPoliticalAdvertisingStatus::DOES_NOT_CONTAIN_EU_POLITICAL_ADVERTISING 
 ]); 
 // Creates a campaign operation. 
 $campaignOperation = new CampaignOperation(); 
 $campaignOperation->setCreate($campaign); 
 // Issues a mutate request to add campaigns. 
 $campaignServiceClient = $googleAdsClient->getCampaignServiceClient(); 
 $response = $campaignServiceClient->mutateCampaigns( 
 MutateCampaignsRequest::build($customerId, [$campaignOperation]) 
 ); 
 /** @var Campaign $addedCampaign */ 
 $addedCampaign = $response->getResults()[0]; 
 printf( 
 "Added a standard shopping campaign with resource name '%s'.%s", 
 $addedCampaign->getResourceName(), 
 PHP_EOL 
 ); 
 return $addedCampaign->getResourceName(); 
 } 
 /** 
 * Creates a new shopping product ad group in the specified campaign. 
 * 
 * @param GoogleAdsClient $googleAdsClient the Google Ads API client 
 * @param int $customerId the customer ID 
 * @param string $campaignResourceName the resource name of campaign that a new ad group will 
 *     belong to 
 * @return string the resource name of the newly created ad group 
 */ 
 private static function addShoppingProductAdGroup( 
 GoogleAdsClient $googleAdsClient, 
 int $customerId, 
 string $campaignResourceName 
 ) { 
 // Creates an ad group. 
 $adGroup = new AdGroup([ 
 'name' => 'Earth to Mars Cruise #' . Helper::getPrintableDatetime(), 
 // Sets the campaign. 
 'campaign' => $campaignResourceName, 
 // Sets the ad group type to SHOPPING_PRODUCT_ADS. This is the only value possible for 
 // ad groups that contain shopping product ads. 
 'type' => AdGroupType::SHOPPING_PRODUCT_ADS, 
 'cpc_bid_micros' => 10000000, 
 'status' => AdGroupStatus::ENABLED 
 ]); 
 // Creates an ad group operation. 
 $adGroupOperation = new AdGroupOperation(); 
 $adGroupOperation->setCreate($adGroup); 
 // Issues a mutate request to add an ad group. 
 $adGroupServiceClient = $googleAdsClient->getAdGroupServiceClient(); 
 $response = $adGroupServiceClient->mutateAdGroups( 
 MutateAdGroupsRequest::build($customerId, [$adGroupOperation]) 
 ); 
 /** @var AdGroup $addedAdGroup */ 
 $addedAdGroup = $response->getResults()[0]; 
 printf( 
 "Added a shopping product ad group with resource name '%s'.%s", 
 $addedAdGroup->getResourceName(), 
 PHP_EOL 
 ); 
 return $addedAdGroup->getResourceName(); 
 } 
 /** 
 * Creates a new shopping product ad group ad in the specified ad group. 
 * 
 * @param GoogleAdsClient $googleAdsClient the Google Ads API client 
 * @param int $customerId the customer ID 
 * @param string $adGroupResourceName the resource name of ad group that a new ad group ad will 
 *     belong to 
 */ 
 private static function addShoppingProductAdGroupAd( 
 GoogleAdsClient $googleAdsClient, 
 int $customerId, 
 string $adGroupResourceName 
 ) { 
 // Creates a new shopping product ad. 
 $ad = new Ad(['shopping_product_ad' => new ShoppingProductAdInfo()]); 
 // Creates a new ad group ad and sets the shopping product ad to it. 
 $adGroupAd = new AdGroupAd([ 
 'ad' => $ad, 
 'status' => AdGroupAdStatus::PAUSED, 
 // Sets the ad group. 
 'ad_group' => $adGroupResourceName 
 ]); 
 // Creates an ad group ad operation. 
 $adGroupAdOperation = new AdGroupAdOperation(); 
 $adGroupAdOperation->setCreate($adGroupAd); 
 // Issues a mutate request to add an ad group ad. 
 $adGroupAdServiceClient = $googleAdsClient->getAdGroupAdServiceClient(); 
 $response = $adGroupAdServiceClient->mutateAdGroupAds( 
 MutateAdGroupAdsRequest::build($customerId, [$adGroupAdOperation]) 
 ); 
 /** @var AdGroupAd $addedAdGroupAd */ 
 $addedAdGroupAd = $response->getResults()[0]; 
 printf( 
 "Added a shopping product ad group ad with resource name '%s'.%s", 
 $addedAdGroupAd->getResourceName(), 
 PHP_EOL 
 ); 
 } 
 /** 
 * Creates a new default shopping listing group for the specified ad group. A listing group is 
 * the Google Ads API representation of a "product group" described in the Google Ads user 
 * interface. The listing group will be added to the ad group using an "ad group criterion". 
 * The criterion will contain the bid for a given listing group. 
 * 
 * @param GoogleAdsClient $googleAdsClient the Google Ads API client 
 * @param int $customerId the customer ID 
 * @param string $adGroupResourceName the resource name of ad group that the new listing group 
 *     will belong to 
 */ 
 private static function addDefaultShoppingListingGroup( 
 GoogleAdsClient $googleAdsClient, 
 int $customerId, 
 string $adGroupResourceName 
 ) { 
 // Creates a new ad group criterion. This will contain the "default" listing group (All 
 // products). 
 $adGroupCriterion = new AdGroupCriterion([ 
 'ad_group' => $adGroupResourceName, 
 'status' => AdGroupAdStatus::ENABLED, 
 // Creates a new listing group. This will be the top-level "root" node. 
 // Set the type of the listing group to be a biddable unit. 
 'listing_group' => new ListingGroupInfo(['type' => ListingGroupType::UNIT]), 
 // Set the bid for products in this listing group unit. 
 'cpc_bid_micros' => 500000 
 ]); 
 // Creates an ad group criterion operation. 
 $adGroupCriterionOperation = new AdGroupCriterionOperation(); 
 $adGroupCriterionOperation->setCreate($adGroupCriterion); 
 // Issues a mutate request to add an ad group criterion. 
 $adGroupCriterionServiceClient = $googleAdsClient->getAdGroupCriterionServiceClient(); 
 $response = $adGroupCriterionServiceClient->mutateAdGroupCriteria( 
 MutateAdGroupCriteriaRequest::build($customerId, [$adGroupCriterionOperation]) 
 ); 
 /** @var AdGroupCriterion $addedAdGroupCriterion */ 
 $addedAdGroupCriterion = $response->getResults()[0]; 
 printf( 
 "Added an ad group criterion containing a listing group with resource name: '%s'.%s", 
 $addedAdGroupCriterion->getResourceName(), 
 PHP_EOL 
 ); 
 } 
 } 
 AddShoppingProductAd::main(); 
  
  

Python

 #!/usr/bin/env python 
 # Copyright 2018 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 creates a standard shopping product ad. 
 In the process of creating a standard shopping campaign and a shopping product 
 ad group are also created. 
 Prerequisite: You need to have access to a Merchant Center account. You can find 
 instructions to create a Merchant Center account here: 
 https://support.google.com/merchants/answer/188924. 
 This account must be linked to your Google Ads account. 
 """ 
 import 
  
 argparse 
 import 
  
 sys 
 import 
  
 uuid 
 from 
  
 google.ads.googleads.client 
  
 import 
 GoogleAdsClient 
 from 
  
 google.ads.googleads.errors 
  
 import 
 GoogleAdsException 
 from 
  
 google.ads.googleads.v21.resources.types.ad_group 
  
 import 
 AdGroup 
 from 
  
 google.ads.googleads.v21.resources.types.ad_group_ad 
  
 import 
 AdGroupAd 
 from 
  
 google.ads.googleads.v21.resources.types.ad_group_criterion 
  
 import 
 ( 
 AdGroupCriterion 
 , 
 ) 
 from 
  
 google.ads.googleads.v21.resources.types.campaign 
  
 import 
 Campaign 
 from 
  
 google.ads.googleads.v21.resources.types.campaign_budget 
  
 import 
 ( 
 CampaignBudget 
 , 
 ) 
 from 
  
 google.ads.googleads.v21.services.services.ad_group_ad_service 
  
 import 
 ( 
 AdGroupAdServiceClient 
 , 
 ) 
 from 
  
 google.ads.googleads.v21.services.services.ad_group_criterion_service 
  
 import 
 ( 
 AdGroupCriterionServiceClient 
 , 
 ) 
 from 
  
 google.ads.googleads.v21.services.services.ad_group_service 
  
 import 
 ( 
 AdGroupServiceClient 
 , 
 ) 
 from 
  
 google.ads.googleads.v21.services.services.campaign_budget_service 
  
 import 
 ( 
 CampaignBudgetServiceClient 
 , 
 ) 
 from 
  
 google.ads.googleads.v21.services.services.campaign_service 
  
 import 
 ( 
 CampaignServiceClient 
 , 
 ) 
 from 
  
 google.ads.googleads.v21.services.types.ad_group_ad_service 
  
 import 
 ( 
 AdGroupAdOperation 
 , 
 ) 
 from 
  
 google.ads.googleads.v21.services.types.ad_group_criterion_service 
  
 import 
 ( 
 AdGroupCriterionOperation 
 , 
 ) 
 from 
  
 google.ads.googleads.v21.services.types.ad_group_service 
  
 import 
 ( 
 AdGroupOperation 
 , 
 ) 
 from 
  
 google.ads.googleads.v21.services.types.campaign_budget_service 
  
 import 
 ( 
 CampaignBudgetOperation 
 , 
 ) 
 from 
  
 google.ads.googleads.v21.services.types.campaign_service 
  
 import 
 ( 
 CampaignOperation 
 , 
 ) 
 def 
  
 main 
 ( 
 client 
 : 
 GoogleAdsClient 
 , 
 customer_id 
 : 
 str 
 , 
 merchant_center_account_id 
 : 
 int 
 , 
 create_default_listing_group 
 : 
 bool 
 , 
 ) 
 - 
> None 
 : 
 # Creates a budget to be used by the campaign that will be created below. 
 budget_resource_name 
 : 
 str 
 = 
 add_campaign_budget 
 ( 
 client 
 , 
 customer_id 
 ) 
 # Create a standard shopping campaign. 
 campaign_resource_name 
 : 
 str 
 = 
 add_standard_shopping_campaign 
 ( 
 client 
 , 
 customer_id 
 , 
 budget_resource_name 
 , 
 merchant_center_account_id 
 ) 
 # Create a shopping product ad group. 
 ad_group_resource_name 
 : 
 str 
 = 
 add_shopping_product_ad_group 
 ( 
 client 
 , 
 customer_id 
 , 
 campaign_resource_name 
 ) 
 # Create a shopping product ad group ad. 
 add_shopping_product_ad_group_ad 
 ( 
 client 
 , 
 customer_id 
 , 
 ad_group_resource_name 
 ) 
 if 
 create_default_listing_group 
 : 
 # Creates an ad group criterion containing a listing group. 
 # This will be the listing group tree for 'All products' and will 
 # contain a single biddable unit node. 
 add_default_shopping_listing_group 
 ( 
 client 
 , 
 customer_id 
 , 
 ad_group_resource_name 
 ) 
 def 
  
 add_campaign_budget 
 ( 
 client 
 : 
 GoogleAdsClient 
 , 
 customer_id 
 : 
 str 
 ) 
 - 
> str 
 : 
  
 """Creates a new campaign budget in the specified client account.""" 
 campaign_budget_service 
 : 
 CampaignBudgetServiceClient 
 = 
 client 
 . 
 get_service 
 ( 
 "CampaignBudgetService" 
 ) 
 # Create a budget, which can be shared by multiple campaigns. 
 campaign_budget_operation 
 : 
 CampaignBudgetOperation 
 = 
 client 
 . 
 get_type 
 ( 
 "CampaignBudgetOperation" 
 ) 
 campaign_budget 
 : 
 CampaignBudget 
 = 
 campaign_budget_operation 
 . 
 create 
 campaign_budget 
 . 
 name 
 = 
 f 
 "Interplanetary Budget 
 { 
 uuid 
 . 
 uuid4 
 () 
 } 
 " 
 campaign_budget 
 . 
 delivery_method 
 = 
 ( 
 client 
 . 
 enums 
 . 
 BudgetDeliveryMethodEnum 
 . 
 STANDARD 
 ) 
 campaign_budget 
 . 
 amount_micros 
 = 
 500000 
 # Add budget. 
 campaign_budget_response 
 = 
 campaign_budget_service 
 . 
 mutate_campaign_budgets 
 ( 
 customer_id 
 = 
 customer_id 
 , 
 operations 
 = 
 [ 
 campaign_budget_operation 
 ] 
 ) 
 budget_resource_name 
 : 
 str 
 = 
 campaign_budget_response 
 . 
 results 
 [ 
 0 
 ] 
 . 
 resource_name 
 print 
 ( 
 f 
 "Added a budget with resource name: ' 
 { 
 budget_resource_name 
 } 
 '" 
 ) 
 return 
 budget_resource_name 
 def 
  
 add_shopping_product_ad_group_ad 
 ( 
 client 
 : 
 GoogleAdsClient 
 , 
 customer_id 
 : 
 str 
 , 
 ad_group_resource_name 
 : 
 str 
 , 
 ) 
 - 
> str 
 : 
  
 """Creates a new shopping product ad group ad in the specified ad group.""" 
 ad_group_ad_service 
 : 
 AdGroupAdServiceClient 
 = 
 client 
 . 
 get_service 
 ( 
 "AdGroupAdService" 
 ) 
 # Creates a new ad group ad and sets the product ad to it. 
 ad_group_ad_operation 
 : 
 AdGroupAdOperation 
 = 
 client 
 . 
 get_type 
 ( 
 "AdGroupAdOperation" 
 ) 
 ad_group_ad 
 : 
 AdGroupAd 
 = 
 ad_group_ad_operation 
 . 
 create 
 ad_group_ad 
 . 
 ad_group 
 = 
 ad_group_resource_name 
 ad_group_ad 
 . 
 status 
 = 
 client 
 . 
 enums 
 . 
 AdGroupAdStatusEnum 
 . 
 PAUSED 
 # The Ad object itself is not directly manipulated for Shopping Product Ads. 
 # Instead, we copy ShoppingProductAdInfo into the ad's shopping_product_ad field. 
 client 
 . 
 copy_from 
 ( 
 ad_group_ad 
 . 
 ad 
 . 
 shopping_product_ad 
 , 
 client 
 . 
 get_type 
 ( 
 "ShoppingProductAdInfo" 
 ), 
 ) 
 # Add the ad group ad. 
 ad_group_ad_response 
 = 
 ad_group_ad_service 
 . 
 mutate_ad_group_ads 
 ( 
 customer_id 
 = 
 customer_id 
 , 
 operations 
 = 
 [ 
 ad_group_ad_operation 
 ] 
 ) 
 ad_group_ad_resource_name 
 : 
 str 
 = 
 ad_group_ad_response 
 . 
 results 
 [ 
 0 
 ] 
 . 
 resource_name 
 print 
 ( 
 f 
 "Created shopping product ad group ad ' 
 { 
 ad_group_ad_resource_name 
 } 
 '." 
 ) 
 def 
  
 add_shopping_product_ad_group 
 ( 
 client 
 : 
 GoogleAdsClient 
 , 
 customer_id 
 : 
 str 
 , 
 campaign_resource_name 
 : 
 str 
 , 
 ) 
 - 
> str 
 : 
  
 """Creates a new shopping product ad group in the specified campaign.""" 
 ad_group_service 
 : 
 AdGroupServiceClient 
 = 
 client 
 . 
 get_service 
 ( 
 "AdGroupService" 
 ) 
 # Create ad group. 
 ad_group_operation 
 : 
 AdGroupOperation 
 = 
 client 
 . 
 get_type 
 ( 
 "AdGroupOperation" 
 ) 
 ad_group 
 : 
 AdGroup 
 = 
 ad_group_operation 
 . 
 create 
 ad_group 
 . 
 name 
 = 
 f 
 "Earth to Mars cruise 
 { 
 uuid 
 . 
 uuid4 
 () 
 } 
 " 
 ad_group 
 . 
 status 
 = 
 client 
 . 
 enums 
 . 
 AdGroupStatusEnum 
 . 
 ENABLED 
 ad_group 
 . 
 campaign 
 = 
 campaign_resource_name 
 # Sets the ad group type to SHOPPING_PRODUCT_ADS. This is the only value 
 # possible for ad groups that contain shopping product ads. 
 ad_group 
 . 
 type_ 
 = 
 client 
 . 
 enums 
 . 
 AdGroupTypeEnum 
 . 
 SHOPPING_PRODUCT_ADS 
 ad_group 
 . 
 cpc_bid_micros 
 = 
 10000000 
 # Add the ad group. 
 ad_group_response 
 = 
 ad_group_service 
 . 
 mutate_ad_groups 
 ( 
 customer_id 
 = 
 customer_id 
 , 
 operations 
 = 
 [ 
 ad_group_operation 
 ] 
 ) 
 ad_group_resource_name 
 : 
 str 
 = 
 ad_group_response 
 . 
 results 
 [ 
 0 
 ] 
 . 
 resource_name 
 print 
 ( 
 "Added a product shopping ad group with resource name " 
 f 
 "' 
 { 
 ad_group_resource_name 
 } 
 '." 
 ) 
 return 
 ad_group_resource_name 
 def 
  
 add_standard_shopping_campaign 
 ( 
 client 
 : 
 GoogleAdsClient 
 , 
 customer_id 
 : 
 str 
 , 
 budget_resource_name 
 : 
 str 
 , 
 merchant_center_account_id 
 : 
 int 
 , 
 ) 
 - 
> str 
 : 
  
 """Creates a new standard shopping campaign in the specified client account.""" 
 campaign_service 
 : 
 CampaignServiceClient 
 = 
 client 
 . 
 get_service 
 ( 
 "CampaignService" 
 ) 
 # Create standard shopping campaign. 
 campaign_operation 
 : 
 CampaignOperation 
 = 
 client 
 . 
 get_type 
 ( 
 "CampaignOperation" 
 ) 
 campaign 
 : 
 Campaign 
 = 
 campaign_operation 
 . 
 create 
 campaign 
 . 
 name 
 = 
 f 
 "Interplanetary Cruise Campaign 
 { 
 uuid 
 . 
 uuid4 
 () 
 } 
 " 
 # Configures settings related to shopping campaigns including advertising 
 # channel type and shopping setting. 
 campaign 
 . 
 advertising_channel_type 
 = 
 ( 
 client 
 . 
 enums 
 . 
 AdvertisingChannelTypeEnum 
 . 
 SHOPPING 
 ) 
 campaign 
 . 
 shopping_setting 
 . 
 merchant_id 
 = 
 merchant_center_account_id 
 # Sets the priority of the campaign. Higher numbers take priority over lower 
 # numbers. For standard shopping campaigns, allowed values are between 0 and 
 # 2, inclusive. 
 campaign 
 . 
 shopping_setting 
 . 
 campaign_priority 
 = 
 0 
 # Enables local inventory ads for this campaign. 
 campaign 
 . 
 shopping_setting 
 . 
 enable_local 
 = 
 True 
 # Recommendation: Set the campaign to PAUSED when creating it to prevent the 
 # ads from immediately serving. Set to ENABLED once you've added targeting 
 # and the ads are ready to serve. 
 campaign 
 . 
 status 
 = 
 client 
 . 
 enums 
 . 
 CampaignStatusEnum 
 . 
 PAUSED 
 # Sets the bidding strategy to Manual CPC. 
 # Recommendation: Use one of the automated bidding strategies for Shopping 
 # campaigns to help you optimize your advertising spend. More information 
 # can be found here: https://support.google.com/google-ads/answer/6309029 
 campaign 
 . 
 manual_cpc 
 = 
 client 
 . 
 get_type 
 ( 
 "ManualCpc" 
 ) 
 # Sets the budget. 
 campaign 
 . 
 campaign_budget 
 = 
 budget_resource_name 
 # Declare whether or not this campaign serves political ads targeting the 
 # EU. Valid values are: 
 #   CONTAINS_EU_POLITICAL_ADVERTISING 
 #   DOES_NOT_CONTAIN_EU_POLITICAL_ADVERTISING 
 campaign 
 . 
 contains_eu_political_advertising 
 = 
 ( 
 client 
 . 
 enums 
 . 
 EuPoliticalAdvertisingStatusEnum 
 . 
 DOES_NOT_CONTAIN_EU_POLITICAL_ADVERTISING 
 ) 
 # Add the campaign. 
 campaign_response 
 = 
 campaign_service 
 . 
 mutate_campaigns 
 ( 
 customer_id 
 = 
 customer_id 
 , 
 operations 
 = 
 [ 
 campaign_operation 
 ] 
 ) 
 campaign_resource_name 
 : 
 str 
 = 
 campaign_response 
 . 
 results 
 [ 
 0 
 ] 
 . 
 resource_name 
 print 
 ( 
 "Added a standard shopping campaign with resource name " 
 f 
 "' 
 { 
 campaign_resource_name 
 } 
 '." 
 ) 
 return 
 campaign_resource_name 
 def 
  
 add_default_shopping_listing_group 
 ( 
 client 
 : 
 GoogleAdsClient 
 , 
 customer_id 
 : 
 str 
 , 
 ad_group_resource_name 
 : 
 str 
 , 
 ) 
 - 
> None 
 : 
  
 """Creates a new default shopping listing group for the specified ad group. 
 A listing group is the Google Ads API representation of a "product group" 
 described in the Google Ads user interface. The listing group will be added 
 to the ad group using an "ad group criterion". The criterion will contain 
 the bid for a given listing group. 
 """ 
 ad_group_criterion_service 
 : 
 AdGroupCriterionServiceClient 
 = 
 ( 
 client 
 . 
 get_service 
 ( 
 "AdGroupCriterionService" 
 ) 
 ) 
 # Creates a new ad group criterion. This will contain the "default" listing 
 # group (All products). 
 ad_group_criterion_operation 
 : 
 AdGroupCriterionOperation 
 = 
 client 
 . 
 get_type 
 ( 
 "AdGroupCriterionOperation" 
 ) 
 ad_group_criterion 
 : 
 AdGroupCriterion 
 = 
 ad_group_criterion_operation 
 . 
 create 
 ad_group_criterion 
 . 
 ad_group 
 = 
 ad_group_resource_name 
 ad_group_criterion 
 . 
 status 
 = 
 client 
 . 
 enums 
 . 
 AdGroupCriterionStatusEnum 
 . 
 ENABLED 
 ad_group_criterion 
 . 
 listing_group 
 . 
 type_ 
 = 
 ( 
 client 
 . 
 enums 
 . 
 ListingGroupTypeEnum 
 . 
 UNIT 
 ) 
 #  Set the bid for products in this listing group unit. 
 ad_group_criterion 
 . 
 cpc_bid_micros 
 = 
 500000 
 ad_group_criterion_response 
 = 
 ( 
 ad_group_criterion_service 
 . 
 mutate_ad_group_criteria 
 ( 
 customer_id 
 = 
 customer_id 
 , 
 operations 
 = 
 [ 
 ad_group_criterion_operation 
 ] 
 ) 
 ) 
 print 
 ( 
 "Added an ad group criterion containing a listing group with " 
 f 
 "' 
 { 
 ad_group_criterion_response 
 . 
 results 
 [ 
 0 
 ] 
 . 
 resource_name 
 } 
 '." 
 ) 
 if 
 __name__ 
 == 
 "__main__" 
 : 
 parser 
 = 
 argparse 
 . 
 ArgumentParser 
 ( 
 description 
 = 
 ( 
 "Adds a standard shopping campaign, a shopping product ad " 
 "group and a shopping product ad to the specified " 
 "merchant account." 
 ) 
 ) 
 # 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." 
 , 
 ) 
 parser 
 . 
 add_argument 
 ( 
 "-m" 
 , 
 "--merchant_center_account_id" 
 , 
 type 
 = 
 int 
 , 
 required 
 = 
 True 
 , 
 help 
 = 
 "The merchant center account ID." 
 , 
 ) 
 parser 
 . 
 add_argument 
 ( 
 "-d" 
 , 
 "--create_default_listing_group" 
 , 
 action 
 = 
 "store_true" 
 , 
 default 
 = 
 False 
 , 
 help 
 = 
 "Create a default listing group." 
 , 
 ) 
 args 
 : 
 argparse 
 . 
 Namespace 
 = 
 parser 
 . 
 parse_args 
 () 
 # GoogleAdsClient will read the google-ads.yaml configuration file in the 
 # home directory if none is specified. 
 googleads_client 
 : 
 GoogleAdsClient 
 = 
 GoogleAdsClient 
 . 
 load_from_storage 
 ( 
 version 
 = 
 "v21" 
 ) 
 try 
 : 
 main 
 ( 
 googleads_client 
 , 
 args 
 . 
 customer_id 
 , 
 args 
 . 
 merchant_center_account_id 
 , 
 args 
 . 
 create_default_listing_group 
 , 
 ) 
 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 
 ' 
 \t 
 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 
 ) 
  

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 creates a standard shopping product campaign, ad group, and ad. 
 # 
 # Prerequisite: You need to have access to a Merchant Center account. You can 
 # find instructions to create a Merchant Center account here: 
 # https://support.google.com/merchants/answer/188924 
 # 
 # This account must be linked to your Google Ads account. 
 require 
  
 'optparse' 
 require 
  
 'google/ads/google_ads' 
 require 
  
 'date' 
 def 
  
 add_shopping_product_ad 
 ( 
  
 customer_id 
 , 
  
 merchant_center_id 
 , 
  
 create_default_listing_group 
 ) 
  
 # GoogleAdsClient will read a config file from 
  
 # ENV['HOME']/google_ads_config.rb when called without parameters 
  
 client 
  
 = 
  
 Google 
 :: 
 Ads 
 :: 
 GoogleAds 
 :: 
 GoogleAdsClient 
 . 
 new 
  
 budget_name 
  
 = 
  
 add_campaign_budget 
 ( 
 client 
 , 
  
 customer_id 
 ) 
  
 campaign_name 
  
 = 
  
 add_standard_shopping_campaign 
 ( 
  
 client 
 , 
  
 customer_id 
 , 
  
 budget_name 
 , 
  
 merchant_center_id 
 , 
  
 ) 
  
 ad_group_name 
  
 = 
  
 add_shopping_product_ad_group 
 ( 
  
 client 
 , 
  
 customer_id 
 , 
  
 campaign_name 
 , 
  
 ) 
  
 add_shopping_product_ad_group_ad 
 ( 
 client 
 , 
  
 customer_id 
 , 
  
 ad_group_name 
 ) 
  
 if 
  
 create_default_listing_group 
  
 # The default listing group will be for 'All products' and will contain 
  
 # a single biddable unit node. 
  
 add_default_shopping_listing_group 
 ( 
 client 
 , 
  
 customer_id 
 , 
  
 ad_group_name 
 ) 
  
 end 
 end 
 def 
  
 add_campaign_budget 
 ( 
 client 
 , 
  
 customer_id 
 ) 
  
 operation 
  
 = 
  
 client 
 . 
 operation 
 . 
 create_resource 
 . 
 campaign_budget 
  
 do 
  
 | 
 budget 
 | 
  
 budget 
 . 
 name 
  
 = 
  
 "Interplanetary Budget # 
 #{ 
 ( 
 Time 
 . 
 new 
 . 
 to_f 
  
 * 
  
 1000 
 ) 
 . 
 to_i 
 } 
 " 
  
 budget 
 . 
 delivery_method 
  
 = 
  
 :STANDARD 
  
 budget 
 . 
 amount_micros 
  
 = 
  
 500_000 
  
 end 
  
 service 
  
 = 
  
 client 
 . 
 service 
 . 
 campaign_budget 
  
 response 
  
 = 
  
 service 
 . 
 mutate_campaign_budgets 
 ( 
  
 customer_id 
 : 
  
 customer_id 
 , 
  
 operations 
 : 
  
 [ 
 operation 
 ] 
 , 
  
 ) 
  
 budget_name 
  
 = 
  
 response 
 . 
 results 
 . 
 first 
 . 
 resource_name 
  
 puts 
  
 "Added a budget with resource name: 
 #{ 
 budget_name 
 } 
 " 
  
 budget_name 
 end 
 def 
  
 add_standard_shopping_campaign 
 ( 
  
 client 
 , 
  
 customer_id 
 , 
  
 budget_name 
 , 
  
 merchant_center_id 
 ) 
  
 operation 
  
 = 
  
 client 
 . 
 operation 
 . 
 create_resource 
 . 
 campaign 
  
 do 
  
 | 
 campaign 
 | 
  
 campaign 
 . 
 name 
  
 = 
  
 "Interplanetary Cruise Campaign # 
 #{ 
 ( 
 Time 
 . 
 new 
 . 
 to_f 
  
 * 
  
 1000 
 ) 
 . 
 to_i 
 } 
 " 
  
 # Shopping campaign specific settings 
  
 campaign 
 . 
 advertising_channel_type 
  
 = 
  
 :SHOPPING 
  
 campaign 
 . 
 shopping_setting 
  
 = 
  
 client 
 . 
 resource 
 . 
 shopping_setting 
  
 do 
  
 | 
 shopping_setting 
 | 
  
 shopping_setting 
 . 
 merchant_id 
  
 = 
  
 merchant_center_id 
  
 shopping_setting 
 . 
 campaign_priority 
  
 = 
  
 0 
  
 shopping_setting 
 . 
 enable_local 
  
 = 
  
 true 
  
 end 
  
 campaign 
 . 
 status 
  
 = 
  
 :PAUSED 
  
 # Sets the bidding strategy to Manual CPC. 
  
 campaign 
 . 
 manual_cpc 
  
 = 
  
 client 
 . 
 resource 
 . 
 manual_cpc 
  
 campaign 
 . 
 campaign_budget 
  
 = 
  
 budget_name 
  
 # Declare whether or not this campaign serves political ads targeting the EU. 
  
 # Valid values are CONTAINS_EU_POLITICAL_ADVERTISING and 
  
 # DOES_NOT_CONTAIN_EU_POLITICAL_ADVERTISING. 
  
 c 
 . 
 contains_eu_political_advertising 
  
 = 
  
 :DOES_NOT_CONTAIN_EU_POLITICAL_ADVERTISING 
  
 end 
  
 service 
  
 = 
  
 client 
 . 
 service 
 . 
 campaign 
  
 response 
  
 = 
  
 service 
 . 
 mutate_campaigns 
 ( 
  
 customer_id 
 : 
  
 customer_id 
 , 
  
 operations 
 : 
  
 [ 
 operation 
 ] 
 , 
  
 ) 
  
 campaign_name 
  
 = 
  
 response 
 . 
 results 
 . 
 first 
 . 
 resource_name 
  
 puts 
  
 "Added a standard shopping campaign with resource name 
 #{ 
 campaign_name 
 } 
 ." 
  
 campaign_name 
 end 
 def 
  
 add_shopping_product_ad_group 
 ( 
 client 
 , 
  
 customer_id 
 , 
  
 campaign_name 
 ) 
  
 operation 
  
 = 
  
 client 
 . 
 operation 
 . 
 create_resource 
 . 
 ad_group 
  
 do 
  
 | 
 ad_group 
 | 
  
 ad_group 
 . 
 name 
  
 = 
  
 "Earth to Mars cruise # 
 #{ 
 ( 
 Time 
 . 
 new 
 . 
 to_f 
  
 * 
  
 1000 
 ) 
 . 
 to_i 
 } 
 " 
  
 ad_group 
 . 
 status 
  
 = 
  
 :ENABLED 
  
 ad_group 
 . 
 campaign 
  
 = 
  
 campaign_name 
  
 ad_group 
 . 
 type 
  
 = 
  
 :SHOPPING_PRODUCT_ADS 
  
 ad_group 
 . 
 cpc_bid_micros 
  
 = 
  
 10_000_000 
  
 end 
  
 service 
  
 = 
  
 client 
 . 
 service 
 . 
 ad_group 
  
 response 
  
 = 
  
 service 
 . 
 mutate_ad_groups 
 ( 
  
 customer_id 
 : 
  
 customer_id 
 , 
  
 operations 
 : 
  
 [ 
 operation 
 ] 
 , 
  
 ) 
  
 ad_group_name 
  
 = 
  
 response 
 . 
 results 
 . 
 first 
 . 
 resource_name 
  
 puts 
  
 "Added a product shopping ad group with resource name 
 #{ 
 ad_group_name 
 } 
 ." 
  
 ad_group_name 
 end 
 def 
  
 add_shopping_product_ad_group_ad 
 ( 
 client 
 , 
  
 customer_id 
 , 
  
 ad_group_name 
 ) 
  
 operation 
  
 = 
  
 client 
 . 
 operation 
 . 
 create_resource 
 . 
 ad_group_ad 
  
 do 
  
 | 
 ad_group_ad 
 | 
  
 ad_group_ad 
 . 
 ad_group 
  
 = 
  
 ad_group_name 
  
 ad_group_ad 
 . 
 status 
  
 = 
  
 :PAUSED 
  
 ad_group_ad 
 . 
 ad 
  
 = 
  
 client 
 . 
 resource 
 . 
 ad 
  
 do 
  
 | 
 ad 
 | 
  
 ad 
 . 
 shopping_product_ad 
  
 = 
  
 client 
 . 
 resource 
 . 
 shopping_product_ad_info 
  
 end 
  
 end 
  
 service 
  
 = 
  
 client 
 . 
 service 
 . 
 ad_group_ad 
  
 response 
  
 = 
  
 service 
 . 
 mutate_ad_group_ads 
 ( 
  
 customer_id 
 : 
  
 customer_id 
 , 
  
 operations 
 : 
  
 [ 
 operation 
 ] 
 , 
  
 ) 
  
 puts 
  
 "Created shopping product ad group ad " 
  
 \ 
  
 " 
 #{ 
 response 
 . 
 results 
 . 
 first 
 . 
 resource_name 
 } 
 " 
 end 
 def 
  
 add_default_shopping_listing_group 
 ( 
 client 
 , 
  
 customer_id 
 , 
  
 ad_group_name 
 ) 
  
 operation 
  
 = 
  
 client 
 . 
 operation 
 . 
 create_resource 
 . 
 ad_group_criterion 
  
 do 
  
 | 
 criterion 
 | 
  
 criterion 
 . 
 ad_group 
  
 = 
  
 ad_group_name 
  
 criterion 
 . 
 status 
  
 = 
  
 :ENABLED 
  
 criterion 
 . 
 listing_group 
  
 = 
  
 client 
 . 
 resource 
 . 
 listing_group_info 
  
 do 
  
 | 
 lgi 
 | 
  
 lgi 
 . 
 type 
  
 = 
  
 :UNIT 
  
 end 
  
 criterion 
 . 
 cpc_bid_micros 
  
 = 
  
 500_000 
  
 end 
  
 service 
  
 = 
  
 client 
 . 
 service 
 . 
 ad_group_criterion 
  
 response 
  
 = 
  
 service 
 . 
 mutate_ad_group_criteria 
 ( 
  
 customer_id 
 : 
  
 customer_id 
 , 
  
 operations 
 : 
  
 [ 
 operation 
 ] 
  
 ) 
  
 puts 
  
 "Added an ad group criterion containing a listing group with resource " 
  
 \ 
  
 "name 
 #{ 
 response 
 . 
 results 
 . 
 first 
 . 
 resource_name 
 } 
 ." 
 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' 
  
 options 
 [ 
 :merchant_center_id 
 ] 
  
 = 
  
 'INSERT_MERCHANT_CENTER_ID_HERE' 
  
 # Specifying any value for this field on the command line will override this 
  
 # to true. 
  
 options 
 [ 
 :create_default_listing_group 
 ] 
  
 = 
  
 false 
  
 OptionParser 
 . 
 new 
  
 do 
  
 | 
 opts 
 | 
  
 opts 
 . 
 banner 
  
 = 
  
 sprintf 
 ( 
 "Usage: 
 #{ 
 File 
 . 
 basename 
 ( 
 __FILE__ 
 ) 
 } 
 [options]" 
 ) 
  
 opts 
 . 
 separator 
  
 '' 
  
 opts 
 . 
 separator 
  
 'Options:' 
  
 opts 
 . 
 on 
 ( 
 '-C' 
 , 
  
 '--customer-id CUSTOMER-ID' 
 , 
  
 String 
 , 
  
 'Customer ID' 
 ) 
  
 do 
  
 | 
 v 
 | 
  
 options 
 [ 
 :customer_id 
 ] 
  
 = 
  
 v 
  
 end 
  
 opts 
 . 
 on 
 ( 
 '-M' 
 , 
  
 '--merchant-center-account-id MERCHANT-CENTER-ACCOUNT-ID' 
 , 
  
 Integer 
 , 
  
 'Merchant Center ID' 
 ) 
  
 do 
  
 | 
 v 
 | 
  
 options 
 [ 
 :merchant_center_id 
 ] 
  
 = 
  
 v 
  
 end 
  
 opts 
 . 
 on 
 ( 
 '-d' 
 , 
  
 '--create-default-listing-group CREATE-DEFAULT-LISTING-GROUP' 
 , 
  
 TrueClass 
 , 
  
 'Create Default Listing Group' 
 ) 
  
 do 
  
 | 
 v 
 | 
  
 options 
 [ 
 :create_default_listing_group 
 ] 
  
 = 
  
 v 
  
 end 
  
 opts 
 . 
 separator 
  
 '' 
  
 opts 
 . 
 separator 
  
 'Help:' 
  
 opts 
 . 
 on_tail 
 ( 
 '-h' 
 , 
  
 '--help' 
 , 
  
 'Show this message' 
 ) 
  
 do 
  
 puts 
  
 opts 
  
 exit 
  
 end 
  
 end 
 . 
 parse! 
  
 begin 
  
 add_shopping_product_ad 
 ( 
  
 options 
 . 
 fetch 
 ( 
 :customer_id 
 ) 
 . 
 tr 
 ( 
 "-" 
 , 
  
 "" 
 ), 
  
 options 
 . 
 fetch 
 ( 
 :merchant_center_id 
 ), 
  
 options 
 . 
 fetch 
 ( 
 :create_default_listing_group 
 ), 
  
 ) 
  
 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 
  
  

Perl

 #!/usr/bin/perl -w 
 # 
 # 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 
 # 
 #     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 creates a standard shopping campaign, a shopping product ad group 
 # and a shopping product ad. 
 # 
 # Prerequisite: You need to have access to a Merchant Center account. You can 
 # find instructions to create a Merchant Center account here: 
 # https://support.google.com/merchants/answer/188924 
 # This account must be linked to your Google Ads account. 
 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::V21::Resources::CampaignBudget 
 ; 
 use 
  
 Google::Ads::GoogleAds::V21::Resources::Campaign 
 ; 
 use 
  
 Google::Ads::GoogleAds::V21::Resources::ShoppingSetting 
 ; 
 use 
  
 Google::Ads::GoogleAds::V21::Resources::AdGroup 
 ; 
 use 
  
 Google::Ads::GoogleAds::V21::Resources::AdGroupAd 
 ; 
 use 
  
 Google::Ads::GoogleAds::V21::Resources::Ad 
 ; 
 use 
  
 Google::Ads::GoogleAds::V21::Resources::AdGroupCriterion 
 ; 
 use 
  
 Google::Ads::GoogleAds::V21::Common::ManualCpc 
 ; 
 use 
  
 Google::Ads::GoogleAds::V21::Common::ShoppingProductAdInfo 
 ; 
 use 
  
 Google::Ads::GoogleAds::V21::Common::ListingGroupInfo 
 ; 
 use 
  
 Google::Ads::GoogleAds::V21::Enums::BudgetDeliveryMethodEnum 
  
 qw(STANDARD) 
 ; 
 use 
  
 Google::Ads::GoogleAds::V21::Enums::AdvertisingChannelTypeEnum 
  
 qw(SHOPPING) 
 ; 
 use 
  
 Google::Ads::GoogleAds::V21::Enums::AdGroupTypeEnum 
  
 qw(SHOPPING_PRODUCT_ADS) 
 ; 
 use 
  
 Google::Ads::GoogleAds::V21::Enums::CampaignStatusEnum 
 ; 
 use 
  
 Google::Ads::GoogleAds::V21::Enums::AdGroupStatusEnum 
 ; 
 use 
  
 Google::Ads::GoogleAds::V21::Enums::AdGroupAdStatusEnum 
 ; 
 use 
  
 Google::Ads::GoogleAds::V21::Enums::ListingGroupTypeEnum 
  
 qw(UNIT) 
 ; 
 use 
  
 Google::Ads::GoogleAds::V21::Enums::AdGroupCriterionStatusEnum 
 ; 
 use 
  
 Google::Ads::GoogleAds::V21::Enums::EuPoliticalAdvertisingStatusEnum 
  
 qw(DOES_NOT_CONTAIN_EU_POLITICAL_ADVERTISING) 
 ; 
 use 
  
 Google::Ads::GoogleAds::V21::Services::CampaignBudgetService::CampaignBudgetOperation 
 ; 
 use 
  
 Google::Ads::GoogleAds::V21::Services::CampaignService::CampaignOperation 
 ; 
 use 
  
 Google::Ads::GoogleAds::V21::Services::AdGroupService::AdGroupOperation 
 ; 
 use 
  
 Google::Ads::GoogleAds::V21::Services::AdGroupAdService::AdGroupAdOperation 
 ; 
 use 
  
 Google::Ads::GoogleAds::V21::Services::AdGroupCriterionService::AdGroupCriterionOperation 
 ; 
 use 
  
 Getopt::Long 
  
 qw(:config auto_help) 
 ; 
 use 
  
 Pod::Usage 
 ; 
 use 
  
 Cwd 
  
 qw(abs_path) 
 ; 
 use 
  
 Data::Uniqid 
  
 qw(uniqid) 
 ; 
 # 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. 
 my 
  
 $customer_id 
  
 = 
  
 "INSERT_CUSTOMER_ID_HERE" 
 ; 
 my 
  
 $merchant_center_account_id 
  
 = 
  
 "INSERT_MERCHANT_CENTER_ACCOUNT_ID_HERE" 
 ; 
 my 
  
 $create_default_listing_group 
  
 = 
  
 undef 
 ; 
 sub 
  
 add_shopping_product_ad 
  
 { 
  
 my 
  
 ( 
 $api_client 
 , 
  
 $customer_id 
 , 
  
 $merchant_center_account_id 
 , 
  
 $create_default_listing_group 
 ) 
  
 = 
  
 @_ 
 ; 
  
 # Create a budget to be used by the campaign that will be created below. 
  
 my 
  
 $budget_resource_name 
  
 = 
  
 add_campaign_budget 
 ( 
 $api_client 
 , 
  
 $customer_id 
 ); 
  
 # Create a standard shopping campaign. 
  
 my 
  
 $campaign_resource_name 
  
 = 
  
 add_standard_shopping_campaign 
 ( 
 $api_client 
 , 
  
 $customer_id 
 , 
  
 $budget_resource_name 
 , 
  
 $merchant_center_account_id 
 ); 
  
 # Create a shopping product ad group. 
  
 my 
  
 $ad_group_resource_name 
  
 = 
  
 add_shopping_product_ad_group 
 ( 
 $api_client 
 , 
  
 $customer_id 
 , 
  
 $campaign_resource_name 
 ); 
  
 # Create a shopping product ad group ad. 
  
 add_shopping_product_ad_group_ad 
 ( 
 $api_client 
 , 
  
 $customer_id 
 , 
  
 $ad_group_resource_name 
 ); 
  
 if 
  
 ( 
 $create_default_listing_group 
 ) 
  
 { 
  
 # Create an ad group criterion containing a listing group. 
  
 # This will be the listing group tree for 'All products' and will 
  
 # contain a single biddable unit node. 
  
 add_default_shopping_listing_group 
 ( 
 $api_client 
 , 
  
 $customer_id 
 , 
  
 $ad_group_resource_name 
 ); 
  
 } 
  
 return 
  
 1 
 ; 
 } 
 # Creates a new campaign budget in the specified client account. 
 sub 
  
 add_campaign_budget 
  
 { 
  
 my 
  
 ( 
 $api_client 
 , 
  
 $customer_id 
 ) 
  
 = 
  
 @_ 
 ; 
  
 # Create a campaign budget. 
  
 my 
  
 $campaign_budget 
  
 = 
  
 Google::Ads::GoogleAds::V21::Resources:: 
 CampaignBudget 
 - 
> new 
 ({ 
  
 name 
  
 = 
>  
 "Interplanetary Cruise Budget #" 
  
 . 
  
 uniqid 
 (), 
  
 deliveryMethod 
  
 = 
>  
 STANDARD 
 , 
  
 # Set the amount of budget. 
  
 amountMicros 
  
 = 
>  
 5000000 
  
 }); 
  
 # Create a campaign budget operation. 
  
 my 
  
 $campaign_budget_operation 
  
 = 
  
 Google::Ads::GoogleAds::V21::Services::CampaignBudgetService:: 
 CampaignBudgetOperation 
  
 - 
> new 
 ({ 
 create 
  
 = 
>  
 $campaign_budget 
 }); 
  
 # Add the campaign budget. 
  
 my 
  
 $campaign_budget_resource_name 
  
 = 
  
 $api_client 
 - 
> CampaignBudgetService 
 () 
 - 
> mutate 
 ({ 
  
 customerId 
  
 = 
>  
 $customer_id 
 , 
  
 operations 
  
 = 
>  
 [ 
 $campaign_budget_operation 
 ]}) 
 - 
> { 
 results 
 }[ 
 0 
 ]{ 
 resourceName 
 }; 
  
 printf 
  
 "Added a budget with resource name: '%s'.\n" 
 , 
  
 $campaign_budget_resource_name 
 ; 
  
 return 
  
 $campaign_budget_resource_name 
 ; 
 } 
 # Creates a new standard shopping campaign in the specified client account. 
 sub 
  
 add_standard_shopping_campaign 
  
 { 
  
 my 
  
 ( 
 $api_client 
 , 
  
 $customer_id 
 , 
  
 $budget_resource_name 
 , 
  
 $merchant_center_account_id 
 ) 
  
 = 
  
 @_ 
 ; 
  
 # Create a standard shopping campaign. 
  
 my 
  
 $campaign 
  
 = 
  
 Google::Ads::GoogleAds::V21::Resources:: 
 Campaign 
 - 
> new 
 ({ 
  
 name 
  
 = 
>  
 "Interplanetary Cruise Campaign #" 
  
 . 
  
 uniqid 
 (), 
  
 # Configure settings related to shopping campaigns including advertising 
  
 # channel type and shopping setting. 
  
 advertisingChannelType 
  
 = 
>  
 SHOPPING 
 , 
  
 shoppingSetting 
  
 = 
>  
 Google::Ads::GoogleAds::V21::Resources:: 
 ShoppingSetting 
 - 
> new 
 ({ 
  
 merchantId 
  
 = 
>  
 $merchant_center_account_id 
 , 
  
 # Set the priority of the campaign. Higher numbers take priority over 
  
 # lower numbers. For standard shopping campaigns, allowed values are 
  
 # between 0 and 2, inclusive. 
  
 campaignPriority 
  
 = 
>  
 0 
 , 
  
 # Enable local inventory ads for this campaign. 
  
 enableLocal 
  
 = 
>  
 "true" 
  
 } 
  
 ), 
  
 # Recommendation: Set the campaign to PAUSED when creating it to prevent 
  
 # the ads from immediately serving. Set to ENABLED once you've added 
  
 # targeting and the ads are ready to serve. 
  
 status 
  
 = 
>  
 Google::Ads::GoogleAds::V21::Enums::CampaignStatusEnum:: 
 PAUSED 
 , 
  
 # Set the bidding strategy to Manual CPC. 
  
 # Recommendation: Use one of the automated bidding strategies for shopping 
  
 # campaigns to help you optimize your advertising spend. More information 
  
 # can be found here: https://support.google.com/google-ads/answer/6309029. 
  
 manualCpc 
  
 = 
>  
 Google::Ads::GoogleAds::V21::Common:: 
 ManualCpc 
 - 
> new 
 (), 
  
 # Set the budget. 
  
 campaignBudget 
  
 = 
>  
 $budget_resource_name 
 , 
  
 # Declare whether or not this campaign serves political ads targeting the EU. 
  
 # Valid values are CONTAINS_EU_POLITICAL_ADVERTISING and 
  
 # DOES_NOT_CONTAIN_EU_POLITICAL_ADVERTISING. 
  
 containsEuPoliticalAdvertising 
  
 = 
>  
 DOES_NOT_CONTAIN_EU_POLITICAL_ADVERTISING 
  
 }); 
  
 # Create a campaign operation. 
  
 my 
  
 $campaign_operation 
  
 = 
  
 Google::Ads::GoogleAds::V21::Services::CampaignService:: 
 CampaignOperation 
 - 
>  
 new 
 ({ 
 create 
  
 = 
>  
 $campaign 
 }); 
  
 # Add the campaign. 
  
 my 
  
 $campaign_resource_name 
  
 = 
  
 $api_client 
 - 
> CampaignService 
 () 
 - 
> mutate 
 ({ 
  
 customerId 
  
 = 
>  
 $customer_id 
 , 
  
 operations 
  
 = 
>  
 [ 
 $campaign_operation 
 ]}) 
 - 
> { 
 results 
 }[ 
 0 
 ]{ 
 resourceName 
 }; 
  
 printf 
  
 "Added a standard shopping campaign with resource name: '%s'.\n" 
 , 
  
 $campaign_resource_name 
 ; 
  
 return 
  
 $campaign_resource_name 
 ; 
 } 
 # Creates a new shopping product ad group in the specified campaign. 
 sub 
  
 add_shopping_product_ad_group 
  
 { 
  
 my 
  
 ( 
 $api_client 
 , 
  
 $customer_id 
 , 
  
 $campaign_resource_name 
 ) 
  
 = 
  
 @_ 
 ; 
  
 # Create an ad group. 
  
 my 
  
 $ad_group 
  
 = 
  
 Google::Ads::GoogleAds::V21::Resources:: 
 AdGroup 
 - 
> new 
 ({ 
  
 name 
  
 = 
>  
 "Earth to Mars Cruises #" 
  
 . 
  
 uniqid 
 (), 
  
 campaign 
  
 = 
>  
 $campaign_resource_name 
 , 
  
 # Set the ad group type to SHOPPING_PRODUCT_ADS. This is the only value 
  
 # possible for ad groups that contain shopping product ads. 
  
 type 
  
 = 
>  
 SHOPPING_PRODUCT_ADS 
 , 
  
 cpcBidMicros 
  
 = 
>  
 1000000 
 , 
  
 status 
  
 = 
>  
 Google::Ads::GoogleAds::V21::Enums::AdGroupStatusEnum:: 
 ENABLED 
  
 }); 
  
 # Create an ad group operation. 
  
 my 
  
 $ad_group_operation 
  
 = 
  
 Google::Ads::GoogleAds::V21::Services::AdGroupService:: 
 AdGroupOperation 
 - 
>  
 new 
 ({ 
 create 
  
 = 
>  
 $ad_group 
 }); 
  
 # Add the ad group. 
  
 my 
  
 $ad_group_resource_name 
  
 = 
  
 $api_client 
 - 
> AdGroupService 
 () 
 - 
> mutate 
 ({ 
  
 customerId 
  
 = 
>  
 $customer_id 
 , 
  
 operations 
  
 = 
>  
 [ 
 $ad_group_operation 
 ]}) 
 - 
> { 
 results 
 }[ 
 0 
 ]{ 
 resourceName 
 }; 
  
 printf 
  
 "Added a product shopping ad group with resource name: '%s'.\n" 
 , 
  
 $ad_group_resource_name 
 ; 
  
 return 
  
 $ad_group_resource_name 
 ; 
 } 
 # Creates a new shopping product ad group ad in the specified ad group. 
 sub 
  
 add_shopping_product_ad_group_ad 
  
 { 
  
 my 
  
 ( 
 $api_client 
 , 
  
 $customer_id 
 , 
  
 $ad_group_resource_name 
 ) 
  
 = 
  
 @_ 
 ; 
  
 # Create an ad group ad and set a shopping product ad to it. 
  
 my 
  
 $ad_group_ad 
  
 = 
  
 Google::Ads::GoogleAds::V21::Resources:: 
 AdGroupAd 
 - 
> new 
 ({ 
  
 # Set the ad group. 
  
 adGroup 
  
 = 
>  
 $ad_group_resource_name 
 , 
  
 # Set the ad to a new shopping product ad. 
  
 ad 
  
 = 
>  
 Google::Ads::GoogleAds::V21::Resources:: 
 Ad 
 - 
> new 
 ({ 
  
 shoppingProductAd 
  
 = 
>  
 Google::Ads::GoogleAds::V21::Common:: 
 ShoppingProductAdInfo 
 - 
> new 
 ()} 
  
 ), 
  
 status 
  
 = 
>  
 Google::Ads::GoogleAds::V21::Enums::AdGroupAdStatusEnum:: 
 PAUSED 
  
 }); 
  
 # Create an ad group ad operation. 
  
 my 
  
 $ad_group_ad_operation 
  
 = 
  
 Google::Ads::GoogleAds::V21::Services::AdGroupAdService:: 
 AdGroupAdOperation 
  
 - 
> new 
 ({ 
 create 
  
 = 
>  
 $ad_group_ad 
 }); 
  
 # Add the ad group ad. 
  
 my 
  
 $ad_group_ad_resource_name 
  
 = 
  
 $api_client 
 - 
> AdGroupAdService 
 () 
 - 
> mutate 
 ({ 
  
 customerId 
  
 = 
>  
 $customer_id 
 , 
  
 operations 
  
 = 
>  
 [ 
 $ad_group_ad_operation 
 ]}) 
 - 
> { 
 results 
 }[ 
 0 
 ]{ 
 resourceName 
 }; 
  
 printf 
  
 "Added a product shopping ad group ad with resource name: '%s'.\n" 
 , 
  
 $ad_group_ad_resource_name 
 ; 
  
 return 
  
 $ad_group_ad_resource_name 
 ; 
 } 
 # Creates a new default shopping listing group for the specified ad group. A listing 
 # group is the Google Ads API representation of a "product group" described in the 
 # Google Ads user interface. The listing group will be added to the ad group using an 
 # "ad group criterion". The criterion will contain the bid for a given listing group. 
 sub 
  
 add_default_shopping_listing_group 
  
 { 
  
 my 
  
 ( 
 $api_client 
 , 
  
 $customer_id 
 , 
  
 $ad_group_resource_name 
 ) 
  
 = 
  
 @_ 
 ; 
  
 # Create a new ad group criterion. This will contain the "default" listing group 
  
 # (All products). 
  
 my 
  
 $ad_group_criterion 
  
 = 
  
 Google::Ads::GoogleAds::V21::Resources:: 
 AdGroupCriterion 
 - 
> new 
 ({ 
  
 # Set the ad group. 
  
 adGroup 
  
 = 
>  
 $ad_group_resource_name 
 , 
  
 # Create a new listing group. This will be the top-level "root" node. 
  
 # Set the type of the listing group to be a biddable unit. 
  
 listingGroup 
  
 = 
>  
 Google::Ads::GoogleAds::V21::Common:: 
 ListingGroupInfo 
 - 
> new 
 ({ 
  
 type 
  
 = 
>  
 UNIT 
  
 } 
  
 ), 
  
 # Set the bid for products in this listing group unit. 
  
 cpcBidMicros 
  
 = 
>  
 500000 
 , 
  
 status 
  
 = 
>  
 Google::Ads::GoogleAds::V21::Enums::AdGroupCriterionStatusEnum:: 
 ENABLED 
  
 }); 
  
 # Create an ad group criterion operation. 
  
 my 
  
 $ad_group_criterion_operation 
  
 = 
  
 Google::Ads::GoogleAds::V21::Services::AdGroupCriterionService:: 
 AdGroupCriterionOperation 
  
 - 
> new 
 ({ 
 create 
  
 = 
>  
 $ad_group_criterion 
 }); 
  
 # Add the listing group criterion. 
  
 my 
  
 $ad_group_criterion_resource_name 
  
 = 
  
 $api_client 
 - 
> AdGroupCriterionService 
 () 
 - 
> mutate 
 ({ 
  
 customerId 
  
 = 
>  
 $customer_id 
 , 
  
 operations 
  
 = 
>  
 [ 
 $ad_group_criterion_operation 
 ]} 
  
 ) 
 - 
> { 
 results 
 }[ 
 0 
 ]{ 
 resourceName 
 }; 
  
 printf 
  
 "Added an ad group criterion containing a listing group " 
  
 . 
  
 "with resource name: '%s'.\n" 
 , 
  
 $ad_group_criterion_resource_name 
 ; 
  
 return 
  
 $ad_group_criterion_resource_name 
 ; 
 } 
 # 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 
 ); 
 # Parameters passed on the command line will override any parameters set in code. 
 GetOptions 
 ( 
  
 "customer_id=s" 
  
 = 
>  
 \ 
 $customer_id 
 , 
  
 "merchant_center_account_id=i" 
  
 = 
>  
 \ 
 $merchant_center_account_id 
 , 
  
 "create_default_listing_group=s" 
  
 = 
>  
 \ 
 $create_default_listing_group 
 ); 
 # 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 
 , 
  
 $merchant_center_account_id 
 ); 
 # Call the example. 
 add_shopping_product_ad 
 ( 
 $api_client 
 , 
  
 $customer_id 
  
 =~ 
  
 s/-//g 
 r 
 , 
  
 $merchant_center_account_id 
 , 
  
 $create_default_listing_group 
 ); 
 =pod 
 =head1 NAME 
 add_shopping_product_ad 
 =head1 DESCRIPTION 
 This example creates a standard shopping campaign, a shopping product ad group 
 and a shopping product ad. 
 Prerequisite: You need to have access to a Merchant Center account. You can find 
 instructions to create a Merchant Center account here: 
 https://support.google.com/merchants/answer/188924 
 This account must be linked to your Google Ads account. 
 =head1 SYNOPSIS 
 add_shopping_product_ad.pl [options] 
 -help                           Show the help message. 
 -customer_id                    The Google Ads customer ID. 
 -merchant_center_account_id     The Merchant Center account ID. 
 -create_default_listing_group   [optional] Create default listing group. 
 =cut 
  
  
Design a Mobile Site
View Site in Mobile | Classic
Share by: