Visitatori che hanno eseguito azioni specifiche

Puoi compilare l'elenco del segmento di pubblico con gli utenti che hanno eseguito azioni specifiche sul tuo sito web. Se utilizzi il monitoraggio delle conversioni, puoi scegliere come target degli annunci gli utenti che in precedenza hanno attivato una conversione (ad es. un acquisto) sul tuo sito web.

Puoi anche scegliere come target gli utenti che hanno eseguito sul tuo sito web un'azione specifica che non consideri una conversione, ad esempio quando un utente aggiunge, ma poi elimina un articolo dal carrello degli acquisti senza effettuare un acquisto.

Prerequisiti

Per creare e scegliere come target segmenti di pubblico, devi innanzitutto:

1. Consulta le norme per la pubblicità basata sugli interessi e sulla località. Le informazioni sensibili sugli utenti non possono essere utilizzate per creare segmenti di pubblico.

2. Configura il tag Google.

   Gli inserzionisti che vogliono creare elenchi di utenti in base al comportamento nelle app mobile devono implementare l'SDK Firebase o utilizzare SDK di terze parti per monitorare il comportamento in-app.

1. Imposta il monitoraggio delle conversioni. Segui le istruzioni riportate nella Guida introduttiva alla gestione delle conversioni. Poi installa il tag Google sul tuo sito web.

Recuperare il tag Google

Tutti gli account Google Ads hanno esattamente un tag Google a livello di account, creato automaticamente quando l'account viene aperto.

Puoi recuperare il tag Google nell'interfaccia utente di Google Ads seguendo le istruzioni del Centro assistenza o nell'API Google Ads creando un RemarketingAction e poi recuperando il tag Google inviando una richiesta GoogleAdsService.searchStream utilizzando la risorsa remarketing_action:

SELECT
  remarketing_action.id,
  remarketing_action.name,
  remarketing_action.tag_snippets
FROM remarketing_action
WHERE remarketing_action.resource_name = 'REMARKETING_ACTION_RESOURCE_NAME'

Installare il tag Google sul sito web o nell'app

Il passaggio successivo consiste nell'installare il tag Google in tutte le pagine del sito. Scopri di più sull'aggiunta del tag Google al tuo sito o alla tua app mobile.

Se prevedi di creare segmenti di pubblico in base solo agli URL delle pagine visitate, non devi apportare modifiche al tag Google. Se utilizzi parametri personalizzati, devi modificare il tag per includerli, come descritto in Strategie avanzate per il tagging e la creazione di elenchi per il remarketing.

Puoi utilizzare Google Tag Assistant per convalidare l'installazione dei tag.

Parametri tag Google integrati

Puoi utilizzare il parametro di remarketing integrato url__ per scegliere come target un elenco di utenti basato sugli URL visitati dagli utenti sul tuo sito web, come mostrato nell'esempio relativo ai visitatori del tuo sito web.

Parametri tag Google personalizzati

Puoi aggiungere parametri personalizzati del tag Google al tag Google per creare elenchi di utenti più personalizzati.

Prima di creare i tuoi parametri personalizzati, consulta l'elenco dei parametri predefiniti per vedere se ne esiste già uno adatto al tuo caso d'uso. L'utilizzo di parametri predefiniti simplifica l'integrazione con altre funzionalità di remarketing di Google Ads.

Creare l'elenco di utenti

Per scegliere come target i visitatori che hanno eseguito azioni specifiche, devi impostare il campo basic_user_list di un UserList con un oggetto BasicUserListInfo contenente riferimento alle azioni, che si tratti di conversioni o azioni non di conversione, che hai scelto come target.

Per una procedura dettagliata completa di uno scenario di esempio in cui scegli come target gli utenti in base a una combinazione di azioni di conversione e non di conversione, consulta lo scenario di esempio.

Visitatori che hanno attivato una conversione

Un elenco di utenti di base definisce la propria appartenenza come persone che hanno attivato una o più azioni di conversione sul tuo sito web. Quando crei un elenco di utenti di base, fornisci il nome della risorsa del ConversionAction a un oggetto UserListActionInfo, che viene poi passato a UserList.

L'esempio seguente crea un elenco utenti di base associato a due azioni di conversione esistenti:

Java

private void runExample(
    GoogleAdsClient googleAdsClient, long customerId, List<Long> conversionActionIds) {
  List<UserListActionInfo> userListActionInfoList = new ArrayList<>();
  for (long conversionActionId : conversionActionIds) {
    // Creates the UserListActionInfo object for a given conversion action. This specifies the
    // conversion action that, when triggered, will cause a user to be added to a UserList.
    UserListActionInfo userListActionInfo =
        UserListActionInfo.newBuilder()
            .setConversionAction(ResourceNames.conversionAction(customerId, conversionActionId))
            .build();
    userListActionInfoList.add(userListActionInfo);
  }

  // Creates a basic user list info object with all of the conversion actions.
  BasicUserListInfo basicUserListInfo =
      BasicUserListInfo.newBuilder().addAllActions(userListActionInfoList).build();

  // Creates the basic user list.
  UserList basicUserList =
      UserList.newBuilder()
          .setName("Example BasicUserList #" + getPrintableDateTime())
          .setDescription("A list of people who have triggered one or more conversion actions")
          .setMembershipLifeSpan(365)
          .setBasicUserList(basicUserListInfo)
          .setMembershipStatus(UserListMembershipStatus.OPEN)
          .build();

  // Creates the operation.
  UserListOperation operation = UserListOperation.newBuilder().setCreate(basicUserList).build();

  // Creates the service client.
  try (UserListServiceClient userListServiceClient =
      googleAdsClient.getLatestVersion().createUserListServiceClient()) {
    // Adds the basic user list.
    MutateUserListsResponse response =
        userListServiceClient.mutateUserLists(
            Long.toString(customerId), ImmutableList.of(operation));
    // Prints the results.
    System.out.printf(
        "Created basic user list with resource name '%s'.%n",
        response.getResults(0).getResourceName());
  }
}
AddConversionBasedUserList.java
      

C#

public void Run(GoogleAdsClient client, long customerId, long[] conversionActionIds)
{
    // Creates the service client.
    UserListServiceClient userListServiceClient =
        client.GetService(Services.V18.UserListService);

    List<UserListActionInfo> userListActionInfoList = new List<UserListActionInfo>();
    foreach (long conversionActionId in conversionActionIds)
    {
        // Creates the UserListActionInfo object for a given conversion action. This
        // specifies the conversion action that, when triggered, will cause a user to be
        // added to a UserList.
        userListActionInfoList.Add(new UserListActionInfo
        {
            ConversionAction =
                ResourceNames.ConversionAction(customerId, conversionActionId)
        });
    }

    // Creates a basic user list info object with all of the conversion actions.
    BasicUserListInfo basicUserListInfo = new BasicUserListInfo();
    basicUserListInfo.Actions.Add(userListActionInfoList);

    // Creates the basic user list.
    UserList basicUserList = new UserList
    {
        Name = $"Example BasicUserList #{ExampleUtilities.GetShortRandomString()}",
        Description = "A list of people who have triggered one or more conversion actions",
        MembershipLifeSpan = 365L,
        BasicUserList = basicUserListInfo,
        MembershipStatus = UserListMembershipStatus.Open
    };

    // Creates the operation.
    UserListOperation operation = new UserListOperation
    {
        Create = basicUserList
    };

    try
    {
        // Adds the new user list.
        MutateUserListsResponse response = userListServiceClient.MutateUserLists
            (customerId.ToString(), new[] { operation });

        // Prints the result.
        Console.WriteLine("Created basic user list with resource name: " +
            $"{response.Results.First().ResourceName}");
    }
    catch (GoogleAdsException e)
    {
        Console.WriteLine("Failure:");
        Console.WriteLine($"Message: {e.Message}");
        Console.WriteLine($"Failure: {e.Failure}");
        Console.WriteLine($"Request ID: {e.RequestId}");
        throw;
    }
}
AddConversionBasedUserList.cs
      

PHP

public static function runExample(
    GoogleAdsClient $googleAdsClient,
    int $customerId,
    array $conversionActionIds
) {
    $userListActionInfoList = [];
    foreach ($conversionActionIds as $conversionActionId) {
        // Creates the UserListActionInfo object for a given conversion action. This specifies
        // the conversion action that, when triggered, will cause a user to be added to a
        // UserList.
        $userListActionInfoList[] = new UserListActionInfo([
            'conversion_action' => ResourceNames::forConversionAction(
                $customerId,
                $conversionActionId
            )
        ]);
    }

    // Creates a basic user list info object with all of the conversion actions.
    $basicUserListInfo = new BasicUserListInfo(['actions' => $userListActionInfoList]);

    // Creates the basic user list.
    $basicUserList = new UserList([
        'name' => 'Example BasicUserList #' . Helper::getPrintableDatetime(),
        'description' => 'A list of people who have triggered one or more conversion actions',
        'membership_status' => UserListMembershipStatus::OPEN,
        'membership_life_span' => 365,
        'basic_user_list' => $basicUserListInfo
    ]);

    // Creates the operation.
    $operation = new UserListOperation();
    $operation->setCreate($basicUserList);

    // 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 basic user list with resource name '%s'.%s",
        $response->getResults()[0]->getResourceName(),
        PHP_EOL
    );
}
AddConversionBasedUserList.php
      

Python

def main(client, customer_id, conversion_action_ids):
    """Creates a combination user list.

    Args:
        client: The Google Ads client.
        customer_id: The customer ID for which to add the user list.
        conversion_action_ids: The IDs of the conversion actions for the basic
            user list.
    """
    # Get the UserListService and ConversionActionService clients.
    user_list_service = client.get_service("UserListService")
    conversion_action_service = client.get_service("ConversionActionService")

    # Create a list of UserListActionInfo objects for the given conversion
    # actions. These specify the conversion actions that, when triggered, will
    # cause a user to be added to a UserList.
    user_list_action_info_list = []
    for conversion_action_id in conversion_action_ids:
        user_list_action_info = client.get_type("UserListActionInfo")
        user_list_action_info.conversion_action = (
            conversion_action_service.conversion_action_path(
                customer_id, conversion_action_id
            )
        )
        user_list_action_info_list.append(user_list_action_info)

    # Create a UserListOperation and populate the UserList.
    user_list_operation = client.get_type("UserListOperation")
    user_list = user_list_operation.create
    user_list.name = f"Example BasicUserList #{uuid4()}"
    user_list.description = (
        "A list of people who have triggered one or more conversion actions"
    )
    user_list.membership_status = client.enums.UserListMembershipStatusEnum.OPEN
    user_list.membership_life_span = 365
    # The basic user list info object contains the conversion action info.
    user_list.basic_user_list.actions.extend(user_list_action_info_list)

    # Issue a mutate request to add the user list, then print the results.
    response = user_list_service.mutate_user_lists(
        customer_id=customer_id, operations=[user_list_operation]
    )
    print(
        "Created basic user list with resource name "
        f"'{response.results[0].resource_name}.'"
    )
add_conversion_based_user_list.py
      

Ruby

def add_conversion_based_user_list(customer_id, conversion_action_ids)
  # GoogleAdsClient will read a config file from
  # ENV['HOME']/google_ads_config.rb when called without parameters
  client = Google::Ads::GoogleAds::GoogleAdsClient.new

  # Creates the basic user list.
  operation = client.operation.create_resource.user_list do |u|
    u.name = "Example BasicUserList ##{(Time.new.to_f * 100).to_i}"
    u.description = "A list of people who have triggered one or more conversion actions"
    u.membership_status = :OPEN
    u.membership_life_span = 365
    # Creates a basic user list info object with all of the conversion actions.
    u.basic_user_list = client.resource.basic_user_list_info do |info|
      conversion_action_ids.each do |conversion_action_id|
        # Creates the UserListActionInfo object for a given conversion action.
        # This specifies the conversion action that, when triggered, will cause a
        # user to be added to a user_list.
        info.actions << client.resource.user_list_action_info do |action|
          action.conversion_action =
            client.path.conversion_action(customer_id, conversion_action_id)
        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 basic user list with resource name " \
    "#{response.results.first.resource_name}"
end
add_conversion_based_user_list.rb
      

Perl

sub add_conversion_based_user_list {
  my ($api_client, $customer_id, $conversion_action_ids) = @_;

  my $user_list_action_info_list = [];
  foreach my $conversion_action_id (@$conversion_action_ids) {
    # Create the UserListActionInfo object for a given conversion action. This
    # specifies the conversion action that, when triggered, will cause a user to
    # be added to a UserList.
    push @$user_list_action_info_list,
      Google::Ads::GoogleAds::V18::Common::UserListActionInfo->new({
        conversionAction =>
          Google::Ads::GoogleAds::V18::Utils::ResourceNames::conversion_action(
          $customer_id, $conversion_action_id
          )});
  }

  # Create a basic user list info object with all of the conversion actions.
  my $basic_user_list_info =
    Google::Ads::GoogleAds::V18::Common::BasicUserListInfo->new({
      actions => $user_list_action_info_list
    });

  # Create the basic user list.
  my $basic_user_list = Google::Ads::GoogleAds::V18::Resources::UserList->new({
    name        => "Example BasicUserList #" . uniqid(),
    description =>
      "A list of people who have triggered one or more conversion actions",
    membershipStatus   => OPEN,
    membershipLifeSpan => 365,
    basicUserList      => $basic_user_list_info
  });

  # Create the operation.
  my $user_list_operation =
    Google::Ads::GoogleAds::V18::Services::UserListService::UserListOperation->
    new({
      create => $basic_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 basic user list with resource name '%s'.\n",
    $user_lists_response->{results}[0]{resourceName};

  return 1;
}
add_conversion_based_user_list.pl
      

Visitatori che hanno eseguito azioni non di conversione

Puoi creare un elenco di utenti di base per le persone che hanno eseguito azioni sul tuo sito web che non consideri conversioni associandolo a un RemarketingAction anziché a un ConversionAction.

Punto chiave: il valore RemarketingAction non viene visualizzato nella sezione Conversioni dell'interfaccia utente di Google Ads. Il suo stato è sempre impostato su HIDDEN e non può essere modificato.

Recuperare l'elenco

Per recuperare l'elenco di utenti, puoi eseguire la seguente query in linguaggio di query Google Ads alla risorsa 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'

Scegliere l'elenco come target

Dopo aver creato il segmento di pubblico, il passaggio successivo consiste nel sceglierlo come target.

Regole di targeting per segmento di pubblico

1. Elenchi di utenti positivi (disponibili) non possono essere impostati contemporaneamente a livello di campagna e a livello di gruppo di annunci. I criteri degli elenchi di utenti positivi devono essere rimossi da tutti i gruppi di annunci di una campagna prima di poterne impostare uno per la campagna.

2. Il targeting positivo per elenco di utenti è supportato solo per le campagne sulla rete di ricerca. Per le campagne display, CampaignCriterion che imposta user_list deve essere esclusa.

3. Nelle campagne sulla rete di ricerca e Shopping, i target degli elenchi di utenti non supportano l'impostazione dei seguenti campi:

   • url_custom_parameters
   • tracking_url_template
   • final_urls
   • final_mobile_urls

Scegliere il tuo elenco di utenti come target degli annunci

La procedura è simile a quella di altri tipi di criteri di targeting nell'API. Il seguente codice mostra come utilizzare un AdGroupCriterion per scegliere come target degli annunci di un gruppo di annunci un elenco di utenti:

Suggerimento: per escludere un elenco di utenti, imposta il campo AdGroupCriterion.negative su true.

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;
  }
}
SetUpRemarketing.java
      

C#

private string TargetAdsInAdGroupToUserList(
    GoogleAdsClient client, long customerId, long adGroupId, string userListResourceName)
{
    // Get the AdGroupCriterionService client.
    AdGroupCriterionServiceClient adGroupCriterionServiceClient = client.GetService
        (Services.V18.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;
}
SetUpRemarketing.cs
      

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;
}
SetUpRemarketing.php
      

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
set_up_remarketing.py
      

Ruby

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
set_up_remarketing.rb
      

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::V18::Resources::AdGroupCriterion->new({
      adGroup => Google::Ads::GoogleAds::V18::Utils::ResourceNames::ad_group(
        $customer_id, $ad_group_id
      ),
      userList => Google::Ads::GoogleAds::V18::Common::UserListInfo->new({
          userList => $user_list_resource_name
        })});

  # Create the operation.
  my $ad_group_criterion_operation =
    Google::Ads::GoogleAds::V18::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;
}
set_up_remarketing.pl
      

Come per altri tipi di criteri, puoi assegnare altre proprietà all'oggetto AdGroupCriterion, ad esempio le sostituzioni di offerta.

Cambiare i livelli di targeting

Se passi dai criteri degli elenchi di utenti a livello di gruppo di annunci a quelli a livello di campagna, devi prima rimuovere i criteri degli elenchi di utenti esistenti da ogni gruppo di annunci attivato o in pausa all'interno della campagna. Fai clic sugli elementi espandibili per visualizzare il codice di esempio per ogni passaggio.

Innanzitutto, recupera tutti gli elementi AdGroupCriteria di una determinata campagna.

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;
}
SetUpRemarketing.java
      

C#

private List<string> GetUserListAdGroupCriteria(
    GoogleAdsClient client, long customerId, long campaignId)
{
    // Get the GoogleAdsService client.
    GoogleAdsServiceClient googleAdsServiceClient =
        client.GetService(Services.V18.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;
}
SetUpRemarketing.cs
      

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;
}
SetUpRemarketing.php
      

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
set_up_remarketing.py
      

Ruby

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,
  )

  # 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
set_up_remarketing.rb
      

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::V18::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;
}
set_up_remarketing.pl
      

Quindi, rimuovi tutti i target dei criteri del gruppo di annunci restituiti.

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());
    }
  }
}
SetUpRemarketing.java
      

C#

private void RemoveExistingListCriteriaFromAdGroup(GoogleAdsClient client, long customerId,
    long campaignId)
{
    // Get the AdGroupCriterionService client.
    AdGroupCriterionServiceClient adGroupCriterionServiceClient =
        client.GetService(Services.V18.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}'.");
    }
}
SetUpRemarketing.cs
      

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
        );
    }
}
SetUpRemarketing.php
      

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}'"
    )
set_up_remarketing.py
      

Ruby

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
set_up_remarketing.rb
      

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::V18::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};
  }
}
set_up_remarketing.pl
      

Quando si passa agli elenchi di utenti a livello di gruppo di annunci, devono essere rimossi anche i criteri degli elenchi di utenti esistenti a livello di campagna e la procedura rispecchia l'esempio precedente.

Scegli come target degli annunci di una campagna un elenco di utenti utilizzando un criterio della campagna.

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;
  }
}
SetUpRemarketing.java
      

C#

private string TargetAdsInCampaignToUserList(
    GoogleAdsClient client, long customerId, long campaignId, string userListResourceName)
{
    // Get the CampaignCriterionService client.
    CampaignCriterionServiceClient campaignCriterionServiceClient =
        client.GetService(Services.V18.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;
}
SetUpRemarketing.cs
      

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;
}
SetUpRemarketing.php
      

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
set_up_remarketing.py
      

Ruby

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
set_up_remarketing.rb
      

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::V18::Resources::CampaignCriterion->new({
      campaign => Google::Ads::GoogleAds::V18::Utils::ResourceNames::campaign(
        $customer_id, $campaign_id
      ),
      userList => Google::Ads::GoogleAds::V18::Common::UserListInfo->new({
          userList => $user_list_resource_name
        })});

  # Create the operation.
  my $campaign_criterion_operation =
    Google::Ads::GoogleAds::V18::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;
}
set_up_remarketing.pl
      

Controllare il rendimento dell'elenco

Per raccogliere i dati sul rendimento dei segmenti di pubblico, effettua una richiesta di ricerca per la risorsa ad_group_audience_view o campaign_audience_view. Ad esempio, puoi esaminare conversions o cost_per_conversion per determinare se il targeting del segmento di pubblico sta effettivamente generando un aumento delle conversioni, quindi modificare di conseguenza i modificatori di offerta.

SELECT
  ad_group_criterion.criterion_id,
  metrics.conversions,
  metrics.cost_per_conversion
FROM ad_group_audience_view