ใช้การตั้งค่าการกำหนดเป้าหมายใน กลุ่มโฆษณาหรือแคมเปญเพื่อระบุว่าจะจำกัดการแสดงโฆษณาให้แสดงเฉพาะ ไปยังกลุ่มผู้ชมที่เฉพาะเจาะจง หรือในเนื้อหาเฉพาะที่คุณเลือก
ตั้งค่าการกำหนดเป้าหมาย
คุณสามารถตั้งค่ารายละเอียดว่าจะใช้เกณฑ์ประเภทต่างๆ ในการกำหนดเป้าหมายอย่างไร
โดยการตั้งค่าช่อง TargetingSetting
ด้วย
อาร์เรย์ของ
target_restrictions
TargetRestriction
แต่ละรายการให้คุณควบคุมได้
ประเภทของเกณฑ์จะใช้
bid_only
หรือไม่
เมื่อตั้งค่า bid_only
เป็น true
ระบบจะตั้งค่าการกำหนดเป้าหมายเป็น
"การสังเกตการณ์" และเกณฑ์จะไม่ใช้เพื่อจำกัดการเข้าชม แต่จะ
ช่วยให้คุณเสนอราคาที่แตกต่างกันสำหรับผู้ใช้ต่างๆ ในรายการได้ การเกริ่นนำ
bid_only
เป็น false
ตั้งค่าการกำหนดเป้าหมายเป็น "การกำหนดเป้าหมาย" และเปิดใช้
เกณฑ์เพื่อจำกัดการเข้าชมของกลุ่มโฆษณาไว้เฉพาะผู้ใช้ในรายการที่กำหนดเป้าหมายเท่านั้น
แนวทางปฏิบัติแนะนำ
โดยค่าเริ่มต้น bid_only
จะมีค่าเป็น false
ซึ่งหมายความว่าการตั้งค่าการกำหนดเป้าหมายจะ
ตั้งค่าเป็น "การกำหนดเป้าหมาย" หากคุณกำลังเพิ่มกลุ่มเป้าหมายในการค้นหาหรือ
แคมเปญ Shopping พิจารณาเปลี่ยนการตั้งค่าการกำหนดเป้าหมายของ bid_only
เป็น
true
เพื่อตั้งค่าเป็น "การสังเกตการณ์"
หากคุณสร้างแคมเปญซ้ำสำหรับกลุ่มเป้าหมายสำหรับโฆษณา Search
ให้กำหนดเป้าหมายของ bid_only
เป็น false
ต่อไป
ข้อจำกัด
คุณไม่สามารถเพิ่มหรืออัปเดตได้
targeting_setting
ใน AdGroup
หากตั้งค่า targeting_setting
ใน
แคมเปญหลัก หากตั้งค่า targeting_setting
ไว้ใน Campaign
ระดับบน
ต้องนำ targeting_setting
ออกจาก Campaign
ระดับบนก่อน ในทำนองเดียวกัน
คุณต้องนำ targeting_setting
ออกจาก AdGroup
ก่อนเพื่อตั้งค่า
ได้ในCampaign
ดึงข้อมูลการตั้งค่าการกำหนดเป้าหมาย
หากต้องการตรวจสอบว่าได้ตั้งค่าการกำหนดเป้าหมายไว้ตามที่ต้องการ ให้ตรวจสอบ
targeting_setting
ในกลุ่มโฆษณาหรือแคมเปญโดยการขอ
ad_group.targeting_setting.target_restrictions
จากแหล่งข้อมูล ad_group
ในคำค้นหา
ตัวอย่าง
ตัวอย่างนี้อัปเดต targeting_setting
ในกลุ่มโฆษณาเพื่อให้ bid_only
คือ true
สำหรับ TargetRestriction
อินสแตนซ์ที่มี targeting_dimension
ของ
AUDIENCE
,
การตรวจสอบอย่างมีประสิทธิภาพว่า โฆษณาในกลุ่มโฆษณาจะแสดงต่อผู้ใช้ใน
กลุ่มผู้ชมที่ระบุ
ขั้นแรก ให้ดึงข้อมูล ad_group.targeting_setting.target_restrictions
ทั้งหมดจาก
กลุ่มโฆษณาที่มีรหัสที่ระบุ
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";
จากนั้น ให้วนแก้ไขข้อจำกัดเป้าหมายและสร้างพารามิเตอร์
ออบเจ็กต์ TargetingSetting
รายการ หากโค้ดพบ TargetRestriction
ที่มีแอตทริบิวต์
targeting_dimension
ของ AUDIENCE
และค่า bid_only
ของ false
อัปเดตฟิลด์ bid_only
ของวัตถุ TargetRestriction
เป็น true
(หรือ
"การสังเกตการณ์") แล้วเพิ่มลงในออบเจ็กต์ TargetingSetting
ของเรา
หรือไม่เช่นนั้น ให้เพิ่มออบเจ็กต์ TargetRestriction
ที่ส่งคืนจากเซิร์ฟเวอร์ไปยัง
TargetingSetting
โปรดทราบว่าคุณต้องสร้างและ
ออบเจ็กต์ TargetingSetting
ทั้งหมดกลับไปยัง Google Ads Google มีสมมติฐานว่า
ควรนำ target_restrictions
ที่หายไปออกจาก TargetingSetting
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;
}
}
สุดท้าย หากโค้ดพบข้อจำกัดเป้าหมายที่ต้องมีการอัปเดต ให้อัปเดตกลุ่มโฆษณาด้วยการตั้งค่าการกำหนดเป้าหมายใหม่
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};
}
กระบวนการตั้งค่าช่อง bid_only
ของแคมเปญแทบจะเหมือนกันทั้งหมด