Utiliza la configuración de segmentación en tus grupos de anuncios o campañas para especificar si deseas limitar los anuncios para que se muestren solo a segmentos de público específicos o en el contenido específico que seleccionaste.
Cómo configurar la segmentación
Si quieres configurar los detalles sobre cómo se usan los distintos tipos de criterios para la segmentación, configura el campo TargetingSetting con un array de target_restrictions.
Cada TargetRestriction te permite controlar si un tipo de criterio usa la opción bid_only o no.
Cuando establezcas bid_only en true, la configuración de la segmentación se establecerá en
"Observación", y los criterios no se usarán para restringir el tráfico, pero te
permitirán realizar ofertas diferentes para los distintos usuarios de tus listas. Si estableces bid_only en false, se establece la configuración de la segmentación en "Segmentación" y se habilitan los criterios para restringir el tráfico del grupo de anuncios solo a los usuarios de la lista de segmentación.
Prácticas recomendadas
Según la configuración predeterminada, bid_only se establece en false, lo que significa que la configuración de la segmentación se establecerá en “Segmentación”. Si agregas segmentos de público a una campaña de Búsqueda o de Shopping, considera cambiar la configuración de segmentación de bid_only a true para establecerla en "Observación".
Si deseas configurar una campaña duplicada para los segmentos de público de los anuncios de búsqueda, mantén la segmentación de bid_only establecida en false.
Restricciones
No puedes agregar ni actualizar targeting_setting en una AdGroup si se configuró targeting_setting en la campaña superior. Si el targeting_setting está configurado en el Campaign superior, primero debes quitar el targeting_setting en el Campaign superior. Del mismo modo, primero debes quitar el objeto targeting_setting de la AdGroup para poder configurarlo en el Campaign.
Recupera la configuración de la segmentación
Para verificar que la segmentación esté configurada como deseas, verifica el targeting_setting en los grupos de anuncios o campañas. Para ello, solicita el campo ad_group.targeting_setting.target_restrictions del recurso ad_group en una búsqueda.
Ejemplo
En este ejemplo, se actualiza la targeting_setting de un grupo de anuncios para que bid_only sea true para las instancias de TargetRestriction con un targeting_dimension de AUDIENCE, lo que garantiza de manera efectiva que los anuncios del grupo de anuncios solo se muestren a los usuarios del segmento de público especificado.
Primero, recupera todos los ad_group.targeting_setting.target_restrictions del grupo de anuncios con el ID proporcionado.
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}"""
Rita
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";
A continuación, recorre las restricciones de destino y reconstruye los objetos TargetingSetting. Si el código encuentra un TargetRestriction con un targeting_dimension de AUDIENCE y un valor bid_only de false, actualiza el campo bid_only del objeto TargetRestriction a true (o bien "Observación") y lo agrega a nuestro objeto TargetingSetting.
De lo contrario, agrega el objeto TargetRestriction como se muestra en el servidor a TargetingSetting. Es importante tener en cuenta que debes reconstruir y pasar todo el objeto TargetingSetting a Google Ads. Google supone que debe quitarse cualquier target_restrictions que falte en 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
Rita
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::V16::Common::TargetRestriction->new({
targetingDimension => AUDIENCE,
bidOnly => "true"
});
push @{$targeting_setting->{targetRestrictions}}, $new_restriction;
}
}
Por último, si el código encuentra una restricción de objetivo que requiere actualización, actualiza el grupo de anuncios con la nueva configuración de la segmentación.
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.V16.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'."
)
Rita
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::V16::Resources::AdGroup->new({
resourceName =>
Google::Ads::GoogleAds::V16::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::V16::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};
}
El proceso para configurar el campo bid_only de las campañas es casi idéntico.