Targeting Settings

    Use the targeting setting in your ad groups or campaigns to specify whether to narrow your ads to only show to specific audience segments, or on specific content you've selected.

    Set up the targeting setting

    You can set up details on how your various criteria types are used for targeting by setting the TargetingSetting field with an array of target_restrictions . Each TargetRestriction lets you control whether a type of criteria uses the bid_only option or not.

    When setting bid_only to true , the targeting setting will be set to "Observation", and the criteria won't be used to restrict traffic, but will allow you to bid differently for different users on your lists. Setting bid_only to false sets the targeting setting to "Targeting" and enables the criteria to restrict ad group traffic only to users on the targeted list.

    Best practices

    By default, bid_only is set to false , which means the targeting setting will be set to "Targeting". If you're adding audience segments to a search or shopping campaign, consider changing the targeting setting of bid_only to true to set it to "Observation".

    If you're setting up a duplicate campaign for audience segments for search ads, keep the targeting of bid_only set to false .

    Restrictions

    You cannot add or update targeting_setting on an AdGroup if targeting_setting is set on the parent campaign. If the targeting_setting is set on the parent Campaign , you must first remove the targeting_setting on the parent Campaign . Likewise, you must first remove the targeting_setting on the AdGroup in order to set it on the Campaign .

    Retrieve the targeting setting

    To verify that your targeting is set up as you intend, check the targeting_setting on ad groups or campaigns by requesting the ad_group.targeting_setting.target_restrictions field from the ad_group resource in a search query.

    Example

    This example updates the targeting_setting on an ad group so that bid_only is true for TargetRestriction instances with a targeting_dimension of AUDIENCE , effectively ensuring that ads in the ad group are only shown to users in the specified audience segment.

    First, retrieve all the ad_group.targeting_setting.target_restrictions from the ad group with the provided ID.

    Java

     String 
  
 searchQuery 
  
 = 
  
 "SELECT ad_group.id, ad_group.name, ad_group.targeting_setting.target_restrictions " 
  
 + 
  
 "FROM ad_group " 
  
 + 
  
 "WHERE ad_group.id = " 
  
 + 
  
 adGroupId 
 ; 
 
      UpdateAudienceTargetRestriction 
 . 
 java

    C#

     string 
  
 query 
  
 = 
  
 $ 
 @" 
 SELECT ad_group.id, ad_group.name, ad_group.targeting_setting.target_restrictions 
 FROM ad_group 
 WHERE ad_group.id = {adGroupId}" 
 ; 
 
      UpdateAudienceTargetRestriction 
 . 
 cs

    PHP

     $query = "SELECT ad_group.id, ad_group.name, " . 
 "ad_group.targeting_setting.target_restrictions " . 
 "FROM ad_group " . 
 "WHERE ad_group.id = $adGroupId"; 
     UpdateAudienceTargetRestriction.php

    Python

     query 
 : 
 str 
 = 
 f 
 """ 
 SELECT 
 ad_group.id, 
 ad_group.name, 
 ad_group.targeting_setting.target_restrictions 
 FROM ad_group 
 WHERE ad_group.id = 
 { 
 ad_group_id 
 } 
 """ 
 
      update_audience_target_restriction 
 . 
 py

    Ruby

     query 
  
 = 
  
<< ~ 
 QUERY 
  
 SELECT 
  
 ad_group 
 . 
 id 
 , 
  
 ad_group 
 . 
 name 
 , 
  
 ad_group 
 . 
 targeting_setting 
 . 
 target_restrictions 
  
 FROM 
  
 ad_group 
  
 WHERE 
  
 ad_group 
 . 
 id 
  
 = 
  
 #{ad_group_id} 
 QUERY 
     update_audience_target_restriction 

     
     
 . 
 rb

    Perl

     my 
  
 $query 
  
 = 
  
 "SELECT ad_group.id, ad_group.name, " 
  
 . 
  
 "ad_group.targeting_setting.target_restrictions FROM ad_group " 
  
 . 
  
 "WHERE ad_group.id = $ad_group_id" 
 ; 
 
      update_audience_target_restriction 
 . 
 pl

    Next, loop through the target restrictions and reconstruct the TargetingSetting objects. If the code encounters a TargetRestriction with a targeting_dimension of AUDIENCE and a bid_only value of false , it updates the TargetRestriction object's bid_only field to true (or "Observation") and add it to our TargetingSetting object.

    Otherwise, add the TargetRestriction object as returned from the server to the TargetingSetting . It is important to note that you must reconstruct and pass the entire TargetingSetting object back to Google Ads. Google assumes that any target_restrictions missing from the TargetingSetting should be removed.

    Java

     for 
  
 ( 
 TargetRestriction 
  
 targetRestriction 
  
 : 
  
 targetRestrictions 
 ) 
  
 { 
  
 TargetingDimension 
  
 targetingDimension 
  
 = 
  
 targetRestriction 
 . 
 getTargetingDimension 
 (); 
  
 boolean 
  
 bidOnly 
  
 = 
  
 targetRestriction 
 . 
 getBidOnly 
 (); 
  
 System 
 . 
 out 
 . 
 printf 
 ( 
  
 "- Targeting restriction with targeting dimension '%s' and bid only set to '%b'.%n" 
 , 
  
 targetingDimension 
 , 
  
 bidOnly 
 ); 
  
 // Adds the target restriction to the TargetingSetting object as is if the targeting 
  
 // dimension has a value other than AUDIENCE because those should not change. 
  
 if 
  
 ( 
 ! 
 targetingDimension 
 . 
 equals 
 ( 
 TargetingDimension 
 . 
 AUDIENCE 
 )) 
  
 { 
  
 targetingSettingBuilder 
 . 
 addTargetRestrictions 
 ( 
 targetRestriction 
 ); 
  
 } 
  
 else 
  
 if 
  
 ( 
 ! 
 bidOnly 
 ) 
  
 { 
  
 shouldUpdateTargetingSetting 
  
 = 
  
 true 
 ; 
  
 // Adds an AUDIENCE target restriction with bid_only set to true to the targeting 
  
 // setting object. This has the effect of setting the AUDIENCE target restriction to 
  
 // "Observation". For more details about the targeting setting, visit 
  
 // https://support.google.com/google-ads/answer/7365594. 
  
 targetingSettingBuilder 
 . 
 addTargetRestrictions 
 ( 
  
 TargetRestriction 
 . 
 newBuilder 
 () 
  
 . 
 setTargetingDimensionValue 
 ( 
 TargetingDimension 
 . 
 AUDIENCE_VALUE 
 ) 
  
 . 
 setBidOnly 
 ( 
 true 
 )); 
  
 } 
 } 
 
      UpdateAudienceTargetRestriction 
 . 
 java

    C#

     foreach 
  
 ( 
 TargetRestriction 
  
 targetRestriction 
  
 in 
  
 targetRestrictions 
 ) 
 { 
  
 TargetingDimension 
  
 targetingDimension 
  
 = 
  
 targetRestriction 
 . 
 TargetingDimension 
 ; 
  
 bool 
  
 bidOnly 
  
 = 
  
 targetRestriction 
 . 
 BidOnly 
 ; 
  
 Console 
 . 
 WriteLine 
 ( 
 "\tTargeting restriction with targeting dimension " 
  
 + 
  
 $"'{targetingDimension}' and bid only set to '{bidOnly}'." 
 ); 
  
 // Add the target restriction to the TargetingSetting object as is if the 
  
 // targeting dimension has a value other than AUDIENCE because those should 
  
 // not change. 
  
 if 
  
 ( 
 targetingDimension 
  
 != 
  
 TargetingDimension 
 . 
 Audience 
 ) 
  
 { 
  
 targetingSetting 
 . 
 TargetRestrictions 
 . 
 Add 
 ( 
 targetRestriction 
 ); 
  
 } 
  
 else 
  
 if 
  
 ( 
 ! 
 bidOnly 
 ) 
  
 { 
  
 shouldUpdateTargetingSetting 
  
 = 
  
 true 
 ; 
  
 // Add an AUDIENCE target restriction with bid_only set to true to the 
  
 // targeting setting object. This has the effect of setting the AUDIENCE 
  
 // target restriction to "Observation". For more details about the 
  
 // targeting setting, visit 
  
 // https://support.google.com/google-ads/answer/7365594. 
  
 targetingSetting 
 . 
 TargetRestrictions 
 . 
 Add 
 ( 
 new 
  
 TargetRestriction 
  
 { 
  
 TargetingDimension 
  
 = 
  
 TargetingDimension 
 . 
 Audience 
 , 
  
 BidOnly 
  
 = 
  
 true 
  
 }); 
  
 } 
 } 
 
      UpdateAudienceTargetRestriction 
 . 
 cs

    PHP

     foreach ( 
 $adGroup->getTargetingSetting()->getTargetRestrictions() as $targetRestriction 
 ) { 
 // Prints the results. 
 $targetingDimension = $targetRestriction->getTargetingDimension(); 
 $bidOnly = $targetRestriction->getBidOnly(); 
 printf( 
 "- Targeting restriction with targeting dimension '%s' and bid only set to " . 
 "'%s'.%s", 
 TargetingDimension::name($targetingDimension), 
 $bidOnly ? 'true' : 'false', 
 PHP_EOL 
 ); 
 // Adds the target restriction to the TargetingSetting object as is if the targeting 
 // dimension has a value other than AUDIENCE because those should not change. 
 if ($targetingDimension !== TargetingDimension::AUDIENCE) { 
 $targetRestrictions[] = $targetRestriction; 
 } elseif (!$bidOnly) { 
 $shouldUpdateTargetingSetting = true; 
 // Adds an AUDIENCE target restriction with bid_only set to true to the 
 // targeting setting object. This has the effect of setting the AUDIENCE 
 // target restriction to "Observation". 
 // For more details about the targeting setting, visit 
 // https://support.google.com/google-ads/answer/7365594. 
 $targetRestrictions[] = new TargetRestriction([ 
 'targeting_dimension' => TargetingDimension::AUDIENCE, 
 'bid_only' => true 
 ]); 
 } 
 } 
     UpdateAudienceTargetRestriction.php

    Python

     target_restriction 
 : 
 TargetRestriction 
 for 
 target_restriction 
 in 
 target_restrictions 
 : 
 targeting_dimension 
 : 
 TargetingDimensionEnum 
 . 
 TargetingDimension 
 = 
 ( 
 target_restriction 
 . 
 targeting_dimension 
 ) 
 bid_only 
 : 
 bool 
 = 
 target_restriction 
 . 
 bid_only 
 print 
 ( 
 " 
 \t 
 Targeting restriction with targeting dimension " 
 f 
 "' 
 { 
 targeting_dimension 
 . 
 name 
 } 
 ' " 
 f 
 "and bid only set to ' 
 { 
 bid_only 
 } 
 '." 
 ) 
 # Add the target restriction to the TargetingSetting object as 
 # is if the targeting dimension has a value other than audience 
 # because those should not change. 
 if 
 targeting_dimension 
 != 
 targeting_dimension_enum 
 . 
 AUDIENCE 
 : 
 targeting_setting 
 . 
 target_restrictions 
 . 
 append 
 ( 
 target_restriction 
 ) 
 elif 
 not 
 bid_only 
 : 
 should_update_targeting_setting 
 : 
 bool 
 = 
 True 
 # Add an audience target restriction with bid_only set to 
 # true to the targeting setting object. This has the effect 
 # of setting the audience target restriction to 
 # "Observation". For more details about the targeting 
 # setting, visit 
 # https://support.google.com/google-ads/answer/7365594. 
 new_target_restriction 
 : 
 TargetRestriction 
 = 
 ( 
 targeting_setting 
 . 
 target_restrictions 
 . 
 add 
 () 
 ) 
 new_target_restriction 
 . 
 targeting_dimension 
 = 
 ( 
 targeting_dimension_enum 
 . 
 AUDIENCE 
 ) 
 new_target_restriction 
 . 
 bid_only 
 = 
 True 
     update_audience_target_restriction 

     
     
 . 
 py

    Ruby

     ad_group 
 . 
 targeting_setting 
 . 
 target_restrictions 
 . 
 each 
  
 do 
  
 | 
 r 
 | 
  
 # Prints the results. 
  
 targeting_dimension 
  
 = 
  
 r 
 . 
 targeting_dimension 
  
 bid_only 
  
 = 
  
 r 
 . 
 bid_only 
  
 puts 
  
 "- Targeting restriction with targeting dimension " 
  
 \ 
  
 " 
 #{ 
 targeting_dimension 
 } 
 and bid only set to 
 #{ 
 bid_only 
 } 
 ." 
  
 # Adds the target restriction to the TargetingSetting object as is if the 
  
 # targeting dimension has a value other than AUDIENCE because those should 
  
 # not change. 
  
 if 
  
 targeting_dimension 
  
 != 
  
 :AUDIENCE 
  
 target_restrictions 
 << 
 r 
  
 elsif 
  
 ! 
 bid_only 
  
 should_update_targeting_setting 
  
 = 
  
 true 
  
 # Adds an AUDIENCE target restriction with bid_only set to true to the 
  
 # targeting setting object. This has the effect of setting the AUDIENCE 
  
 # target restriction to "Observation". 
  
 # For more details about the targeting setting, visit 
  
 # https://support.google.com/google-ads/answer/7365594. 
  
 target_restrictions 
 << 
 client 
 . 
 resource 
 . 
 target_restriction 
  
 do 
  
 | 
 tr 
 | 
  
 tr 
 . 
 targeting_dimension 
  
 = 
  
 :AUDIENCE 
  
 tr 
 . 
 bid_only 
  
 = 
  
 true 
  
 end 
  
 end 
 end 
     update_audience_target_restriction 

     
     
 . 
 rb

    Perl

     foreach 
  
 my 
  
 $target_restriction 
  
 ( 
 @target_restrictions 
 ) 
  
 { 
  
 my 
  
 $targeting_dimension 
  
 = 
  
 $target_restriction 
 - 
> { 
 targetingDimension 
 }; 
  
 printf 
  
 "\tTargeting restriction with targeting dimension '%s' and bid " 
  
 . 
  
 "only set to '%s'.\n" 
 , 
  
 $targeting_dimension 
 , 
  
 $target_restriction 
 - 
> { 
 bidOnly 
 } 
  
 ? 
  
 "TRUE" 
  
 : 
  
 "FALSE" 
 ; 
  
 # Add the target restriction to the TargetingSetting object as is if the 
  
 # targeting dimension has a value other than AUDIENCE because those 
  
 # should not change. 
  
 if 
  
 ( 
 $targeting_dimension 
  
 ne 
  
 AUDIENCE 
 ) 
  
 { 
  
 $target_restriction 
 - 
> { 
 bidOnly 
 } 
  
 = 
  
 $target_restriction 
 - 
> { 
 bidOnly 
 } 
  
 ? 
  
 "true" 
  
 : 
  
 "false" 
 ; 
  
 push 
  
 @ 
 { 
 $targeting_setting 
 - 
> { 
 targetRestrictions 
 }}, 
  
 $target_restriction 
 ; 
  
 } 
  
 elsif 
  
 ( 
 ! 
 $target_restriction 
 - 
> { 
 bidOnly 
 }) 
  
 { 
  
 $should_update_target_setting 
  
 = 
  
 1 
 ; 
  
 # Add an AUDIENCE target restriction with bid_only set to true to the 
  
 # targeting setting object. This has the effect of setting the 
  
 # AUDIENCE target restriction to "Observation". For more details about 
  
 # the targeting setting, visit 
  
 # https://support.google.com/google-ads/answer/7365594. 
  
 my 
  
 $new_restriction 
  
 = 
  
 Google::Ads::GoogleAds::V21::Common:: 
 TargetRestriction 
 - 
> new 
 ({ 
  
 targetingDimension 
  
 = 
>  
 AUDIENCE 
 , 
  
 bidOnly 
  
 = 
>  
 "true" 
  
 }); 
  
 push 
  
 @ 
 { 
 $targeting_setting 
 - 
> { 
 targetRestrictions 
 }}, 
  
 $new_restriction 
 ; 
  
 } 
 } 
 
      update_audience_target_restriction 
 . 
 pl

    Finally, if the code encounters a target restriction that requires updating, it updates the ad group with the new targeting settings.

    Java

     private 
  
 void 
  
 updateTargetingSetting 
 ( 
  
 GoogleAdsClient 
  
 googleAdsClient 
 , 
  
 long 
  
 customerId 
 , 
  
 long 
  
 adGroupId 
 , 
  
 TargetingSetting 
  
 targetingSetting 
 ) 
  
 { 
  
 // Creates the ad group service client. 
  
 try 
  
 ( 
 AdGroupServiceClient 
  
 adGroupServiceClient 
  
 = 
  
 googleAdsClient 
 . 
 getLatestVersion 
 (). 
 createAdGroupServiceClient 
 ()) 
  
 { 
  
 // Creates an ad group object with the proper resource name and updated targeting setting. 
  
 AdGroup 
  
 adGroup 
  
 = 
  
 AdGroup 
 . 
 newBuilder 
 () 
  
 . 
 setResourceName 
 ( 
 ResourceNames 
 . 
 adGroup 
 ( 
 customerId 
 , 
  
 adGroupId 
 )) 
  
 . 
 setTargetingSetting 
 ( 
 targetingSetting 
 ) 
  
 . 
 build 
 (); 
  
 // Constructs an operation that will update the ad group, using the FieldMasks utility to 
  
 // derive the update mask. This mask tells the Google Ads API which attributes of the 
  
 // ad group you want to change. 
  
 AdGroupOperation 
  
 operation 
  
 = 
  
 AdGroupOperation 
 . 
 newBuilder 
 () 
  
 . 
 setUpdate 
 ( 
 adGroup 
 ) 
  
 . 
 setUpdateMask 
 ( 
 FieldMasks 
 . 
 allSetFieldsOf 
 ( 
 adGroup 
 )) 
  
 . 
 build 
 (); 
  
 // Sends the operation in a mutate request. 
  
 MutateAdGroupsResponse 
  
 response 
  
 = 
  
 adGroupServiceClient 
 . 
 mutateAdGroups 
 ( 
  
 Long 
 . 
 toString 
 ( 
 customerId 
 ), 
  
 ImmutableList 
 . 
 of 
 ( 
 operation 
 )); 
  
 // Prints the resource name of the updated object. 
  
 System 
 . 
 out 
 . 
 printf 
 ( 
  
 "Updated targeting setting of ad group with resource name '%s'; set the AUDIENCE " 
  
 + 
  
 "target restriction to 'Observation'.%n" 
 , 
  
 response 
 . 
 getResults 
 ( 
 0 
 ). 
 getResourceName 
 ()); 
  
 } 
 } 
 
      UpdateAudienceTargetRestriction 
 . 
 java

    C#

     private 
  
 void 
  
 UpdateTargetingSetting 
 ( 
 GoogleAdsClient 
  
 client 
 , 
  
 long 
  
 customerId 
 , 
  
 long 
  
 adGroupId 
 , 
  
 TargetingSetting 
  
 targetingSetting 
 ) 
 { 
  
 // Get the AdGroupService client. 
  
 AdGroupServiceClient 
  
 adGroupServiceClient 
  
 = 
  
 client 
 . 
 GetService 
 ( 
 Services 
 . 
 V21 
 . 
 AdGroupService 
 ); 
  
 // Create an ad group object with the updated targeting setting. 
  
 AdGroup 
  
 adGroup 
  
 = 
  
 new 
  
 AdGroup 
  
 { 
  
 ResourceName 
  
 = 
  
 ResourceNames 
 . 
 AdGroup 
 ( 
 customerId 
 , 
  
 adGroupId 
 ), 
  
 TargetingSetting 
  
 = 
  
 targetingSetting 
  
 }; 
  
 // Construct an operation that will update the ad group, using the FieldMasks utility 
  
 // to derive the update mask. This mask tells the Google Ads API which attributes of the 
  
 // ad group you want to change. 
  
 AdGroupOperation 
  
 operation 
  
 = 
  
 new 
  
 AdGroupOperation 
  
 { 
  
 Update 
  
 = 
  
 adGroup 
 , 
  
 UpdateMask 
  
 = 
  
 FieldMasks 
 . 
 AllSetFieldsOf 
 ( 
 adGroup 
 ) 
  
 }; 
  
 // Send the operation in a mutate request. 
  
 MutateAdGroupsResponse 
  
 response 
  
 = 
  
 adGroupServiceClient 
 . 
 MutateAdGroups 
 ( 
 customerId 
 . 
 ToString 
 (), 
  
 new 
 [] 
  
 { 
  
 operation 
  
 }); 
  
 // Print the resource name of the updated object. 
  
 Console 
 . 
 WriteLine 
 ( 
 "Updated targeting setting of ad group with resource name " 
  
 + 
  
 $"'{response.Results.First().ResourceName}'; set the AUDIENCE target restriction " 
  
 + 
  
 "to 'Observation'." 
 ); 
 } 
 
      UpdateAudienceTargetRestriction 
 . 
 cs

    PHP

     private static function updateTargetingSetting( 
 GoogleAdsClient $googleAdsClient, 
 int $customerId, 
 int $adGroupId, 
 TargetingSetting $targetingSetting 
 ) { 
 // Creates an ad group object with the proper resource name and updated targeting setting. 
 $adGroup = new AdGroup([ 
 'resource_name' => ResourceNames::forAdGroup($customerId, $adGroupId), 
 'targeting_setting' => $targetingSetting 
 ]); 
 // Constructs an operation that will update the ad group with the specified resource name, 
 // using the FieldMasks utility to derive the update mask. This mask tells the Google Ads 
 // API which attributes of the ad group you want to change. 
 $adGroupOperation = new AdGroupOperation(); 
 $adGroupOperation->setUpdate($adGroup); 
 $adGroupOperation->setUpdateMask(FieldMasks::allSetFieldsOf($adGroup)); 
 // Issues a mutate request to update the ad group. 
 $adGroupServiceClient = $googleAdsClient->getAdGroupServiceClient(); 
 $response = $adGroupServiceClient->mutateAdGroups( 
 MutateAdGroupsRequest::build($customerId, [$adGroupOperation]) 
 ); 
 // Prints the resource name of the updated ad group. 
 printf( 
 "Updated targeting setting of ad group with resource name '%s'; set the AUDIENCE " . 
 "target restriction to 'Observation'.%s", 
 $response->getResults()[0]->getResourceName(), 
 PHP_EOL 
 ); 
 } 
     UpdateAudienceTargetRestriction.php

    Python

     def 
  
 update_targeting_setting 
 ( 
 client 
 : 
 GoogleAdsClient 
 , 
 customer_id 
 : 
 str 
 , 
 ad_group_id 
 : 
 str 
 , 
 targeting_setting 
 : 
 TargetingSetting 
 , 
 ) 
 - 
> None 
 : 
  
 """Updates the given TargetingSetting of an ad group. 
 Args: 
 client: The Google Ads client. 
 customer_id: The Google Ads customer ID. 
 ad_group_id: The ad group ID for which to update the audience targeting 
 restriction. 
 targeting_setting: The updated targeting setting. 
 """ 
 # Get the AdGroupService client. 
 ad_group_service 
 : 
 AdGroupServiceClient 
 = 
 client 
 . 
 get_service 
 ( 
 "AdGroupService" 
 ) 
 # Construct an operation that will update the ad group. 
 ad_group_operation 
 : 
 AdGroupOperation 
 = 
 client 
 . 
 get_type 
 ( 
 "AdGroupOperation" 
 ) 
 # Populate the ad group object with the updated targeting setting. 
 ad_group 
 : 
 AdGroup 
 = 
 ad_group_operation 
 . 
 update 
 ad_group 
 . 
 resource_name 
 = 
 ad_group_service 
 . 
 ad_group_path 
 ( 
 customer_id 
 , 
 ad_group_id 
 ) 
 ad_group 
 . 
 targeting_setting 
 . 
 target_restrictions 
 . 
 extend 
 ( 
 targeting_setting 
 . 
 target_restrictions 
 ) 
 # Use the field_mask utility to derive the update mask. This mask tells the 
 # Google Ads API which attributes of the ad group you want to change. 
 client 
 . 
 copy_from 
 ( 
 ad_group_operation 
 . 
 update_mask 
 , 
 protobuf_helpers 
 . 
 field_mask 
 ( 
 None 
 , 
 ad_group 
 . 
 _pb 
 ), 
 ) 
 # Send the operation in a mutate request and print the resource name of the 
 # updated object. 
 mutate_ad_groups_response 
 : 
 MutateAdGroupsResponse 
 = 
 ( 
 ad_group_service 
 . 
 mutate_ad_groups 
 ( 
 customer_id 
 = 
 customer_id 
 , 
 operations 
 = 
 [ 
 ad_group_operation 
 ] 
 ) 
 ) 
 print 
 ( 
 "Updated targeting setting of ad group with resource name " 
 f 
 "' 
 { 
 mutate_ad_groups_response 
 . 
 results 
 [ 
 0 
 ] 
 . 
 resource_name 
 } 
 '; set the " 
 "audience target restriction to 'Observation'." 
 ) 
 
      update_audience_target_restriction 
 . 
 py

    Ruby

     def 
  
 update_targeting_setting 
 ( 
  
 client 
 , 
  
 customer_id 
 , 
  
 ad_group_id 
 , 
  
 targeting_setting 
 ) 
  
 # Constructs an operation that will update the ad group with the specified 
  
 # resource name. 
  
 ad_group_resource_name 
  
 = 
  
 client 
 . 
 path 
 . 
 ad_group 
 ( 
 customer_id 
 , 
  
 ad_group_id 
 ) 
  
 operation 
  
 = 
  
 client 
 . 
 operation 
 . 
 update_resource 
 . 
 ad_group 
 ( 
 ad_group_resource_name 
 ) 
  
 do 
  
 | 
 ag 
 | 
  
 ag 
 . 
 targeting_setting 
  
 = 
  
 targeting_setting 
  
 end 
  
 # Issues a mutate request to update the ad group. 
  
 response 
  
 = 
  
 client 
 . 
 service 
 . 
 ad_group 
 . 
 mutate_ad_groups 
 ( 
  
 customer_id 
 : 
  
 customer_id 
 , 
  
 operations 
 : 
  
 [ 
 operation 
 ] 
 , 
  
 ) 
  
 # Prints the resource name of the updated ad group. 
  
 puts 
  
 "Updated targeting setting of ad group with resource name " 
  
 \ 
  
 " 
 #{ 
 response 
 . 
 results 
 . 
 first 
 . 
 resource_name 
 } 
 ; set the AUDIENCE target " 
  
 \ 
  
 "restriction to 'Observation'." 
 end 
     update_audience_target_restriction 

     
     
 . 
 rb

    Perl

     sub 
  
 update_targeting_setting 
  
 { 
  
 my 
  
 ( 
 $api_client 
 , 
  
 $customer_id 
 , 
  
 $ad_group_id 
 , 
  
 $targeting_setting 
 ) 
  
 = 
  
 @_ 
 ; 
  
 # Construct an ad group object with the updated targeting setting. 
  
 my 
  
 $ad_group 
  
 = 
  
 Google::Ads::GoogleAds::V21::Resources:: 
 AdGroup 
 - 
> new 
 ({ 
  
 resourceName 
  
 = 
>  
 Google::Ads::GoogleAds::V21::Utils::ResourceNames:: 
 ad_group 
 ( 
  
 $customer_id 
 , 
  
 $ad_group_id 
  
 ), 
  
 targetingSetting 
  
 = 
>  
 $targeting_setting 
  
 }); 
  
 # Create an operation that will update the ad group, using the FieldMasks 
  
 # utility to derive the update mask. This mask tells the Google Ads API which 
  
 # attributes of the ad group you want to change. 
  
 my 
  
 $ad_group_operation 
  
 = 
  
 Google::Ads::GoogleAds::V21::Services::AdGroupService:: 
 AdGroupOperation 
 - 
>  
 new 
 ({ 
  
 update 
  
 = 
>  
 $ad_group 
 , 
  
 updateMask 
  
 = 
>  
 all_set_fields_of 
 ( 
 $ad_group 
 )}); 
  
 # Send the operation in a mutate request and print the resource name of the 
  
 # updated resource. 
  
 my 
  
 $ad_groups_response 
  
 = 
  
 $api_client 
 - 
> AdGroupService 
 () 
 - 
> mutate 
 ({ 
  
 customerId 
  
 = 
>  
 $customer_id 
 , 
  
 operations 
  
 = 
>  
 [ 
 $ad_group_operation 
 ]}); 
  
 printf 
  
 "Updated targeting setting of ad group with resourceName " 
  
 . 
  
 "'%s'; set the AUDIENCE target restriction to 'Observation'.\n" 
 , 
  
 $ad_groups_response 
 - 
> { 
 results 
 }[ 
 0 
 ]{ 
 resourceName 
 }; 
 } 
 
      update_audience_target_restriction 
 . 
 pl

    The process for setting the bid_only field for campaigns is nearly identical.

    Previous
    Location targeting
    Design a Mobile Site
    View Site in Mobile | Classic
    Share by: