Ustawienia kierowania

Użyj ustawienia kierowania w grup reklam lub kampanii, aby określić, czy reklamy mają być wyświetlane tylko do konkretnych segmentów odbiorców lub do konkretnych treści.

Konfigurowanie ustawień kierowania

Możesz określić szczegółowe informacje o sposobie wykorzystywania różnych typów kryteriów do kierowania przez ustawienie w polu TargetingSetting parametru tablica target_restrictions Każda TargetRestriction pozwala kontrolować czy w typie kryterium stosowany jest parametr bid_only.

Gdy ustawisz wartość true na bid_only, zastosujemy takie ustawienie kierowania: ustawienia „Obserwacja”, a kryteria nie będą służyć do ograniczania ruchu, ale umożliwiają określanie różnych stawek dla różnych użytkowników z list. Ustawienie Od bid_only do false ustawiane jest ustawienie kierowania „Kierowanie” i włącza funkcję ograniczenia wyświetlania w grupie reklam tylko do użytkowników z listy kierowania.

Sprawdzone metody

Domyślnie bid_only ma wartość false, co oznacza, że ustawienia kierowania będą wybrać „Kierowanie”. Jeśli dodajesz segmenty odbiorców do wyszukiwania lub kampanii produktowej, rozważ zmianę ustawienia kierowania „bid_only” na true, aby wybrać ustawienie „Obserwacja”.

Jeśli konfigurujesz zduplikowaną kampanię dla segmentów odbiorców dla reklam w wyszukiwarce, utrzymuj kierowanie w elemencie bid_only na false.

Ograniczenia

Nie możesz dodawać ani aktualizować targeting_settingAdGroup jeśli targeting_setting jest ustawiony na nadrzędną kampanią. Jeśli właściwość targeting_setting jest ustawiona w elemencie nadrzędnym Campaign, musi najpierw usunąć element targeting_setting w elemencie nadrzędnym Campaign. Podobnie, musisz najpierw usunąć targeting_setting z AdGroup, aby ustawić go w Campaign.

Pobieranie ustawienia kierowania

Aby się upewnić, że kierowanie jest ustawione zgodnie z oczekiwaniami, sprawdź targeting_setting w grupach reklam lub kampaniach, wysyłając żądanie o ad_group.targeting_setting.target_restrictions. z zasobu ad_group w zapytaniu.

Przykład

Ten przykład zmienia pole targeting_setting w grupie reklam, tak że bid_only jest true dla TargetRestriction instancji z targeting_dimension równym AUDIENCE, co daje pewność, że reklamy z danej grupy będą wyświetlane tylko użytkownikom wybranego segmentu odbiorców.

Najpierw pobierz wszystkie ad_group.targeting_setting.target_restrictions z grupę reklam o podanym identyfikatorze.

String searchQuery =
   
"SELECT ad_group.id, ad_group.name, ad_group.targeting_setting.target_restrictions "
       
+ "FROM ad_group "
       
+ "WHERE ad_group.id = "
       
+ adGroupId;
     
string query = $@"
    SELECT ad_group.id, ad_group.name, ad_group.targeting_setting.target_restrictions
    FROM ad_group
    WHERE ad_group.id = {adGroupId}"
;
     
$query = "SELECT ad_group.id, ad_group.name, " .
   
"ad_group.targeting_setting.target_restrictions " .
   
"FROM ad_group " .
   
"WHERE ad_group.id = $adGroupId";
     
query = f"""
    SELECT
      ad_group.id,
      ad_group.name,
      ad_group.targeting_setting.target_restrictions
    FROM ad_group
    WHERE ad_group.id = {ad_group_id}"""

     
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

     
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";
     

Następnie przejrzyj ograniczenia kierowania i odtwórz TargetingSetting obiekty. Jeśli kod napotyka TargetRestriction z targeting_dimension o wartości AUDIENCE i bid_only o wartości false, aktualizuje pole bid_only obiektu TargetRestriction na true (lub „Obserwacja”) i dodaj ją do obiektu TargetingSetting.

W przeciwnym razie dodaj obiekt TargetRestriction zwrócony z serwera do TargetingSetting Trzeba pamiętać, że należy odtworzyć i przekazać cały obiekt TargetingSetting z powrotem do Google Ads. Google zakłada, że każdy target_restrictions brakujące w pozycji TargetingSetting powinny zostać usunięte.

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));
 
}
}
     
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
       
});
   
}
}
     
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
       
]);
   
}
}
     
for target_restriction in target_restrictions:
    targeting_dimension
= target_restriction.targeting_dimension
    bid_only
= target_restriction.bid_only

   
print(
       
"\tTargeting 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
= 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
= targeting_setting.target_restrictions.add()
        new_target_restriction
.targeting_dimension = (
            targeting_dimension_enum
.AUDIENCE
       
)
        new_target_restriction
.bid_only = True
     
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
     
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::V17::Common::TargetRestriction->new({
        targetingDimension
=> AUDIENCE,
        bidOnly            
=> "true"
     
});
    push
@{$targeting_setting->{targetRestrictions}}, $new_restriction;
 
}
}
     

Jeśli kod napotka ograniczenie docelowe, które wymaga aktualizacji, aktualizuje grupę reklam o nowe ustawienia kierowania.

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());
 
}
}
     
private void UpdateTargetingSetting(GoogleAdsClient client, long customerId, long
    adGroupId
, TargetingSetting targetingSetting)
{
   
// Get the AdGroupService client.
   
AdGroupServiceClient adGroupServiceClient =
        client
.GetService(Services.V17.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'.");
}
     
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
   
);
}
     
def update_targeting_setting(
    client
, customer_id, ad_group_id, targeting_setting
):
   
"""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
= client.get_service("AdGroupService")

   
# Construct an operation that will update the ad group.
    ad_group_operation
= client.get_type("AdGroupOperation")

   
# Populate the ad group object with the updated targeting setting.
    ad_group
= 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
= 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'."
   
)
     
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
     
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::V17::Resources::AdGroup->new({
      resourceName
=>
       
Google::Ads::GoogleAds::V17::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::V17::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};
}
     

Proces ustawiania pola bid_only w przypadku kampanii jest prawie taki sam.