Performance Max para vendas on-line com um feed de produtos (varejo)

Campanhas Performance Max para varejo ajuda a expandir seu alcance e suas metas, oferecendo a oportunidade de veicular anúncios em inventário adicional.

Talvez seja necessário criar novos recursos, como texto, imagem ou vídeo, para permitir a veiculação de anúncios em novos formatos e plataformas, como como texto, Discover, YouTube in-stream e Display.

Se você tiver insights exclusivos sobre os segmentos dos seus usuários com maior probabilidade de converter, também é possível usar Indicadores de público-alvo para informar o Google.

Confira mais algumas melhorias que as campanhas Performance Max oferecem campanhas padrão do Shopping:

  • Segmentação por idioma com base no feed do Merchant Center ou em critérios da campanha
  • Extensão de URL final
  • Todas as lojas são segmentadas quando a meta de visitas à loja é selecionada
  • É possível definir metas de conversão por cliente ou por campanha.
.

Para usar as campanhas Performance Max para varejo, a conta do Google Ads precisa ser vinculada a uma conta do Merchant Center. Ao vincular ao Merchant Center, os recursos podem ser gerados automaticamente para o campanha, mas o alcance e a performance serão limitados.

Adicionar grupos de recursos

Adicionar um grupo de recursos ativa o Shopping e o remarketing dinâmico canais, e definir a expansão de URL ativa a Anúncios de pesquisa. Em geral, quanto mais recursos você fornecer, mais formatos de anúncio serão que um sistema pode criar para segmentar inventários adicionais.

Recomendamos que cada grupo de recursos segmente produtos diferentes. Observe que há são os limites para as listagens grupos. Como prática recomendada, você deve segmentar apenas um determinado conjunto de produtos de um grupo de recursos. Por exemplo, os produtos de A a L estariam presentes O grupo de recursos 1 e os produtos de M a Z estariam no grupo de recursos 2.

Se quiser personalizar as mensagens do recurso por público-alvo, crie vários grupos de recursos por campanha. Assim, você pode criar diferentes recursos grupos para o mesmo URL final.

Veja mais otimização dicas ao configurar sua campanha Performance Max.

Criar uma campanha de varejo Performance Max

Como em outras campanhas do Shopping, defina os campos ShoppingSetting do campanha.

Obrigatório

merchant_id
O ID no Merchant Center da conta que contém os produtos a serem anunciados.

Opcional

feed_label

Uma string usada para o rótulo do feed conforme definido no Merchant Center. Este campo deve ser usado caso você precise selecionar produtos de um Feed do Merchant Center. Se não for especificado, a campanha usará todos os feeds disponíveis na do Merchant Center.

Se você já usou o sales_country descontinuado, nas letras código do país (XX), use feed_label. Para mais consulte a seção rótulo do feed artigo de suporte.

O envio de um código de país em uma feed_label não acontece automaticamente ativar a veiculação de anúncios nesse país; é preciso primeiro configurar as propriedades segmentação por local.

campaign_priority

A prioridade da campanha do Shopping. As campanhas com números maiores as prioridades têm precedência sobre as prioridades mais baixas.

enable_local

A opção para ativar anúncios de produtos vendidos em lojas locais nesta campanha.

Os produtos disponíveis na loja física serão ativados por padrão se houver um inventário. Isso pode ser usando grupos de fichas.

language

Você pode selecionar vários idiomas para exibir seus anúncios para conjuntos específicos de para os clientes.

Metas de conversão

É possível modificar a conversão no nível do cliente metas ao atualizar o nível da campanha e metas de conversão, conforme ilustrado neste exemplo:

Java

/** Retrieves the list of customer conversion goals. */
private static List<CustomerConversionGoal> getCustomerConversionGoals(
    GoogleAdsClient googleAdsClient, long customerId) {
  String query =
      "SELECT customer_conversion_goal.category, customer_conversion_goal.origin "
          + "FROM customer_conversion_goal";

  List<CustomerConversionGoal> customerConversionGoals = new ArrayList<>();
  try (GoogleAdsServiceClient googleAdsServiceClient =
      googleAdsClient.getLatestVersion().createGoogleAdsServiceClient()) {
    // The number of conversion goals is typically less than 50, so we use
    // GoogleAdsService.search instead of search_stream.
    SearchPagedResponse response =
        googleAdsServiceClient.search(Long.toString(customerId), query);
    for (GoogleAdsRow googleAdsRow : response.iterateAll()) {
      customerConversionGoals.add(googleAdsRow.getCustomerConversionGoal());
    }
  }

  return customerConversionGoals;
}

/** Creates a list of MutateOperations that override customer conversion goals. */
private static List<MutateOperation> createConversionGoalOperations(
    long customerId, List<CustomerConversionGoal> customerConversionGoals) {
  List<MutateOperation> mutateOperations = new ArrayList<>();
  // To override the customer conversion goals, we will change the
  // biddability of each of the customer conversion goals so that only
  // the desired conversion goal is biddable in this campaign.
  for (CustomerConversionGoal customerConversionGoal : customerConversionGoals) {
    ConversionActionCategory category = customerConversionGoal.getCategory();
    ConversionOrigin origin = customerConversionGoal.getOrigin();
    String campaignConversionGoalResourceName =
        ResourceNames.campaignConversionGoal(
            customerId, PERFORMANCE_MAX_CAMPAIGN_TEMPORARY_ID, category, origin);
    CampaignConversionGoal.Builder campaignConversionGoalBuilder =
        CampaignConversionGoal.newBuilder().setResourceName(campaignConversionGoalResourceName);
    // Change the biddability for the campaign conversion goal.
    // Set biddability to True for the desired (category, origin).
    // Set biddability to False for all other conversion goals.
    // Note:
    //  1- It is assumed that this Conversion Action
    //     (category=PURCHASE, origin=WEBSITE) exists in this account.
    //  2- More than one goal can be biddable if desired. This example
    //     shows only one.
    if (category == ConversionActionCategory.PURCHASE && origin == ConversionOrigin.WEBSITE) {
      campaignConversionGoalBuilder.setBiddable(true);
    } else {
      campaignConversionGoalBuilder.setBiddable(false);
    }
    CampaignConversionGoal campaignConversionGoal = campaignConversionGoalBuilder.build();
    CampaignConversionGoalOperation campaignConversionGoalOperation =
        CampaignConversionGoalOperation.newBuilder()
            .setUpdate(campaignConversionGoal)
            .setUpdateMask(FieldMasks.allSetFieldsOf(campaignConversionGoal))
            .build();
    mutateOperations.add(
        MutateOperation.newBuilder()
            .setCampaignConversionGoalOperation(campaignConversionGoalOperation)
            .build());
  }
  return mutateOperations;
}

AddPerformanceMaxRetailCampaign.java

C#

/// <summary>
/// Creates a MutateOperation that links an asset to an asset group.
/// </summary>
/// <param name="fieldType">The field type of the asset to be linked.</param>
/// <param name="assetGroupResourceName">The resource name of the asset group
/// to link the asset to.</param>
/// <param name="assetResourceName">The resource name of the text asset to be
/// linked.</param>
/// <returns>A MutateOperation that links an asset to an asset group.</returns>
private MutateOperation CreateLinkAssetOperation(
    AssetFieldType fieldType,
    string assetGroupResourceName,
    string assetResourceName) => new MutateOperation()
    {
        AssetGroupAssetOperation = new AssetGroupAssetOperation()
        {
            Create = new AssetGroupAsset()
            {
                FieldType = fieldType,
                AssetGroup = assetGroupResourceName,
                Asset = assetResourceName
            }
        }
    };

AddPerformanceMaxRetailCampaign.cs

PHP

private static function getCustomerConversionGoals(
    GoogleAdsClient $googleAdsClient,
    int $customerId
): array {
    $customerConversionGoals = [];
    $googleAdsServiceClient = $googleAdsClient->getGoogleAdsServiceClient();
    // Creates a query that retrieves all customer conversion goals.
    $query = 'SELECT customer_conversion_goal.category, customer_conversion_goal.origin ' .
        'FROM customer_conversion_goal';
    // The number of conversion goals is typically less than 50 so we use a search request
    // instead of search stream.
    $response =
        $googleAdsServiceClient->search(SearchGoogleAdsRequest::build($customerId, $query));

    // Iterates over all rows in all pages and builds the list of conversion goals.
    foreach ($response->iterateAllElements() as $googleAdsRow) {
        /** @var GoogleAdsRow $googleAdsRow */
        $customerConversionGoals[] = [
            'category' => $googleAdsRow->getCustomerConversionGoal()->getCategory(),
            'origin' => $googleAdsRow->getCustomerConversionGoal()->getOrigin()
        ];
    }

    return $customerConversionGoals;
}

/**
 * Creates a list of MutateOperations that override customer conversion goals.
 *
 * @param int $customerId the customer ID
 * @param array $customerConversionGoals the list of customer conversion goals that will be
 *      overridden
 * @return MutateOperation[] a list of MutateOperations that update campaign conversion goals
 */
private static function createConversionGoalOperations(
    int $customerId,
    array $customerConversionGoals
): array {
    $operations = [];

    // To override the customer conversion goals, we will change the biddability of each of the
    // customer conversion goals so that only the desired conversion goal is biddable in this
    // campaign.
    foreach ($customerConversionGoals as $customerConversionGoal) {
        $campaignConversionGoal = new CampaignConversionGoal([
            'resource_name' => ResourceNames::forCampaignConversionGoal(
                $customerId,
                self::PERFORMANCE_MAX_CAMPAIGN_TEMPORARY_ID,
                ConversionActionCategory::name($customerConversionGoal['category']),
                ConversionOrigin::name($customerConversionGoal['origin'])
            )
        ]);
        // Changes the biddability for the campaign conversion goal.
        // Sets biddability to true for the desired (category, origin).
        // Sets biddability to false for all other conversion goals.
        // Note:
        //  1- It is assumed that this Conversion Action
        //     (category=PURCHASE, origin=WEBSITE) exists in this account.
        //  2- More than one goal can be biddable if desired. This example
        //     shows only one.
        if (
            $customerConversionGoal["category"] === ConversionActionCategory::PURCHASE
            && $customerConversionGoal["origin"] === ConversionOrigin::WEBSITE
        ) {
            $campaignConversionGoal->setBiddable(true);
        } else {
            $campaignConversionGoal->setBiddable(false);
        }

        $operations[] = new MutateOperation([
            'campaign_conversion_goal_operation' => new CampaignConversionGoalOperation([
                'update' => $campaignConversionGoal,
                // Sets the update mask on the operation. Here the update mask will be a list
                // of all the fields that were set on the update object.
                'update_mask' => FieldMasks::allSetFieldsOf($campaignConversionGoal)
            ])
        ]);
    }

    return $operations;
}
AddPerformanceMaxRetailCampaign.php

Python

def get_customer_conversion_goals(client, customer_id):
    """Retrieves the list of customer conversion goals.

    Args:
        client: an initialized GoogleAdsClient instance.
        customer_id: a client customer ID.

    Returns:
        a list of dicts containing the category and origin of customer
        conversion goals.
    """
    ga_service = client.get_service("GoogleAdsService")
    customer_conversion_goals = []
    query = """
            SELECT
              customer_conversion_goal.category,
              customer_conversion_goal.origin
            FROM customer_conversion_goal
            """
    # The number of conversion goals is typically less than 50 so we use
    # GoogleAdsService.search instead of search_stream.
    search_request = client.get_type("SearchGoogleAdsRequest")
    search_request.customer_id = customer_id
    search_request.query = query
    results = ga_service.search(request=search_request)

    # Iterate over the results and build the list of conversion goals.
    for row in results:
        customer_conversion_goals.append(
            {
                "category": row.customer_conversion_goal.category,
                "origin": row.customer_conversion_goal.origin,
            }
        )
    return customer_conversion_goals


def create_conversion_goal_operations(
    client,
    customer_id,
    customer_conversion_goals,
):
    """Creates a list of MutateOperations that override customer conversion goals.

    Args:
        client: an initialized GoogleAdsClient instance.
        customer_id: a client customer ID.
        customer_conversion_goals: the list of customer conversion goals that
          will be overridden.

    Returns:
        MutateOperations that update campaign conversion goals.
    """
    campaign_conversion_goal_service = client.get_service(
        "CampaignConversionGoalService"
    )
    operations = []

    # To override the customer conversion goals, we will change the
    # biddability of each of the customer conversion goals so that only
    # the desired conversion goal is biddable in this campaign.
    for customer_conversion_goal in customer_conversion_goals:
        mutate_operation = client.get_type("MutateOperation")
        campaign_conversion_goal = (
            mutate_operation.campaign_conversion_goal_operation.update
        )

        campaign_conversion_goal.resource_name = (
            campaign_conversion_goal_service.campaign_conversion_goal_path(
                customer_id,
                _PERFORMANCE_MAX_CAMPAIGN_TEMPORARY_ID,
                customer_conversion_goal["category"].name,
                customer_conversion_goal["origin"].name,
            )
        )
        # Change the biddability for the campaign conversion goal.
        # Set biddability to True for the desired (category, origin).
        # Set biddability to False for all other conversion goals.
        # Note:
        #  1- It is assumed that this Conversion Action
        #     (category=PURCHASE, origin=WEBSITE) exists in this account.
        #  2- More than one goal can be biddable if desired. This example
        #     shows only one.
        if (
            customer_conversion_goal["category"]
            == client.enums.ConversionActionCategoryEnum.PURCHASE
            and customer_conversion_goal["origin"]
            == client.enums.ConversionOriginEnum.WEBSITE
        ):
            biddable = True
        else:
            biddable = False
        campaign_conversion_goal.biddable = biddable
        field_mask = protobuf_helpers.field_mask(
            None, campaign_conversion_goal._pb
        )
        client.copy_from(
            mutate_operation.campaign_conversion_goal_operation.update_mask,
            field_mask,
        )
        operations.append(mutate_operation)

    return operations
add_performance_max_retail_campaign.py

Ruby

def _get_customer_conversion_goals(client, customer_id)
  query = <<~EOD
    SELECT
        customer_conversion_goal.category,
        customer_conversion_goal.origin
    FROM customer_conversion_goal
  EOD

  customer_conversion_goals = []

  ga_service = client.service.google_ads
  # The number of conversion goals is typically less than 50 so we use
  # GoogleAdsService.search instead of search_stream.
  response = ga_service.search(
      customer_id: customer_id,
      query: query,
      page_size: PAGE_SIZE,
  )

  # Iterate over the results and build the list of conversion goals.
  response.each do |row|
    customer_conversion_goals << {
        "category" => row.customer_conversion_goal.category,
        "origin" => row.customer_conversion_goal.origin
    }
  end

  customer_conversion_goals
end

def create_conversion_goal_operations(client, customer_id, customer_conversion_goals)
  campaign_conversion_goal_service = client.service.campaign_conversion_goal

  operations = []

  # To override the customer conversion goals, we will change the
  # biddability of each of the customer conversion goals so that only
  # the desired conversion goal is biddable in this campaign.
  customer_conversion_goals.each do |customer_conversion_goal|
    operations << client.operation.mutate do |m|
        m.campaign_conversion_goal_operation = client.operation.campaign_conversion_goal do |op|
          op.update = client.resource.campaign_conversion_goal do |ccg|
              ccg.resource_name = client.path.campaign_conversion_goal(
                  customer_id,
                  PERFORMANCE_MAX_CAMPAIGN_TEMPORARY_ID,
                  customer_conversion_goal["category"].to_s,
                  customer_conversion_goal["origin"].to_s)
              # Change the biddability for the campaign conversion goal.
              # Set biddability to True for the desired (category, origin).
              # Set biddability to False for all other conversion goals.
              # Note:
              #  1- It is assumed that this Conversion Action
              #     (category=PURCHASE, origin=WEBSITE) exists in this account.
              #  2- More than one goal can be biddable if desired. This example
              #     shows only one.
              ccg.biddable = (customer_conversion_goal["category"] == :PURCHASE &&
                  customer_conversion_goal["origin"] == :WEBSITE)
          end
          op.update_mask = Google::Ads::GoogleAds::FieldMaskUtil.all_set_fields_of(op.update)
        end
    end
  end

  operations
end
add_performance_max_retail_campaign.rb

Perl

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

  my $customer_conversion_goals = [];
  # Create a query that retrieves all customer conversion goals.
  my $query =
    "SELECT customer_conversion_goal.category, customer_conversion_goal.origin "
    . "FROM customer_conversion_goal";
  # The number of conversion goals is typically less than 50 so we use
  # GoogleAdsService->search() method instead of search_stream().
  my $search_response = $api_client->GoogleAdsService()->search({
    customerId => $customer_id,
    query      => $query
  });

  # Iterate over the results and build the list of conversion goals.
  foreach my $google_ads_row (@{$search_response->{results}}) {
    push @$customer_conversion_goals,
      {
      category => $google_ads_row->{customerConversionGoal}{category},
      origin   => $google_ads_row->{customerConversionGoal}{origin}};
  }

  return $customer_conversion_goals;
}

# Creates a list of MutateOperations that override customer conversion goals.
sub create_conversion_goal_operations {
  my ($customer_id, $customer_conversion_goals) = @_;

  my $operations = [];
  # To override the customer conversion goals, we will change the biddability of
  # each of the customer conversion goals so that only the desired conversion goal
  # is biddable in this campaign.
  foreach my $customer_conversion_goal (@$customer_conversion_goals) {
    my $campaign_conversion_goal =
      Google::Ads::GoogleAds::V17::Resources::CampaignConversionGoal->new({
        resourceName =>
          Google::Ads::GoogleAds::V17::Utils::ResourceNames::campaign_conversion_goal(
          $customer_id,
          PERFORMANCE_MAX_CAMPAIGN_TEMPORARY_ID,
          $customer_conversion_goal->{category},
          $customer_conversion_goal->{origin})});
    # Change the biddability for the campaign conversion goal.
    # Set biddability to true for the desired (category, origin).
    # Set biddability to false for all other conversion goals.
    # Note:
    #  1- It is assumed that this Conversion Action
    #     (category=PURCHASE, origin=WEBSITE) exists in this account.
    #  2- More than one goal can be biddable if desired. This example
    #     shows only one.
    if ( $customer_conversion_goal->{category} eq PURCHASE
      && $customer_conversion_goal->{origin} eq WEBSITE)
    {
      $campaign_conversion_goal->{biddable} = "true";
    } else {
      $campaign_conversion_goal->{biddable} = "false";
    }

    push @$operations,
      Google::Ads::GoogleAds::V17::Services::GoogleAdsService::MutateOperation
      ->new({
        campaignConversionGoalOperation =>
          Google::Ads::GoogleAds::V17::Services::CampaignConversionGoalService::CampaignConversionGoalOperation
          ->new({
            update => $campaign_conversion_goal,
            # Set the update mask on the operation. Here the update mask will be
            # a list of all the fields that were set on the update object.
            updateMask => all_set_fields_of($campaign_conversion_goal)})});
  }

  return $operations;
}
add_performance_max_retail_campaign.pl

Relatórios do Shopping

Use o shopping_performance_view para recuperar métricas resumidas por segmentos de produto, como segments.product_item_id.

SELECT
  segments.product_item_id,
  metrics.clicks,
  metrics.cost_micros,
  metrics.impressions,
  metrics.conversions,
  metrics.all_conversions,
  campaign.advertising_channel_type
FROM shopping_performance_view
WHERE
  campaign.advertising_channel_type = 'PERFORMANCE_MAX'
  AND segments.date DURING LAST_30_DAYS
  AND metrics.clicks > 0
ORDER BY
  metrics.all_conversions DESC,
  metrics.conversions DESC,
  metrics.clicks DESC,
  metrics.cost_micros DESC,
  metrics.impressions DESC

Use o asset_group_product_group_view para recuperar métricas como cliques, conversões e impressões da grupo de produtos anunciados associado a esse grupo de recursos.

Anúncios de veículos

Os anunciantes podem usar anúncios de veículos para promover seu inventário de veículos enviando um feed de dados de veículos para Merchant Center e, em seguida, usar Campanhas Performance Max com feeds de veículos para gerenciar anúncios.

Para criar uma campanha Performance Max com um feed de veículos usando a API Google Ads, siga Criar uma campanha de varejo, e defina o listing_type da campanha como VEHICLES.

Anterior
Vendas on-line ou geração de leads
Próxima
Metas de viagem