Mithilfe der Ausrichtungseinstellung in Ihren Anzeigengruppen oder Kampagnen können Sie festlegen, ob die Anzeigen nur für bestimmte Zielgruppensegmente oder nur für von Ihnen ausgewählte Inhalte ausgeliefert werden sollen.
Ausrichtungseinstellung festlegen
Sie können genau festlegen, wie die verschiedenen Kriterientypen für das Targeting verwendet werden, indem Sie das Feld TargetingSetting mit einem Array von target_restrictions festlegen.
Mit jedem TargetRestriction können Sie festlegen, ob für einen Kriterientyp die Option bid_only verwendet wird oder nicht.
Wenn Sie bid_only auf true setzen, wird die Ausrichtungseinstellung auf "Beobachtung" festgelegt. Die Kriterien werden dann nicht zur Einschränkung der Zugriffe verwendet, Sie können aber für unterschiedliche Nutzer auf Ihren Listen unterschiedliche Gebote abgeben. Wenn Sie bid_only auf false setzen, wird die Targeting-Einstellung auf „Targeting“ festgelegt und mit den Kriterien wird der Anzeigengruppen-Traffic auf Nutzer in der Targeting-Liste beschränkt.
Best Practices
Standardmäßig ist bid_only auf false gesetzt. Das bedeutet, dass die Targeting-Einstellung auf „Targeting“ festgelegt ist. Wenn Sie einer Such- oder Shopping-Kampagne Zielgruppensegmente hinzufügen, sollten Sie die Ausrichtungseinstellung von bid_only in true ändern und dort auf „Beobachtung“ festlegen.
Wenn Sie eine duplizierte Kampagne mit Zielgruppensegmenten für Suchanzeigen einrichten, behalten Sie das Targeting von bid_only auf false bei.
Einschränkungen
Sie können targeting_setting für AdGroup weder hinzufügen noch aktualisieren, wenn targeting_setting für die übergeordnete Kampagne festgelegt ist. Wenn targeting_setting für die übergeordnete Campaign festgelegt ist, müssen Sie zuerst targeting_setting für das übergeordnete Campaign entfernen. Ebenso müssen Sie zuerst das targeting_setting auf dem AdGroup entfernen, um es für das Campaign festzulegen.
Targeting-Einstellung abrufen
Wenn Sie prüfen möchten, ob die Ausrichtung wie gewünscht eingerichtet ist, prüfen Sie die targeting_setting für Anzeigengruppen oder Kampagnen. Fordern Sie dazu in einer Suchanfrage das Feld ad_group.targeting_setting.target_restrictions aus der Ressource ad_group an.
Beispiel
In diesem Beispiel wird die targeting_setting für eine Anzeigengruppe so aktualisiert, dass bid_only für TargetRestriction-Instanzen mit einem targeting_dimension von AUDIENCE auf true gesetzt ist. Dadurch wird sichergestellt, dass Anzeigen in der Anzeigengruppe nur für Nutzer im angegebenen Zielgruppensegment ausgeliefert werden.
Rufen Sie zuerst alle ad_group.targeting_setting.target_restrictions aus der Anzeigengruppe mit der angegebenen ID ab.
Java
String searchQuery =
"SELECT ad_group.id, ad_group.name, ad_group.targeting_setting.target_restrictions "
+ "FROM ad_group "
+ "WHERE ad_group.id = "
+ adGroupId;
C#
string query = $@"
SELECT ad_group.id, ad_group.name, ad_group.targeting_setting.target_restrictions
FROM ad_group
WHERE ad_group.id = {adGroupId}";
PHP
$query = "SELECT ad_group.id, ad_group.name, " .
"ad_group.targeting_setting.target_restrictions " .
"FROM ad_group " .
"WHERE ad_group.id = $adGroupId";
Python
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}"""
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
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";
Gehen Sie als Nächstes die Zieleinschränkungen durch und rekonstruieren Sie die TargetingSetting-Objekte. Wenn der Code auf ein TargetRestriction mit einem targeting_dimension von AUDIENCE und einem bid_only-Wert von false stößt, wird das Feld bid_only des TargetRestriction-Objekts auf true (oder „Beobachtung“) aktualisiert und dem TargetingSetting-Objekt hinzugefügt.
Andernfalls fügen Sie das TargetRestriction-Objekt so hinzu, wie es vom Server zurückgegeben wird, dem TargetingSetting. Das gesamte TargetingSetting-Objekt muss rekonstruiert und an Google Ads zurückgegeben werden. Google geht davon aus, dass alle target_restrictions-Elemente, die in TargetingSetting fehlen, entfernt werden sollten.
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));
}
}
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
});
}
}
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
]);
}
}
Python
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
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
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::V17::Common::TargetRestriction->new({
targetingDimension => AUDIENCE,
bidOnly => "true"
});
push @{$targeting_setting->{targetRestrictions}}, $new_restriction;
}
}
Wenn der Code auf eine Zieleinschränkung stößt, die aktualisiert werden muss, wird die Anzeigengruppe mit den neuen Targeting-Einstellungen aktualisiert.
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());
}
}
C#
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'.");
}
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
);
}
Python
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'."
)
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
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::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};
}
Das Festlegen des Felds bid_only für Kampagnen ist nahezu identisch.