Puedes segmentar tus anuncios para personas que visitaron páginas o secciones específicas de tu
sitio web con una flexible_rule_user_list,
lo que te permite segmentar tus anuncios para URLs más específicas que el dominio de tu sitio web.
Requisitos previos
Para crear segmentos de público y orientar sus anuncios a ellos, primero debe hacer lo siguiente:
Revisa el para la publicidad basada en intereses y ubicación. No se puede utilizar información sensible sobre los usuarios para crear públicos.
Configura tu etiqueta de Google.
Los anunciantes que buscan crear listas de usuarios basadas en el comportamiento de las aplicaciones para dispositivos móviles deben implementar el SDK de Firebase o trabajar con SDK de terceros para realizar un seguimiento el comportamiento en la app.
Recupera la etiqueta de Google
Todas las cuentas de Google Ads tienen exactamente una cuenta de Google a nivel de la cuenta etiqueta, creada automáticamente cuando se abre la cuenta.
Para recuperar la etiqueta de Google en la IU de Google Ads, consulta el Centro de ayuda
instrucciones o en
la API de Google Ads creando un RemarketingAction y, luego, recuperando la etiqueta de Google
a través de la emisión de un
GoogleAdsService.searchStream
solicitud con el remarketing_action
recurso:
SELECT
remarketing_action.id,
remarketing_action.name,
remarketing_action.tag_snippets
FROM remarketing_action
WHERE remarketing_action.resource_name = 'REMARKETING_ACTION_RESOURCE_NAME'
Instala la etiqueta de Google en tu sitio web o aplicación
El siguiente paso es instalar tu etiqueta de Google en todas las páginas de tu sitio. Aprendizaje Más información para agregar la etiqueta de Google a tu sitio o dispositivo móvil de la app.
Si planeas crear segmentos de público basados solo en las URLs de las páginas visitadas, No necesitas editar tu etiqueta de Google. Si utilizas parámetros, debes editar la etiqueta para incluirlos, tal como se detalla en Configuración avanzada estrategias para etiquetar y crear listas.
Puedes usar Google Tag Assistant para validar la instalación de la etiqueta.
Parámetros integrados de la etiqueta de Google
Puedes usar el parámetro de remarketing integrado url__ para segmentar tus anuncios para una lista de usuarios.
en función de las URLs que las personas visitaron en tu sitio web, como se demuestra en
los visitantes de su sitio web
ejemplo.
Parámetros personalizados de la etiqueta de Google
Puedes agregar una etiqueta de Google personalizada parámetros a tu etiqueta de Google para crear listas de usuarios más personalizadas.
Antes de crear sus propios parámetros personalizados, consulte la lista parámetros predefinidos para ver si ya hay una buena opción para tu caso de uso. Uso de parámetros predefinidos , lo que facilita la integración con otras funciones de remarketing de Google Ads.
Crea la lista de usuarios
Esta sección contiene dos ejemplos de listas de usuarios: los visitantes de una página que la visitaron otra página y los visitantes de una página que no visitaron otra página.
Visitantes de una página que visitaron otra página
Puede orientar los anuncios a las personas que visitaron más de una página mediante un
flexible_rule_user_list
Primero, crea dos reglas. Luego, combina las reglas con inclusive_operands.
en la flexible_rule_user_list
con un operador AND
Ejemplo de código para crear una lista de usuarios de reglas flexible
Java
private void runExample(GoogleAdsClient googleAdsClient, long customerId) {
// Creates a UserListRuleInfo object containing the first rule.
UserListRuleInfo userVisitedSite1Rule =
createUserListRuleInfoFromUrl("http://example.com/example1");
// Creates a UserListRuleInfo object containing the second rule.
UserListRuleInfo userVisitedSite2Rule =
createUserListRuleInfoFromUrl("http://example.com/example2");
// Creates a UserListRuleInfo object containing the third rule.
UserListRuleInfo userVisitedSite3Rule =
createUserListRuleInfoFromUrl("http://example.com/example3");
// Create the user list "Visitors of page 1 AND page 2, but not page 3". To create the user list
// "Visitors of page 1 *OR* page 2, but not page 3", change the UserListFlexibleRuleOperator
// from AND to OR.
FlexibleRuleUserListInfo flexibleRuleUserListInfo =
FlexibleRuleUserListInfo.newBuilder()
.setInclusiveRuleOperator(UserListFlexibleRuleOperator.AND)
// Inclusive operands are joined together with the specified inclusiveRuleOperator. This
// represents the set of users that should be included in the user list.
.addInclusiveOperands(
FlexibleRuleOperandInfo.newBuilder()
.setRule(userVisitedSite1Rule)
// Optional: adds a lookback window for this rule, in days.
.setLookbackWindowDays(7L))
.addInclusiveOperands(
FlexibleRuleOperandInfo.newBuilder()
.setRule(userVisitedSite2Rule)
// Optional: adds a lookback window for this rule, in days.
.setLookbackWindowDays(7L))
.addExclusiveOperands(
// Exclusive operands are joined together with OR. This represents the set of users
// to be excluded from the user list.
FlexibleRuleOperandInfo.newBuilder().setRule(userVisitedSite3Rule))
.build();
// Defines a representation of a user list that is generated by a rule.
RuleBasedUserListInfo ruleBasedUserListInfo =
RuleBasedUserListInfo.newBuilder()
// Optional: To include past users in the user list, set the prepopulation_status to
// REQUESTED.
.setPrepopulationStatus(UserListPrepopulationStatus.REQUESTED)
.setFlexibleRuleUserList(flexibleRuleUserListInfo)
.build();
// Creates a user list.
UserList userList =
UserList.newBuilder()
.setName("Flexible rule user list for example.com #" + getPrintableDateTime())
.setDescription(
"Visitors of both http://example.com/example1 AND http://example.com/example2 but"
+ " NOT http://example.com/example3")
.setMembershipStatus(UserListMembershipStatus.OPEN)
.setRuleBasedUserList(ruleBasedUserListInfo)
.build();
// Creates the operation.
UserListOperation operation = UserListOperation.newBuilder().setCreate(userList).build();
// Creates the user list service client.
try (UserListServiceClient userListServiceClient =
googleAdsClient.getLatestVersion().createUserListServiceClient()) {
// Adds the user list.
MutateUserListsResponse response =
userListServiceClient.mutateUserLists(
Long.toString(customerId), ImmutableList.of(operation));
String userListResourceName = response.getResults(0).getResourceName();
// Prints the result.
System.out.printf("Created user list with resource name '%s'.%n", userListResourceName);
}
}
/**
* Creates a UserListRuleInfo object containing a rule targeting any user that visited the
* provided URL.
*/
private UserListRuleInfo createUserListRuleInfoFromUrl(String urlString) {
// Creates a rule targeting any user that visited a URL that equals the given urlString.
UserListRuleItemInfo userVisitedSiteRule =
UserListRuleItemInfo.newBuilder()
// Uses a built-in parameter to create a domain URL rule.
.setName(URL_STRING)
.setStringRuleItem(
UserListStringRuleItemInfo.newBuilder()
.setOperator(UserListStringRuleItemOperator.EQUALS)
.setValue(urlString))
.build();
// Returns a UserListRuleInfo object containing the rule.
return UserListRuleInfo.newBuilder()
.addRuleItemGroups(UserListRuleItemGroupInfo.newBuilder().addRuleItems(userVisitedSiteRule))
.build();
}
C#
public void Run(GoogleAdsClient client, long customerId)
{
// Creates a UserListRuleInfo object containing the first rule.
UserListRuleInfo userVisitedSite1Rule =
CreateUserListRuleInfoFromUrl("http://example.com/example1");
// Creates a UserListRuleInfo object containing the second rule.
UserListRuleInfo userVisitedSite2Rule =
CreateUserListRuleInfoFromUrl("http://example.com/example2");
// Creates a UserListRuleInfo object containing the third rule.
UserListRuleInfo userVisitedSite3Rule =
CreateUserListRuleInfoFromUrl("http://example.com/example3");
// Create the user list "Visitors of page 1 AND page 2, but not page 3". To create the
// user list "Visitors of page 1 *OR* page 2, but not page 3", change the
// UserListFlexibleRuleOperator from And to Or.
FlexibleRuleUserListInfo flexibleRuleUserListInfo = new FlexibleRuleUserListInfo
{
InclusiveRuleOperator = UserListFlexibleRuleOperator.And
};
// Inclusive operands are joined together with the specified inclusiveRuleOperator. This
// represents the set of users that should be included in the user list.
flexibleRuleUserListInfo.InclusiveOperands.Add(new FlexibleRuleOperandInfo
{
Rule = userVisitedSite1Rule,
// Optional: adds a lookback window for this rule, in days.
LookbackWindowDays = 7
});
flexibleRuleUserListInfo.InclusiveOperands.Add(new FlexibleRuleOperandInfo
{
Rule = userVisitedSite2Rule,
// Optional: adds a lookback window for this rule, in days.
LookbackWindowDays = 7
});
// Exclusive operands are joined together with OR. This represents the set of users
// to be excluded from the user list.
flexibleRuleUserListInfo.InclusiveOperands.Add(new FlexibleRuleOperandInfo
{
Rule = userVisitedSite3Rule
});
// Defines a representation of a user list that is generated by a rule.
RuleBasedUserListInfo ruleBasedUserListInfo = new RuleBasedUserListInfo
{
// Optional: To include past users in the user list, set the prepopulation_status to
// REQUESTED.
PrepopulationStatus = UserListPrepopulationStatus.Requested,
FlexibleRuleUserList = flexibleRuleUserListInfo
};
// Creates a user list.
UserList userList = new UserList
{
Name = $"Flexible rule user list example.com #{ExampleUtilities.GetRandomString()}",
Description = "Visitors of both https://example.com/example1 AND " +
"https://example.com/example2 but NOT https://example.com/example3",
MembershipStatus = UserListMembershipStatus.Open,
RuleBasedUserList = ruleBasedUserListInfo
};
// Creates the operation.
UserListOperation operation = new UserListOperation
{
Create = userList
};
try
{
UserListServiceClient userListServiceClient =
client.GetService(Services.V17.UserListService);
MutateUserListsResponse response =
userListServiceClient.MutateUserLists(customerId.ToString(),
new[] { operation });
string userListResourceName = response.Results[0].ResourceName;
Console.WriteLine($"Created user list with resource name '{userListResourceName}'.");
}
catch (GoogleAdsException e)
{
Console.WriteLine("Failure:");
Console.WriteLine($"Message: {e.Message}");
Console.WriteLine($"Failure: {e.Failure}");
Console.WriteLine($"Request ID: {e.RequestId}");
throw;
}
}
/// <summary>
/// Creates a UserListRuleInfo object containing a rule targeting any user that visited the
/// provided URL.
/// </summary>
private UserListRuleInfo CreateUserListRuleInfoFromUrl(string urlString)
{
// Creates a rule targeting any user that visited a URL that equals the given urlString.
UserListRuleItemInfo userVisitedSiteRule = new UserListRuleItemInfo
{
Name = URL_STRING,
StringRuleItem = new UserListStringRuleItemInfo
{
Operator = UserListStringRuleItemOperator.Equals,
Value = urlString
}
};
// Returns a UserListRuleInfo object containing the rule.
UserListRuleInfo userListRuleInfo = new UserListRuleInfo();
UserListRuleItemGroupInfo userListRuleItemGroupInfo = new UserListRuleItemGroupInfo();
userListRuleItemGroupInfo.RuleItems.Add(userVisitedSiteRule);
userListRuleInfo.RuleItemGroups.Add(userListRuleItemGroupInfo);
return userListRuleInfo;
}
PHP
public static function runExample(
GoogleAdsClient $googleAdsClient,
int $customerId
) {
// Creates a rule targeting any user that visited a url that equals
// http://example.com/example1'.
$userVisitedSite1RuleInfo = self::createUserListRuleFromUrl('http://example.com/example1');
// Creates a rule targeting any user that visited a url that equals
// http://example.com/example2'.
$userVisitedSite2RuleInfo = self::createUserListRuleFromUrl('http://example.com/example2');
// Creates a rule targeting any user that visited a url that equals
// http://example.com/example3'.
$userVisitedSite3RuleInfo = self::createUserListRuleFromUrl('http://example.com/example3');
// Create the user list "Visitors of page 1 AND page 2, but not page 3".
// To create the user list "Visitors of page 1 *OR* page 2, but not page 3",
// change the UserListFlexibleRuleOperator from PBAND to OR.
$flexibleRuleUserListInfo = new FlexibleRuleUserListInfo([
'inclusive_rule_operator' => UserListFlexibleRuleOperator::PBAND,
'inclusive_operands' => [
new FlexibleRuleOperandInfo([
'rule' => $userVisitedSite1RuleInfo,
// Optionally add a lookback window for this rule, in days.
'lookback_window_days' => 7
]),
new FlexibleRuleOperandInfo([
'rule' => $userVisitedSite2RuleInfo,
// Optionally add a lookback window for this rule, in days.
'lookback_window_days' => 7
])
],
// Exclusive operands are joined together with OR. This represents the set of users to
// be excluded from the user list.
'exclusive_operands' => [
new FlexibleRuleOperandInfo(['rule' => $userVisitedSite3RuleInfo])
]
]);
// Defines a representation of a user list that is generated by a rule.
$ruleBasedUserListInfo = new RuleBasedUserListInfo([
// Optional: To include past users in the user list, set the prepopulation_status to
// REQUESTED.
'prepopulation_status' => UserListPrepopulationStatus::REQUESTED,
'flexible_rule_user_list' => $flexibleRuleUserListInfo
]);
// Creates a user list.
$userList = new UserList([
'name' => 'All visitors to http://example.com/example1 AND ' .
'http://example.com/example2 but NOT http://example.com/example3 #'
. Helper::getPrintableDatetime(),
'description' => 'Visitors of both http://example.com/example1 AND ' .
'http://example.com/example2 but NOT http://example.com/example3',
'membership_status' => UserListMembershipStatus::OPEN,
'rule_based_user_list' => $ruleBasedUserListInfo
]);
// Creates the operation.
$operation = new UserListOperation();
$operation->setCreate($userList);
// Issues a mutate request to add the user list and prints some information.
$userListServiceClient = $googleAdsClient->getUserListServiceClient();
$response = $userListServiceClient->mutateUserLists(
MutateUserListsRequest::build($customerId, [$operation])
);
printf(
"Created user list with resource name '%s'.%s",
$response->getResults()[0]->getResourceName(),
PHP_EOL
);
}
Python
def main(client, customer_id):
"""Creates a rule-based user list.
The list will be defined by a combination of rules for users who have
visited two different pages of a website.
Args:
client: The Google Ads client.
customer_id: The customer ID for which to add the user list.
"""
# Create a UserListRuleInfo object containing the first rule.
user_visited_site1_rule_info = create_user_list_rule_info_from_url(
client, "http://example.com/example1"
)
# Create a UserListRuleInfo object containing the second rule.
user_visited_site2_rule_info = create_user_list_rule_info_from_url(
client, "http://example.com/example2"
)
# Create a UserListRuleInfo object containing the third rule.
user_visited_site3_rule_info = create_user_list_rule_info_from_url(
client, "http://example.com/example3"
)
# Create the user list "Visitors of page 1 AND page 2, but not page 3".
# To create the user list "Visitors of page 1 *OR* page 2, but not page 3",
# change the UserListFlexibleRuleOperator from AND to OR.
flexible_rule_user_list_info = client.get_type("FlexibleRuleUserListInfo")
flexible_rule_user_list_info.inclusive_rule_operator = (
client.enums.UserListFlexibleRuleOperatorEnum.AND
)
# Inclusive operands are joined together with the specified
# inclusive_rule_operator. This represents the set of users that should be
# included in the user list.
operand_1 = client.get_type("FlexibleRuleOperandInfo")
operand_1.rule = user_visited_site1_rule_info
# Optionally add a lookback window for this rule, in days.
operand_1.lookback_window_days = 7
flexible_rule_user_list_info.inclusive_operands.append(operand_1)
operand_2 = client.get_type("FlexibleRuleOperandInfo")
operand_2.rule = user_visited_site2_rule_info
# Optionally add a lookback window for this rule, in days.
operand_2.lookback_window_days = 7
flexible_rule_user_list_info.inclusive_operands.append(operand_2)
# Exclusive operands are joined together with OR.
# This represents the set of users to be excluded from the user list.
operand_3 = client.get_type("FlexibleRuleOperandInfo")
operand_3.rule = user_visited_site3_rule_info
flexible_rule_user_list_info.exclusive_operands.append(operand_3)
# Define a representation of a user list that is generated by a rule.
rule_based_user_list_info = client.get_type("RuleBasedUserListInfo")
# Optional: To include past users in the user list, set the
# prepopulation_status to REQUESTED.
rule_based_user_list_info.prepopulation_status = (
client.enums.UserListPrepopulationStatusEnum.REQUESTED
)
rule_based_user_list_info.flexible_rule_user_list = (
flexible_rule_user_list_info
)
# Create a user list.
user_list_operation = client.get_type("UserListOperation")
user_list = user_list_operation.create
user_list.name = (
"All visitors to http://example.com/example1 AND "
"http://example.com/example2 but NOT "
f"http://example.com/example3 #{uuid4()}"
)
user_list.description = (
"Visitors of both http://example.com/example1 AND "
"http://example.com/example2 but NOT"
"http://example.com/example3"
)
user_list.membership_status = client.enums.UserListMembershipStatusEnum.OPEN
user_list.rule_based_user_list = rule_based_user_list_info
# Issue a mutate request to add the user list, then print the results.
user_list_service = client.get_service("UserListService")
response = user_list_service.mutate_user_lists(
customer_id=customer_id, operations=[user_list_operation]
)
print(
"Created user list with resource name: "
f"'{response.results[0].resource_name}.'"
)
Rita
def add_combined_rule_user_list(customer_id)
# GoogleAdsClient will read a config file from
# ENV['HOME']/google_ads_config.rb when called without parameters
client = Google::Ads::GoogleAds::GoogleAdsClient.new
user_visited_site1_rule_info = create_user_list_rule_info_from_url(
client,
'http://example.com/example1',
)
user_visited_site2_rule_info = create_user_list_rule_info_from_url(
client,
'http://example.com/example2',
)
user_visited_site3_rule_info = create_user_list_rule_info_from_url(
client,
'http://example.com/example3',
)
# Creates a user list.
operation = client.operation.create_resource.user_list do |u|
u.name = "Flexible rule user list for example.com ##{(Time.new.to_f * 1000).to_i}"
u.description = "Visitors of both http://example.com/example1 AND " \
"http://example.com/example2 but NOT http://example.com/example3"
u.membership_status = :OPEN
# Defines a representation of a user list that is generated by a rule.
u.rule_based_user_list = client.resource.rule_based_user_list_info do |r|
# Optional: To include past users in the user list, set the
# prepopulation_status to REQUESTED.
r.prepopulation_status = :REQUESTED
r.flexible_rule_user_list = client.resource.flexible_rule_user_list_info do |frul|
frul.inclusive_rule_operator = :AND
frul.inclusive_operands += [
client.resource.flexible_rule_operand_info do |froi|
froi.rule = user_visited_site1_rule_info
# Optionally add a lookback window for this rule, in days.
froi.lookback_window_days = 7
end,
client.resource.flexible_rule_operand_info do |froi|
froi.rule = user_visited_site2_rule_info
# Optionally add a lookback window for this rule, in days.
froi.lookback_window_days = 7
end,
]
frul.exclusive_operands << client.resource.flexible_rule_operand_info do |froi|
froi.rule = user_visited_site3_rule_info
end
end
end
end
# Issues a mutate request to add the user list and prints some information.
response = client.service.user_list.mutate_user_lists(
customer_id: customer_id,
operations: [operation],
)
puts "Created user list with resource name " \
"#{response.results.first.resource_name}"
end
Perl
sub add_combined_rule_user_list {
my ($api_client, $customer_id) = @_;
# Create a UserListRuleInfo object containing the first rule.
my $user_visited_site1_rule_info =
create_user_list_rule_info_from_url("http://example.com/example1");
# Create a UserListRuleInfo object containing the second rule.
my $user_visited_site2_rule_info =
create_user_list_rule_info_from_url("http://example.com/example2");
# Create a UserListRuleInfo object containing the third rule.
my $user_visited_site3_rule_info =
create_user_list_rule_info_from_url("http://example.com/example3");
# Create the user list "Visitors of page 1 AND page 2, but not page 3".
# To create the user list "Visitors of page 1 *OR* page 2, but not page 3",
# change the UserListFlexibleRuleOperator from AND to OR.
my $flexible_rule_user_list_info =
Google::Ads::GoogleAds::V17::Common::FlexibleRuleUserListInfo->new({
inclusiveRuleOperator => AND,
# Inclusive operands are joined together with the specified inclusiveRuleOperator.
# This represents the set of users that should be included in the user list.
inclusiveOperands => [
Google::Ads::GoogleAds::V17::Common::FlexibleRuleOperandInfo->new({
rule => $user_visited_site1_rule_info,
# Optionally add a lookback window for this rule, in days.
lookbackWindowDays => 7
}
),
Google::Ads::GoogleAds::V17::Common::FlexibleRuleOperandInfo->new({
rule => $user_visited_site2_rule_info,
# Optionally add a lookback window for this rule, in days.
lookbackWindowDays => 7
})
],
# Exclusive operands are joined together with OR.
# This represents the set of users to be excluded from the user list.
exclusiveOperands => [
Google::Ads::GoogleAds::V17::Common::FlexibleRuleOperandInfo->new({
rule => $user_visited_site3_rule_info
})
],
});
# Define a representation of a user list that is generated by a rule.
my $rule_based_user_list_info =
Google::Ads::GoogleAds::V17::Common::RuleBasedUserListInfo->new({
# Optional: To include past users in the user list, set the prepopulationStatus
# to REQUESTED.
prepopulationStatus => REQUESTED,
flexibleRuleUserList => $flexible_rule_user_list_info
});
# Create a user list.
my $user_list = Google::Ads::GoogleAds::V17::Resources::UserList->new({
name => "Flexible rule user list for example.com #" . uniqid(),
description => "Visitors of both http://example.com/example1 AND " .
"http://example.com/example2 but NOT http://example.com/example3",
membershipStatus => OPEN,
ruleBasedUserList => $rule_based_user_list_info
});
# Create the operation.
my $user_list_operation =
Google::Ads::GoogleAds::V17::Services::UserListService::UserListOperation->
new({
create => $user_list
});
# Issue a mutate request to add the user list and print some information.
my $user_lists_response = $api_client->UserListService()->mutate({
customerId => $customer_id,
operations => [$user_list_operation]});
printf "Created user list with resource name '%s'.\n",
$user_lists_response->{results}[0]{resourceName};
return 1;
}
Visitantes de una página que no visitaron otra página
Puede orientar los anuncios a las personas que visitaron una página, pero no otra, mediante
flexible_rule_user_list
Los visitantes que visitaron una página se encuentran en el
inclusive_operands:
mientras que los visitantes que no visitaron otra página estarían en la
exclusive_operands
Combina las dos listas con un AND en el
inclusive_rule_operator
Cómo recuperar la lista
Para recuperar tu lista de usuarios, puedes emitir la siguiente consulta del lenguaje de consulta de Google Ads al
Recurso user_list.
SELECT
user_list.name,
user_list.membership_status,
user_list.membership_life_span
FROM user_list
WHERE
user_list.resource_name = 'USER_LIST_RESOURCE_NAME'
Orientar la lista
Una vez que hayas creado tu segmento de público, el siguiente paso es establecer que la modifica.
Reglas de segmentación por segmento de público
Las listas de usuarios positivos (aptos para oferta) no se pueden configurar a nivel de la campaña, y las del grupo de anuncios al mismo tiempo. Se deben quitar los criterios positivos de la lista de usuarios de todos los grupos de anuncios de una campaña antes de poder configurar uno para ella.
La segmentación positiva por lista de usuarios solo se admite en las campañas de Búsqueda. Para Campañas de Display,
CampaignCriterionque estableceuser_listdebe excluidos.En las campañas de Búsqueda y Shopping, los objetivos de la lista de usuarios no admiten la configuración los siguientes campos:
Oriente los anuncios a su lista de usuarios
El proceso es similar a otros tipos de criterios de segmentación en la API. El
El siguiente código muestra cómo puedes usar un AdGroupCriterion para segmentar anuncios de un grupo de anuncios a una lista de usuarios:
Java
private String targetAdsInAdGroupToUserList(
GoogleAdsClient googleAdsClient, long customerId, long adGroupId, String userList) {
// Creates the ad group criterion targeting members of the user list.
AdGroupCriterion adGroupCriterion =
AdGroupCriterion.newBuilder()
.setAdGroup(ResourceNames.adGroup(customerId, adGroupId))
.setUserList(UserListInfo.newBuilder().setUserList(userList).build())
.build();
// Creates the operation.
AdGroupCriterionOperation operation =
AdGroupCriterionOperation.newBuilder().setCreate(adGroupCriterion).build();
// Creates the ad group criterion service.
try (AdGroupCriterionServiceClient adGroupCriterionServiceClient =
googleAdsClient.getLatestVersion().createAdGroupCriterionServiceClient()) {
// Adds the ad group criterion.
MutateAdGroupCriteriaResponse response =
adGroupCriterionServiceClient.mutateAdGroupCriteria(
Long.toString(customerId), ImmutableList.of(operation));
// Gets and prints the results.
String adGroupCriterionResourceName = response.getResults(0).getResourceName();
System.out.printf(
"Successfully created ad group criterion with resource name '%s' "
+ "targeting user list with resource name '%s' with ad group with ID %d.%n",
adGroupCriterionResourceName, userList, adGroupId);
return adGroupCriterionResourceName;
}
}
C#
private string TargetAdsInAdGroupToUserList(
GoogleAdsClient client, long customerId, long adGroupId, string userListResourceName)
{
// Get the AdGroupCriterionService client.
AdGroupCriterionServiceClient adGroupCriterionServiceClient = client.GetService
(Services.V17.AdGroupCriterionService);
// Create the ad group criterion targeting members of the user list.
AdGroupCriterion adGroupCriterion = new AdGroupCriterion
{
AdGroup = ResourceNames.AdGroup(customerId, adGroupId),
UserList = new UserListInfo
{
UserList = userListResourceName
}
};
// Create the operation.
AdGroupCriterionOperation adGroupCriterionOperation = new AdGroupCriterionOperation
{
Create = adGroupCriterion
};
// Add the ad group criterion, then print and return the new criterion's resource name.
MutateAdGroupCriteriaResponse mutateAdGroupCriteriaResponse =
adGroupCriterionServiceClient.MutateAdGroupCriteria(customerId.ToString(),
new[] { adGroupCriterionOperation });
string adGroupCriterionResourceName =
mutateAdGroupCriteriaResponse.Results.First().ResourceName;
Console.WriteLine("Successfully created ad group criterion with resource name " +
$"'{adGroupCriterionResourceName}' targeting user list with resource name " +
$"'{userListResourceName}' with ad group with ID {adGroupId}.");
return adGroupCriterionResourceName;
}
PHP
private static function targetAdsInAdGroupToUserList(
GoogleAdsClient $googleAdsClient,
int $customerId,
int $adGroupId,
string $userListResourceName
): string {
// Creates the ad group criterion targeting members of the user list.
$adGroupCriterion = new AdGroupCriterion([
'ad_group' => ResourceNames::forAdGroup($customerId, $adGroupId),
'user_list' => new UserListInfo(['user_list' => $userListResourceName])
]);
// Creates the operation.
$operation = new AdGroupCriterionOperation();
$operation->setCreate($adGroupCriterion);
// Issues a mutate request to add an ad group criterion.
$adGroupCriterionServiceClient = $googleAdsClient->getAdGroupCriterionServiceClient();
/** @var MutateAdGroupCriteriaResponse $adGroupCriterionResponse */
$adGroupCriterionResponse = $adGroupCriterionServiceClient->mutateAdGroupCriteria(
MutateAdGroupCriteriaRequest::build($customerId, [$operation])
);
$adGroupCriterionResourceName =
$adGroupCriterionResponse->getResults()[0]->getResourceName();
printf(
"Successfully created ad group criterion with resource name '%s' " .
"targeting user list with resource name '%s' with ad group with ID %d.%s",
$adGroupCriterionResourceName,
$userListResourceName,
$adGroupId,
PHP_EOL
);
return $adGroupCriterionResourceName;
}
Python
def target_ads_in_ad_group_to_user_list(
client, customer_id, ad_group_id, user_list_resource_name
):
"""Creates an ad group criterion that targets a user list with an ad group.
Args:
client: an initialized GoogleAdsClient instance.
customer_id: a str client customer ID used to create an ad group
criterion.
ad_group_id: a str ID for an ad group used to create an ad group
criterion that targets members of a user list.
user_list_resource_name: a str resource name for a user list.
Returns:
a str resource name for an ad group criterion.
"""
ad_group_criterion_operation = client.get_type("AdGroupCriterionOperation")
# Creates the ad group criterion targeting members of the user list.
ad_group_criterion = ad_group_criterion_operation.create
ad_group_criterion.ad_group = client.get_service(
"AdGroupService"
).ad_group_path(customer_id, ad_group_id)
ad_group_criterion.user_list.user_list = user_list_resource_name
ad_group_criterion_service = client.get_service("AdGroupCriterionService")
response = ad_group_criterion_service.mutate_ad_group_criteria(
customer_id=customer_id, operations=[ad_group_criterion_operation]
)
resource_name = response.results[0].resource_name
print(
"Successfully created ad group criterion with resource name: "
f"'{resource_name}' targeting user list with resource name: "
f"'{user_list_resource_name}' and with ad group with ID "
f"{ad_group_id}."
)
return resource_name
Rita
def target_ads_in_ad_group_to_user_list(
client,
customer_id,
ad_group_id,
user_list
)
# Creates the ad group criterion targeting members of the user list.
operation = client.operation.create_resource.ad_group_criterion do |agc|
agc.ad_group = client.path.ad_group(customer_id, ad_group_id)
agc.user_list = client.resource.user_list_info do |info|
info.user_list = user_list
end
end
# Issues a mutate request to create the ad group criterion.
response = client.service.ad_group_criterion.mutate_ad_group_criteria(
customer_id: customer_id,
operations: [operation],
)
ad_group_criterion_resource_name = response.results.first.resource_name
puts "Successfully created ad group criterion with resource name " \
"'#{ad_group_criterion_resource_name}' targeting user list with resource name " \
"'#{user_list}' with ad group with ID #{ad_group_id}"
ad_group_criterion_resource_name
end
Perl
sub target_ads_in_ad_group_to_user_list {
my ($api_client, $customer_id, $ad_group_id, $user_list_resource_name) = @_;
# Create the ad group criterion targeting members of the user list.
my $ad_group_criterion =
Google::Ads::GoogleAds::V17::Resources::AdGroupCriterion->new({
adGroup => Google::Ads::GoogleAds::V17::Utils::ResourceNames::ad_group(
$customer_id, $ad_group_id
),
userList => Google::Ads::GoogleAds::V17::Common::UserListInfo->new({
userList => $user_list_resource_name
})});
# Create the operation.
my $ad_group_criterion_operation =
Google::Ads::GoogleAds::V17::Services::AdGroupCriterionService::AdGroupCriterionOperation
->new({
create => $ad_group_criterion
});
# Add the ad group criterion, then print and return the new criterion's resource name.
my $ad_group_criteria_response =
$api_client->AdGroupCriterionService()->mutate({
customerId => $customer_id,
operations => [$ad_group_criterion_operation]});
my $ad_group_criterion_resource_name =
$ad_group_criteria_response->{results}[0]{resourceName};
printf "Successfully created ad group criterion with resource name '%s' " .
"targeting user list with resource name '%s' with ad group with ID %d.\n",
$ad_group_criterion_resource_name, $user_list_resource_name, $ad_group_id;
return $ad_group_criterion_resource_name;
}
Al igual que con otros tipos de criterios, puedes asignar otras propiedades al
AdGroupCriterion, como anulaciones de oferta.
Cambiar niveles de segmentación
Si cambia de criterios de la lista de usuarios a nivel del grupo de anuncios a nivel de la campaña primero debes quitar los criterios existentes de la lista de usuarios de cada grupo de anuncios detenido en esa campaña. Haz clic en los elementos expandibles para ver código de ejemplo para cada paso.
Primero, recupere todos los criterios de AdGroupCriteria de una campaña determinada.
Java
private List<String> getUserListAdGroupCriterion(
GoogleAdsClient googleAdsClient, long customerId, long campaignId) {
List<String> userListCriteria = new ArrayList<>();
// Creates the Google Ads service client.
try (GoogleAdsServiceClient googleAdsServiceClient =
googleAdsClient.getLatestVersion().createGoogleAdsServiceClient()) {
// Creates a request that will retrieve all of the ad group criteria under a campaign.
SearchGoogleAdsRequest request =
SearchGoogleAdsRequest.newBuilder()
.setCustomerId(Long.toString(customerId))
.setQuery(
"SELECT ad_group_criterion.criterion_id"
+ " FROM ad_group_criterion"
+ " WHERE campaign.id = "
+ campaignId
+ " AND ad_group_criterion.type = 'USER_LIST'")
.build();
// Issues the search request.
SearchPagedResponse searchPagedResponse = googleAdsServiceClient.search(request);
// Iterates over all rows in all pages. Prints the results and adds the ad group criteria
// resource names to the list.
for (GoogleAdsRow googleAdsRow : searchPagedResponse.iterateAll()) {
String adGroupCriterionResourceName = googleAdsRow.getAdGroupCriterion().getResourceName();
System.out.printf(
"Ad group criterion with resource name '%s' was found.%n",
adGroupCriterionResourceName);
userListCriteria.add(adGroupCriterionResourceName);
}
}
return userListCriteria;
}
C#
private List<string> GetUserListAdGroupCriteria(
GoogleAdsClient client, long customerId, long campaignId)
{
// Get the GoogleAdsService client.
GoogleAdsServiceClient googleAdsServiceClient =
client.GetService(Services.V17.GoogleAdsService);
List<string> userListCriteriaResourceNames = new List<string>();
// Create a query that will retrieve all of the ad group criteria under a campaign.
string query = $@"
SELECT ad_group_criterion.criterion_id
FROM ad_group_criterion
WHERE
campaign.id = {campaignId}
AND ad_group_criterion.type = 'USER_LIST'";
// Issue the search request.
googleAdsServiceClient.SearchStream(customerId.ToString(), query,
delegate (SearchGoogleAdsStreamResponse resp)
{
// Display the results and add the resource names to the list.
foreach (GoogleAdsRow googleAdsRow in resp.Results)
{
string adGroupCriterionResourceName =
googleAdsRow.AdGroupCriterion.ResourceName;
Console.WriteLine("Ad group criterion with resource name " +
$"{adGroupCriterionResourceName} was found.");
userListCriteriaResourceNames.Add(adGroupCriterionResourceName);
}
});
return userListCriteriaResourceNames;
}
PHP
private static function getUserListAdGroupCriteria(
GoogleAdsClient $googleAdsClient,
int $customerId,
int $campaignId
): array {
// Creates a query that retrieves all of the ad group criteria under a campaign.
$query = sprintf(
"SELECT ad_group_criterion.criterion_id " .
"FROM ad_group_criterion " .
"WHERE campaign.id = %d " .
"AND ad_group_criterion.type = 'USER_LIST'",
$campaignId
);
// Creates the Google Ads service client.
$googleAdsServiceClient = $googleAdsClient->getGoogleAdsServiceClient();
// Issues the search request.
$response =
$googleAdsServiceClient->search(SearchGoogleAdsRequest::build($customerId, $query));
$userListCriteria = [];
// Iterates over all rows in all pages. Prints the user list criteria and adds the ad group
// criteria resource names to the list.
foreach ($response->iterateAllElements() as $googleAdsRow) {
/** @var GoogleAdsRow $googleAdsRow */
$adGroupCriterionResourceName = $googleAdsRow->getAdGroupCriterion()->getResourceName();
printf(
"Ad group criterion with resource name '%s' was found.%s",
$adGroupCriterionResourceName,
PHP_EOL
);
$userListCriteria[] = $adGroupCriterionResourceName;
}
return $userListCriteria;
}
Python
def get_user_list_ad_group_criteria(client, customer_id, campaign_id):
"""Finds all of user list ad group criteria under a campaign.
Args:
client: an initialized GoogleAdsClient instance.
customer_id: a str client customer ID.
campaign_id: a str campaign ID.
Returns:
a list of ad group criterion resource names.
"""
# Creates a query that retrieves all of the ad group criteria under a
# campaign.
query = f"""
SELECT
ad_group_criterion.criterion_id
FROM ad_group_criterion
WHERE campaign.id = {campaign_id}
AND ad_group_criterion.type = USER_LIST"""
googleads_service = client.get_service("GoogleAdsService")
search_request = client.get_type("SearchGoogleAdsRequest")
search_request.customer_id = customer_id
search_request.query = query
response = googleads_service.search(request=search_request)
# Iterates over all rows in all pages. Prints the user list criteria and
# adds the ad group criteria resource names to the list.
user_list_criteria = []
for row in response:
resource_name = row.ad_group_criterion.resource_name
print(
"Ad group criterion with resource name '{resource_name}' was "
"found."
)
user_list_criteria.append(resource_name)
return user_list_criteria
Rita
def get_user_list_ad_group_criterion(
client,
customer_id,
campaign_id
)
user_list_criteria = []
# Creates a query that will retrieve all of the ad group criteria
# under a campaign.
query = <<~QUERY
SELECT ad_group_criterion.criterion_id
FROM ad_group_criterion
WHERE campaign.id = #{campaign_id}
AND ad_group_criterion.type = 'USER_LIST'
QUERY
# Issues the search request.
response = client.service.google_ads.search(
customer_id: customer_id,
query: query,
page_size: PAGE_SIZE,
)
# Iterates over all rows in all pages. Prints the results and adds the ad
# group criteria resource names to the list.
response.each do |row|
ad_group_criterion_resource_name = row.ad_group_criterion.resource_name
puts "Ad group criterion with resource name " \
"'#{ad_group_criterion_resource_name}' was found"
user_list_criteria << ad_group_criterion_resource_name
end
user_list_criteria
end
Perl
sub get_user_list_ad_group_criteria {
my ($api_client, $customer_id, $campaign_id) = @_;
my $user_list_criterion_resource_names = [];
# Create a search stream request that will retrieve all of the user list ad
# group criteria under a campaign.
my $search_stream_request =
Google::Ads::GoogleAds::V17::Services::GoogleAdsService::SearchGoogleAdsStreamRequest
->new({
customerId => $customer_id,
query => sprintf(
"SELECT ad_group_criterion.criterion_id " .
"FROM ad_group_criterion " .
"WHERE campaign.id = %d AND ad_group_criterion.type = 'USER_LIST'",
$campaign_id
)});
my $search_stream_handler =
Google::Ads::GoogleAds::Utils::SearchStreamHandler->new({
service => $api_client->GoogleAdsService(),
request => $search_stream_request
});
# Issue a search request and process the stream response.
$search_stream_handler->process_contents(
sub {
# Display the results and add the resource names to the list.
my $google_ads_row = shift;
my $ad_group_criterion_resource_name =
$google_ads_row->{adGroupCriterion}{resourceName};
printf "Ad group criterion with resource name '%s' was found.\n",
$ad_group_criterion_resource_name;
push(@$user_list_criterion_resource_names,
$ad_group_criterion_resource_name);
});
return $user_list_criterion_resource_names;
}
Luego, quita todas las segmentaciones de criterios del grupo de anuncios que se mostraron.
Java
private void removeExistingListCriteriaFromAdGroup(
GoogleAdsClient googleAdsClient, long customerId, long campaignId) {
// Retrieves all of the ad group criteria under a campaign.
List<String> adGroupCriteria =
getUserListAdGroupCriterion(googleAdsClient, customerId, campaignId);
List<AdGroupCriterionOperation> operations = new ArrayList<>();
// Creates a list of remove operations.
for (String adGroupCriterion : adGroupCriteria) {
operations.add(AdGroupCriterionOperation.newBuilder().setRemove(adGroupCriterion).build());
}
// Creates the ad group criterion service.
try (AdGroupCriterionServiceClient adGroupCriterionServiceClient =
googleAdsClient.getLatestVersion().createAdGroupCriterionServiceClient()) {
// Removes the ad group criterion.
MutateAdGroupCriteriaResponse response =
adGroupCriterionServiceClient.mutateAdGroupCriteria(
Long.toString(customerId), operations);
// Gets and prints the results.
System.out.printf("Removed %d ad group criteria.%n", response.getResultsCount());
for (MutateAdGroupCriterionResult result : response.getResultsList()) {
System.out.printf(
"Successfully removed ad group criterion with resource name '%s'.%n",
result.getResourceName());
}
}
}
C#
private void RemoveExistingListCriteriaFromAdGroup(GoogleAdsClient client, long customerId,
long campaignId)
{
// Get the AdGroupCriterionService client.
AdGroupCriterionServiceClient adGroupCriterionServiceClient =
client.GetService(Services.V17.AdGroupCriterionService);
// Retrieve all of the ad group criteria under a campaign.
List<string> adGroupCriteria =
GetUserListAdGroupCriteria(client, customerId, campaignId);
// Create a list of remove operations.
List<AdGroupCriterionOperation> operations = adGroupCriteria.Select(adGroupCriterion =>
new AdGroupCriterionOperation { Remove = adGroupCriterion }).ToList();
// Remove the ad group criteria and print the resource names of the removed criteria.
MutateAdGroupCriteriaResponse mutateAdGroupCriteriaResponse =
adGroupCriterionServiceClient.MutateAdGroupCriteria(customerId.ToString(),
operations);
Console.WriteLine($"Removed {mutateAdGroupCriteriaResponse.Results.Count} ad group " +
"criteria.");
foreach (MutateAdGroupCriterionResult result in mutateAdGroupCriteriaResponse.Results)
{
Console.WriteLine("Successfully removed ad group criterion with resource name " +
$"'{result.ResourceName}'.");
}
}
PHP
private static function removeExistingListCriteriaFromAdGroup(
GoogleAdsClient $googleAdsClient,
int $customerId,
int $campaignId
) {
// Retrieves all of the ad group criteria under a campaign.
$allAdGroupCriteria = self::getUserListAdGroupCriteria(
$googleAdsClient,
$customerId,
$campaignId
);
$removeOperations = [];
// Creates a list of remove operations.
foreach ($allAdGroupCriteria as $adGroupCriterionResourceName) {
$operation = new AdGroupCriterionOperation();
$operation->setRemove($adGroupCriterionResourceName);
$removeOperations[] = $operation;
}
// Issues a mutate request to remove the ad group criteria.
$adGroupCriterionServiceClient = $googleAdsClient->getAdGroupCriterionServiceClient();
/** @var MutateAdGroupCriteriaResponse $adGroupCriteriaResponse */
$adGroupCriteriaResponse = $adGroupCriterionServiceClient->mutateAdGroupCriteria(
MutateAdGroupCriteriaRequest::build($customerId, $removeOperations)
);
foreach ($adGroupCriteriaResponse->getResults() as $adGroupCriteriaResult) {
printf(
"Successfully removed ad group criterion with resource name '%s'.%s",
$adGroupCriteriaResult->getResourceName(),
PHP_EOL
);
}
}
Python
def remove_existing_criteria_from_ad_group(client, customer_id, campaign_id):
"""Removes all ad group criteria targeting a user list under a campaign.
This is a necessary step before targeting a user list at the campaign level.
Args:
client: an initialized GoogleAdsClient instance.
customer_id: a str client customer ID.
campaign_id: a str ID for a campaign that will have all ad group
criteria that targets user lists removed.
"""
# Retrieves all of the ad group criteria under a campaign.
all_ad_group_criteria = get_user_list_ad_group_criteria(
client, customer_id, campaign_id
)
# Creates a list of remove operations.
remove_operations = []
for ad_group_criterion_resource_name in all_ad_group_criteria:
remove_operation = client.get_type("AdGroupCriterionOperation")
remove_operation.remove = ad_group_criterion_resource_name
remove_operations.append(remove_operation)
ad_group_criterion_service = client.get_service("AdGroupCriterionService")
response = ad_group_criterion_service.mutate_ad_group_criteria(
customer_id=customer_id, operations=remove_operations
)
print(
"Successfully removed ad group criterion with resource name: "
f"'{response.results[0].resource_name}'"
)
Rita
def remove_existing_list_criteria_from_ad_group(
client,
customer_id,
campaign_id
)
# Retrieves all of the ad group criteria under a campaign.
ad_group_criteria = get_user_list_ad_group_criterion(
client, customer_id, campaign_id)
# Creates a list of remove operations.
operations = []
ad_group_criteria.each do |agc|
operations << client.operation.remove_resource.ad_group_criterion(agc)
end
# Issues a mutate request to remove all ad group criteria.
response = client.service.ad_group_criterion.mutate_ad_group_criteria(
customer_id: customer_id,
operations: operations,
)
puts "Removed #{response.results.size} ad group criteria."
response.results.each do |result|
puts "Successfully removed ad group criterion with resource name " \
"'#{result.resource_name}'"
end
end
Perl
sub remove_existing_list_criteria_from_ad_group {
my ($api_client, $customer_id, $campaign_id) = @_;
# Retrieve all of the ad group criteria under a campaign.
my $ad_group_criteria =
get_user_list_ad_group_criteria($api_client, $customer_id, $campaign_id);
# Create a list of remove operations.
my $operations = [];
foreach my $ad_group_criterion (@$ad_group_criteria) {
push(
@$operations,
Google::Ads::GoogleAds::V17::Services::AdGroupCriterionService::AdGroupCriterionOperation
->new({
remove => $ad_group_criterion
}));
}
# Remove the ad group criteria and print the resource names of the removed criteria.
my $ad_group_criteria_response =
$api_client->AdGroupCriterionService()->mutate({
customerId => $customer_id,
operations => $operations
});
printf "Removed %d ad group criteria.\n",
scalar @{$ad_group_criteria_response->{results}};
foreach my $result (@{$ad_group_criteria_response->{results}}) {
printf "Successfully removed ad group criterion with resource name '%s'.\n",
$result->{resourceName};
}
}
Al realizar el cambio, también se deben quitar los criterios existentes de la lista de usuarios a nivel de la campaña a las listas de usuarios a nivel del grupo de anuncios. El proceso refleja el ejemplo anterior.
Segmentar los anuncios de una campaña para una lista de usuarios mediante un criterio de campaña
Java
private String targetAdsInCampaignToUserList(
GoogleAdsClient googleAdsClient, long customerId, long campaignId, String userList) {
// Creates the campaign criterion.
CampaignCriterion campaignCriterion =
CampaignCriterion.newBuilder()
.setCampaign(ResourceNames.campaign(customerId, campaignId))
.setUserList(UserListInfo.newBuilder().setUserList(userList).build())
.build();
// Creates the operation.
CampaignCriterionOperation operation =
CampaignCriterionOperation.newBuilder().setCreate(campaignCriterion).build();
// Creates the campaign criterion service client.
try (CampaignCriterionServiceClient campaignCriterionServiceClient =
googleAdsClient.getLatestVersion().createCampaignCriterionServiceClient()) {
// Adds the campaign criterion.
MutateCampaignCriteriaResponse response =
campaignCriterionServiceClient.mutateCampaignCriteria(
Long.toString(customerId), ImmutableList.of(operation));
// Gets and prints the campaign criterion resource name.
String campaignCriterionResourceName = response.getResults(0).getResourceName();
System.out.printf(
"Successfully created campaign criterion with resource name '%s' "
+ "targeting user list with resource name '%s' with campaign with ID %d.%n",
campaignCriterionResourceName, userList, campaignId);
return campaignCriterionResourceName;
}
}
C#
private string TargetAdsInCampaignToUserList(
GoogleAdsClient client, long customerId, long campaignId, string userListResourceName)
{
// Get the CampaignCriterionService client.
CampaignCriterionServiceClient campaignCriterionServiceClient =
client.GetService(Services.V17.CampaignCriterionService);
// Create the campaign criterion.
CampaignCriterion campaignCriterion = new CampaignCriterion
{
Campaign = ResourceNames.Campaign(customerId, campaignId),
UserList = new UserListInfo
{
UserList = userListResourceName
}
};
// Create the operation.
CampaignCriterionOperation campaignCriterionOperation = new CampaignCriterionOperation
{
Create = campaignCriterion
};
// Add the campaign criterion and print the resulting criterion's resource name.
MutateCampaignCriteriaResponse mutateCampaignCriteriaResponse =
campaignCriterionServiceClient.MutateCampaignCriteria(customerId.ToString(),
new[] { campaignCriterionOperation });
string campaignCriterionResourceName =
mutateCampaignCriteriaResponse.Results.First().ResourceName;
Console.WriteLine("Successfully created campaign criterion with resource name " +
$"'{campaignCriterionResourceName}' targeting user list with resource name " +
$"'{userListResourceName}' with campaign with ID {campaignId}.");
return campaignCriterionResourceName;
}
PHP
private static function targetAdsInCampaignToUserList(
GoogleAdsClient $googleAdsClient,
int $customerId,
int $campaignId,
string $userListResourceName
): string {
// Creates the campaign criterion.
$campaignCriterion = new CampaignCriterion([
'campaign' => ResourceNames::forCampaign($customerId, $campaignId),
'user_list' => new UserListInfo(['user_list' => $userListResourceName])
]);
// Creates the operation.
$operation = new CampaignCriterionOperation();
$operation->setCreate($campaignCriterion);
// Issues a mutate request to create a campaign criterion.
$campaignCriterionServiceClient = $googleAdsClient->getCampaignCriterionServiceClient();
/** @var MutateCampaignCriteriaResponse $campaignCriteriaResponse */
$campaignCriteriaResponse = $campaignCriterionServiceClient->mutateCampaignCriteria(
MutateCampaignCriteriaRequest::build($customerId, [$operation])
);
$campaignCriterionResourceName =
$campaignCriteriaResponse->getResults()[0]->getResourceName();
printf(
"Successfully created campaign criterion with resource name '%s' " .
"targeting user list with resource name '%s' with campaign with ID %d.%s",
$campaignCriterionResourceName,
$userListResourceName,
$campaignId,
PHP_EOL
);
return $campaignCriterionResourceName;
}
Python
def target_ads_in_campaign_to_user_list(
client, customer_id, campaign_id, user_list_resource_name
):
"""Creates a campaign criterion that targets a user list with a campaign.
Args:
client: an initialized GoogleAdsClient instance.
customer_id: a str client customer ID used to create an campaign
criterion.
campaign_id: a str ID for a campaign used to create a campaign
criterion that targets members of a user list.
user_list_resource_name: a str resource name for a user list.
Returns:
a str resource name for a campaign criterion.
"""
campaign_criterion_operation = client.get_type("CampaignCriterionOperation")
campaign_criterion = campaign_criterion_operation.create
campaign_criterion.campaign = client.get_service(
"CampaignService"
).campaign_path(customer_id, campaign_id)
campaign_criterion.user_list.user_list = user_list_resource_name
campaign_criterion_service = client.get_service("CampaignCriterionService")
response = campaign_criterion_service.mutate_campaign_criteria(
customer_id=customer_id, operations=[campaign_criterion_operation]
)
resource_name = response.results[0].resource_name
print(
"Successfully created campaign criterion with resource name "
f"'{resource_name}' targeting user list with resource name "
f"'{user_list_resource_name}' with campaign with ID {campaign_id}"
)
return resource_name
Rita
def target_ads_in_campaign_to_user_list(
client,
customer_id,
campaign_id,
user_list
)
# Creates the campaign criterion targeting members of the user list.
operation = client.operation.create_resource.campaign_criterion do |cc|
cc.campaign = client.path.campaign(customer_id, campaign_id)
cc.user_list = client.resource.user_list_info do |info|
info.user_list = user_list
end
end
# Issues a mutate request to create the campaign criterion.
response = client.service.campaign_criterion.mutate_campaign_criteria(
customer_id: customer_id,
operations: [operation],
)
campaign_criterion_resource_name = response.results.first.resource_name
puts "Successfully created campaign criterion with resource name " \
"'#{campaign_criterion_resource_name}' targeting user list with resource name " \
"'#{user_list}' with campaign with ID #{campaign_id}"
campaign_criterion_resource_name
end
Perl
sub target_ads_in_campaign_to_user_list {
my ($api_client, $customer_id, $campaign_id, $user_list_resource_name) = @_;
# Create the campaign criterion.
my $campaign_criterion =
Google::Ads::GoogleAds::V17::Resources::CampaignCriterion->new({
campaign => Google::Ads::GoogleAds::V17::Utils::ResourceNames::campaign(
$customer_id, $campaign_id
),
userList => Google::Ads::GoogleAds::V17::Common::UserListInfo->new({
userList => $user_list_resource_name
})});
# Create the operation.
my $campaign_criterion_operation =
Google::Ads::GoogleAds::V17::Services::CampaignCriterionService::CampaignCriterionOperation
->new({
create => $campaign_criterion
});
# Add the campaign criterion and print the resulting criterion's resource name.
my $campaign_criteria_response =
$api_client->CampaignCriterionService()->mutate({
customerId => $customer_id,
operations => [$campaign_criterion_operation]});
my $campaign_criterion_resource_name =
$campaign_criteria_response->{results}[0]{resourceName};
printf "Successfully created campaign criterion with resource name '%s' " .
"targeting user list with resource name '%s' with campaign with ID %d.\n",
$campaign_criterion_resource_name, $user_list_resource_name, $campaign_id;
return $campaign_criterion_resource_name;
}
Revisa el rendimiento de la lista
Para recopilar datos de rendimiento de sus segmentos de público, realice una búsqueda
solicitud a la ad_group_audience_view
o el recurso campaign_audience_view.
Por ejemplo, puedes observar conversions o cost_per_conversion para
determinar si orientar los anuncios
al segmento de público genera más
conversiones y, luego, ajuste los modificadores de ofertas según corresponda.
SELECT
ad_group_criterion.criterion_id,
metrics.conversions,
metrics.cost_per_conversion
FROM ad_group_audience_view