Segmentação por local

Este guia descreve a segmentação por local e o modo de usar a API Google Ads para adicionar, recuperar e atualizar segmentações por local para suas campanhas.

Para informações sobre limites de segmentação, consulte a seção Limites de segmentação em Sobre os limites da conta do Google Ads.

Por que a segmentação por área geográfica é importante?

A segmentação por local permite veicular anúncios para usuários em uma região geográfica específica. Por exemplo, suponha que você esteja anunciando uma rede de supermercados. Sem a segmentação por local, seus anúncios seriam mostrados em todas as regiões do mundo e poderiam receber cliques de usuários em regiões onde você não tem supermercados. Assim, haveria a geração de custos e nenhuma possibilidade de retorno do investimento. Com a segmentação por local, suas campanhas mostram anúncios apenas em regiões onde você tem supermercados abertos. Essa abordagem também permite segmentar diretamente os clientes que pesquisam supermercados localmente.

A Google Ads API permite segmentar seus anúncios por país, região ou proximidade em torno de um ponto geográfico específico.

Segmentar campanhas geográficas para uma região

Você pode segmentar campanhas para qualquer região geográfica em que o Google Ads ofereça suporte à segmentação por local, como um país, um estado, uma cidade ou uma região postal. Cada local segmentável é identificado de maneira exclusiva por um ID de critério. Você pode pesquisar um ID de critério usando GeoTargetConstantService.SuggestGeoTargetConstants. O resource_name de cada GeoTargetConstant tem o formato geoTargetConstants/{Criterion ID}. Por exemplo, o valor resource_name do estado de Nova York é geoTargetConstants/21167.

Você pode adicionar segmentações por área geográfica às suas campanhas usando o CampaignCriterionService ou no nível do grupo de anúncios usando AdGroupCriterion para tipos de campanha compatíveis, como campanhas Geração de demanda com upgraded_targeting ativado. O snippet de código a seguir mostra como segmentar sua campanha com um ID de critério.

Java

private static CampaignCriterion buildLocationIdCriterion(
    long locationId, String campaignResourceName) {
  Builder criterionBuilder = CampaignCriterion.newBuilder().setCampaign(campaignResourceName);

  criterionBuilder
      .getLocationBuilder()
      .setGeoTargetConstant(ResourceNames.geoTargetConstant(locationId));

  return criterionBuilder.build();
}
AddCampaignTargetingCriteria.java
      

C#

private CampaignCriterion buildLocationCriterion(long locationId,
    string campaignResourceName)
{
    GeoTargetConstantName location = new GeoTargetConstantName(locationId.ToString());
    return new CampaignCriterion()
    {
        Campaign = campaignResourceName,
        Location = new LocationInfo()
        {
            GeoTargetConstant = location.ToString()
        }
    };
}
AddCampaignTargetingCriteria.cs
      

PHP

private static function createLocationCampaignCriterionOperation(
    int $locationId,
    string $campaignResourceName
) {
    // Constructs a campaign criterion for the specified campaign ID using the specified
    // location ID.
    $campaignCriterion = new CampaignCriterion([
        // Creates a location using the specified location ID.
        'location' => new LocationInfo([
            // Besides using location ID, you can also search by location names using
            // GeoTargetConstantServiceClient::suggestGeoTargetConstants() and directly
            // apply GeoTargetConstant::$resourceName here. An example can be found
            // in GetGeoTargetConstantByNames.php.
            'geo_target_constant' => ResourceNames::forGeoTargetConstant($locationId)
        ]),
        'campaign' => $campaignResourceName
    ]);

    return new CampaignCriterionOperation(['create' => $campaignCriterion]);
}
AddCampaignTargetingCriteria.php
      

Python

def create_location_op(
    client: GoogleAdsClient,
    customer_id: str,
    campaign_id: str,
    location_id: str,
) -> CampaignCriterionOperation:
    campaign_service: CampaignServiceClient = client.get_service(
        "CampaignService"
    )
    geo_target_constant_service: GeoTargetConstantServiceClient = (
        client.get_service("GeoTargetConstantService")
    )

    # Create the campaign criterion.
    campaign_criterion_operation: CampaignCriterionOperation = client.get_type(
        "CampaignCriterionOperation"
    )
    campaign_criterion: CampaignCriterion = campaign_criterion_operation.create
    campaign_criterion.campaign = campaign_service.campaign_path(
        customer_id, campaign_id
    )

    # Besides using location_id, you can also search by location names from
    # GeoTargetConstantService.suggest_geo_target_constants() and directly
    # apply GeoTargetConstant.resource_name here. An example can be found
    # in get_geo_target_constant_by_names.py.
    campaign_criterion.location.geo_target_constant = (
        geo_target_constant_service.geo_target_constant_path(location_id)
    )

    return campaign_criterion_operation
add_campaign_targeting_criteria.py
      

Ruby

def create_location(client, customer_id, campaign_id, location_id)
  client.operation.create_resource.campaign_criterion do |criterion|
    criterion.campaign = client.path.campaign(customer_id, campaign_id)

    criterion.location = client.resource.location_info do  |li|
      # Besides using location_id, you can also search by location names from
      # GeoTargetConstantService.suggest_geo_target_constants() and directly
      # apply GeoTargetConstant.resource_name here. An example can be found
      # in get_geo_target_constant_by_names.rb.
      li.geo_target_constant = client.path.geo_target_constant(location_id)
    end
  end
end
add_campaign_targeting_criteria.rb
      

Perl

sub create_location_campaign_criterion_operation {
  my ($location_id, $campaign_resource_name) = @_;

  # Construct a campaign criterion for the specified campaign using the
  # specified location ID.
  my $campaign_criterion =
    Google::Ads::GoogleAds::V25::Resources::CampaignCriterion->new({
      # Create a location using the specified location ID.
      location => Google::Ads::GoogleAds::V25::Common::LocationInfo->new({
          # Besides using location ID, you can also search by location names
          # using GeoTargetConstantService::suggest() and directly apply
          # GeoTargetConstant->{resourceName} here. An example can be found
          # in get_geo_target_constants_by_names.pl.
          geoTargetConstant =>
            Google::Ads::GoogleAds::V25::Utils::ResourceNames::geo_target_constant(
            $location_id)}
      ),
      campaign => $campaign_resource_name
    });

  return
    Google::Ads::GoogleAds::V25::Services::CampaignCriterionService::CampaignCriterionOperation
    ->new({
      create => $campaign_criterion
    });
}
add_campaign_targeting_criteria.pl
      

curl

Observação:embora um exemplo de código REST direto para esta etapa não seja fornecido aqui, você pode fazer isso usando uma solicitação REST manual.

Consulte a documentação da interface REST da API Google Ads e as páginas de referência específicas do método. Você precisará criar o payload JSON com base nas definições do proto.

Recursos principais:

• Usar REST
• Estrutura da interface REST
• Mapeamentos de campos JSON
• Consulte a referência da API REST para o serviço e o método específicos.

O Google pode eliminar alguns critérios de local por vários motivos: o local pode ser reestruturado em áreas menores ou maiores, mudanças geopolíticas e assim por diante. Consulte o campo status de um objeto GeoTargetConstant para determinar se um local está ENABLED ou REMOVAL_PLANNED.

Pesquisar por nome do local

Você também pode pesquisar o ID do critério pelo nome do local usando GeoTargetConstantService.SuggestGeoTargetConstants. O exemplo de código a seguir mostra como pesquisar um ID de critério de local pelo nome.

Java

private void runExample(GoogleAdsClient googleAdsClient) {
  try (GeoTargetConstantServiceClient geoTargetClient =
      googleAdsClient.getLatestVersion().createGeoTargetConstantServiceClient()) {

    SuggestGeoTargetConstantsRequest.Builder requestBuilder =
        SuggestGeoTargetConstantsRequest.newBuilder();

    // Locale is using ISO 639-1 format. If an invalid locale is given, 'en' is used by default.
    requestBuilder.setLocale("en");

    // A list of country codes can be referenced here:
    // https://developers.google.com/google-ads/api/reference/data/geotargets
    requestBuilder.setCountryCode("FR");

    requestBuilder
        .getLocationNamesBuilder()
        .addAllNames(ImmutableList.of("Paris", "Quebec", "Spain", "Deutschland"));

    SuggestGeoTargetConstantsResponse response =
        geoTargetClient.suggestGeoTargetConstants(requestBuilder.build());

    for (GeoTargetConstantSuggestion suggestion :
        response.getGeoTargetConstantSuggestionsList()) {
      System.out.printf(
          "%s (%s,%s,%s,%s) is found in locale (%s) with reach (%d) for search term (%s).%n",
          suggestion.getGeoTargetConstant().getResourceName(),
          suggestion.getGeoTargetConstant().getName(),
          suggestion.getGeoTargetConstant().getCountryCode(),
          suggestion.getGeoTargetConstant().getTargetType(),
          suggestion.getGeoTargetConstant().getStatus().name(),
          suggestion.getLocale(),
          suggestion.getReach(),
          suggestion.getSearchTerm());
    }
  }
}
GetGeoTargetConstantsByNames.java
      

C#

public void Run(GoogleAdsClient client)
{
    // Get the GeoTargetConstantServiceClient.
    GeoTargetConstantServiceClient geoService =
        client.GetService(Services.V25.GeoTargetConstantService);

    // Locale is using ISO 639-1 format. If an invalid locale is given,
    // 'en' is used by default.
    string locale = "en";

    // A list of country codes can be referenced here:
    // https://developers.google.com/google-ads/api/reference/data/geotargets
    string countryCode = "FR";

    string[] locations = { "Paris", "Quebec", "Spain", "Deutschland" };

    SuggestGeoTargetConstantsRequest request = new SuggestGeoTargetConstantsRequest()
    {
        Locale = locale,
        CountryCode = countryCode,
        LocationNames = new SuggestGeoTargetConstantsRequest.Types.LocationNames()
    };

    request.LocationNames.Names.AddRange(locations);

    try
    {
        SuggestGeoTargetConstantsResponse response =
            geoService.SuggestGeoTargetConstants(request);

        foreach (GeoTargetConstantSuggestion suggestion
            in response.GeoTargetConstantSuggestions)
        {
            Console.WriteLine(
                $"{suggestion.GeoTargetConstant.ResourceName} " +
                $"({suggestion.GeoTargetConstant.Name}, " +
                $"{suggestion.GeoTargetConstant.CountryCode}, " +
                $"{suggestion.GeoTargetConstant.TargetType}, " +
                $"{suggestion.GeoTargetConstant.Status}) is found in locale " +
                $"({suggestion.Locale}) with reach ({suggestion.Reach}) " +
                $"for search term ({suggestion.SearchTerm}).");
        }
    }
    catch (GoogleAdsException e)
    {
        Console.WriteLine("Failure:");
        Console.WriteLine($"Message: {e.Message}");
        Console.WriteLine($"Failure: {e.Failure}");
        Console.WriteLine($"Request ID: {e.RequestId}");
        throw;
    }
}
GetGeoTargetConstantsByNames.cs
      

PHP

public static function runExample(
    GoogleAdsClient $googleAdsClient,
    array $locationNames,
    string $locale,
    string $countryCode
) {
    $geoTargetConstantServiceClient = $googleAdsClient->getGeoTargetConstantServiceClient();

    $response = $geoTargetConstantServiceClient->suggestGeoTargetConstants(
        new SuggestGeoTargetConstantsRequest([
            'locale' => $locale,
            'country_code' => $countryCode,
            'location_names' => new LocationNames(['names' => $locationNames])
        ])
    );

    // Iterates over all geo target constant suggestion objects and prints the requested field
    // values for each one.
    foreach ($response->getGeoTargetConstantSuggestions() as $geoTargetConstantSuggestion) {
        /** @var GeoTargetConstantSuggestion $geoTargetConstantSuggestion */
        printf(
            "Found '%s' ('%s','%s','%s',%s) in locale '%s' with reach %d"
            . " for the search term '%s'.%s",
            $geoTargetConstantSuggestion->getGeoTargetConstant()->getResourceName(),
            $geoTargetConstantSuggestion->getGeoTargetConstant()->getName(),
            $geoTargetConstantSuggestion->getGeoTargetConstant()->getCountryCode(),
            $geoTargetConstantSuggestion->getGeoTargetConstant()->getTargetType(),
            GeoTargetConstantStatus::name(
                $geoTargetConstantSuggestion->getGeoTargetConstant()->getStatus()
            ),
            $geoTargetConstantSuggestion->getLocale(),
            $geoTargetConstantSuggestion->getReach(),
            $geoTargetConstantSuggestion->getSearchTerm(),
            PHP_EOL
        );
    }
}
GetGeoTargetConstantsByNames.php
      

Python

def main(client: GoogleAdsClient) -> None:
    gtc_service: GeoTargetConstantServiceClient = client.get_service(
        "GeoTargetConstantService"
    )

    gtc_request: SuggestGeoTargetConstantsRequest = client.get_type(
        "SuggestGeoTargetConstantsRequest"
    )
    gtc_request.locale = LOCALE
    gtc_request.country_code = COUNTRY_CODE

    # The location names to get suggested geo target constants.
    # Type hint for gtc_request.location_names.names is not straightforward
    # as it's part of a complex protobuf object.
    gtc_request.location_names.names.extend(
        ["Paris", "Quebec", "Spain", "Deutschland"]
    )

    results: SuggestGeoTargetConstantsResponse = (
        gtc_service.suggest_geo_target_constants(gtc_request)
    )

    suggestion: GeoTargetConstantSuggestion
    for suggestion in results.geo_target_constant_suggestions:
        geo_target_constant: GeoTargetConstant = suggestion.geo_target_constant
        print(
            f"{geo_target_constant.resource_name} "
            f"({geo_target_constant.name}, "
            f"{geo_target_constant.country_code}, "
            f"{geo_target_constant.target_type}, "
            f"{geo_target_constant.status.name}) "
            f"is found in locale ({suggestion.locale}) "
            f"with reach ({suggestion.reach}) "
            f"from search term ({suggestion.search_term})."
        )
get_geo_target_constants_by_names.py
      

Ruby

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

  gtc_service = client.service.geo_target_constant

  location_names = client.resource.location_names do |ln|
    ['Paris', 'Quebec', 'Spain', 'Deutschland'].each do |name|
      ln.names << name
    end
  end

  # Locale is using ISO 639-1 format. If an invalid locale is given,
  # 'en' is used by default.
  locale = 'en'

  # A list of country codes can be referenced here:
  # https://developers.google.com/google-ads/api/reference/data/geotargets
  country_code = 'FR'

  response = gtc_service.suggest_geo_target_constants(
    locale: locale,
    country_code: country_code,
    location_names: location_names
  )

  response.geo_target_constant_suggestions.each do |suggestion|
    puts sprintf("%s (%s,%s,%s,%s) is found in locale (%s) with reach (%d)" \
        " from search term (%s).", suggestion.geo_target_constant.resource_name,
        suggestion.geo_target_constant.name,
        suggestion.geo_target_constant.country_code,
        suggestion.geo_target_constant.target_type,
        suggestion.geo_target_constant.status,
        suggestion.locale,
        suggestion.reach,
        suggestion.search_term)
  end
end
get_geo_target_constants_by_names.rb
      

Perl

sub get_geo_target_constants_by_names {
  my ($api_client, $location_names, $locale, $country_code) = @_;

  my $suggest_response = $api_client->GeoTargetConstantService()->suggest({
      locale        => $locale,
      countryCode   => $country_code,
      locationNames =>
        Google::Ads::GoogleAds::V25::Services::GeoTargetConstantService::LocationNames
        ->new({
          names => $location_names
        })});

  # Iterate over all geo target constant suggestion objects and print the requested
  # field values for each one.
  foreach my $geo_target_constant_suggestion (
    @{$suggest_response->{geoTargetConstantSuggestions}})
  {
    printf "Found '%s' ('%s','%s','%s',%s) in locale '%s' with reach %d" .
      " for the search term '%s'.\n",
      $geo_target_constant_suggestion->{geoTargetConstant}{resourceName},
      $geo_target_constant_suggestion->{geoTargetConstant}{name},
      $geo_target_constant_suggestion->{geoTargetConstant}{countryCode},
      $geo_target_constant_suggestion->{geoTargetConstant}{targetType},
      $geo_target_constant_suggestion->{geoTargetConstant}{status},
      $geo_target_constant_suggestion->{locale},
      $geo_target_constant_suggestion->{reach},
      $geo_target_constant_suggestion->{searchTerm};
  }

  return 1;
}
get_geo_target_constants_by_names.pl
      

curl

Observação:embora um exemplo de código REST direto para esta etapa não seja fornecido aqui, você pode fazer isso usando uma solicitação REST manual.

Consulte a documentação da interface REST da API Google Ads e as páginas de referência específicas do método. Você precisará criar o payload JSON com base nas definições do proto.

Recursos principais:

• Usar REST
• Estrutura da interface REST
• Mapeamentos de campos JSON
• Consulte a referência da API REST para o serviço e o método específicos.

Segmentar campanhas por proximidade com um local

Às vezes, você pode querer segmentar de forma ainda mais precisa do que uma cidade ou país. Por exemplo, você pode querer anunciar seus supermercados em um raio de 10 quilômetros da sua loja. Nesses casos, você pode usar a segmentação por proximidade. O código para criar uma proximidade segmentação é semelhante à adição de uma segmentação por local, exceto que você precisa criar um ProximityInfo objeto em vez de um LocationInfo objeto.

Java

private static CampaignCriterion buildProximityLocation(String campaignResourceName) {
  Builder builder = CampaignCriterion.newBuilder().setCampaign(campaignResourceName);

  ProximityInfo.Builder proximityBuilder = builder.getProximityBuilder();
  proximityBuilder.setRadius(10.0).setRadiusUnits(ProximityRadiusUnits.MILES);

  AddressInfo.Builder addressBuilder = proximityBuilder.getAddressBuilder();
  addressBuilder
      .setStreetAddress("38 avenue de l'Opéra")
      .setCityName("Paris")
      .setPostalCode("75002")
      .setCountryCode("FR");

  return builder.build();
}
AddCampaignTargetingCriteria.java
      

C#

private CampaignCriterion buildProximityCriterion(string campaignResourceName)
{
    ProximityInfo proximity = new ProximityInfo()
    {
        Address = new AddressInfo()
        {
            StreetAddress = "38 avenue de l'Opéra",
            CityName = "Paris",
            PostalCode = "75002",
            CountryCode = "FR"
        },
        Radius = 10d,
        // Default is kilometers.
        RadiusUnits = ProximityRadiusUnits.Miles
    };

    return new CampaignCriterion()
    {
        Campaign = campaignResourceName,
        Proximity = proximity
    };
}
AddCampaignTargetingCriteria.cs
      

PHP

private static function createProximityCampaignCriterionOperation(string $campaignResourceName)
{
    // Constructs a campaign criterion as a proximity.
    $campaignCriterion = new CampaignCriterion([
        'proximity' => new ProximityInfo([
            'address' => new AddressInfo([
                'street_address' => '38 avenue de l\'Opéra',
                'city_name' => 'Paris',
                'postal_code' => '75002',
                'country_code' => 'FR',
            ]),
            'radius' => 10.0,
            // Default is kilometers.
            'radius_units' => ProximityRadiusUnits::MILES
        ]),
        'campaign' => $campaignResourceName
    ]);

    return new CampaignCriterionOperation(['create' => $campaignCriterion]);
}
AddCampaignTargetingCriteria.php
      

Python

def create_proximity_op(
    client: GoogleAdsClient, customer_id: str, campaign_id: str
) -> CampaignCriterionOperation:
    campaign_service: CampaignServiceClient = client.get_service(
        "CampaignService"
    )

    # Create the campaign criterion.
    campaign_criterion_operation: CampaignCriterionOperation = client.get_type(
        "CampaignCriterionOperation"
    )
    campaign_criterion: CampaignCriterion = campaign_criterion_operation.create
    campaign_criterion.campaign = campaign_service.campaign_path(
        customer_id, campaign_id
    )
    campaign_criterion.proximity.address.street_address = "38 avenue de l'Opera"
    campaign_criterion.proximity.address.city_name = "Paris"
    campaign_criterion.proximity.address.postal_code = "75002"
    campaign_criterion.proximity.address.country_code = "FR"
    campaign_criterion.proximity.radius = 10
    # Default is kilometers.
    campaign_criterion.proximity.radius_units = (
        client.enums.ProximityRadiusUnitsEnum.MILES
    )

    return campaign_criterion_operation
add_campaign_targeting_criteria.py
      

Ruby

def create_proximity(client, customer_id, campaign_id)
  client.operation.create_resource.campaign_criterion do |criterion|
    criterion.campaign = client.path.campaign(customer_id, campaign_id)

    criterion.proximity = client.resource.proximity_info do |proximity|
      proximity.address = client.resource.address_info do |address|
        address.street_address = "38 avenue de l'Opéra"
        address.city_name = "Paris"
        address.postal_code = "75002"
        address.country_code = "FR"
      end

      proximity.radius = 10
      proximity.radius_units = :MILES
    end
  end
end
add_campaign_targeting_criteria.rb
      

Perl

sub create_proximity_campaign_criterion_operation {
  my ($campaign_resource_name) = @_;

  # Construct a campaign criterion as a proximity.
  my $campaign_criterion =
    Google::Ads::GoogleAds::V25::Resources::CampaignCriterion->new({
      proximity => Google::Ads::GoogleAds::V25::Common::ProximityInfo->new({
          address => Google::Ads::GoogleAds::V25::Common::AddressInfo->new({
              streetAddress => "38 avenue de l'Opéra",
              cityName      => "cityName",
              postalCode    => "75002",
              countryCode   => "FR"
            }
          ),
          radius => 10.0,
          # Default is kilometers.
          radiusUnits => MILES
        }
      ),
      campaign => $campaign_resource_name
    });

  return
    Google::Ads::GoogleAds::V25::Services::CampaignCriterionService::CampaignCriterionOperation
    ->new({
      create => $campaign_criterion
    });
}
add_campaign_targeting_criteria.pl
      

curl

Observação:embora um exemplo de código REST direto para esta etapa não seja fornecido aqui, você pode fazer isso usando uma solicitação REST manual.

Consulte a documentação da interface REST da API Google Ads e as páginas de referência específicas do método. Você precisará criar o payload JSON com base nas definições do proto.

Recursos principais:

• Usar REST
• Estrutura da interface REST
• Mapeamentos de campos JSON
• Consulte a referência da API REST para o serviço e o método específicos.

Recuperar segmentações por área geográfica

Você pode recuperar as segmentações por área geográfica de uma campanha usando GoogleAdsService.SearchStream. A inclusão de campaign_criterion.type e campaign_criterion.resource_name na cláusula SELECT permite distinguir entre critérios LOCATION e PROXIMITY e registrar os nomes de recursos para atualizações ou remoções subsequentes.

SELECT
  campaign_criterion.resource_name,
  campaign_criterion.campaign,
  campaign_criterion.type,
  campaign_criterion.location.geo_target_constant,
  campaign_criterion.proximity.geo_point.longitude_in_micro_degrees,
  campaign_criterion.proximity.geo_point.latitude_in_micro_degrees,
  campaign_criterion.proximity.radius,
  campaign_criterion.proximity.radius_units,
  campaign_criterion.proximity.address.street_address,
  campaign_criterion.proximity.address.city_name,
  campaign_criterion.proximity.address.postal_code,
  campaign_criterion.proximity.address.country_code,
  campaign_criterion.negative
FROM campaign_criterion
WHERE
  campaign_criterion.campaign = 'customers/{customer_id}/campaigns/{campaign_id}'
  AND campaign_criterion.type IN ('LOCATION', 'PROXIMITY')

Atualizar segmentações por área geográfica

Os critérios de local em uma campanha são imutáveis após a criação. Portanto, a atualização das segmentações por área geográfica de uma campanha exige a substituição das segmentações obsoletas por novas em uma única solicitação atômica CampaignCriterionService.MutateCampaignCriteria:

1. Consulte os critérios LOCATION e PROXIMITY atuais da campanha usando a consulta GAQL em Recuperar segmentações por área geográfica.
2. Compare os critérios atuais com a lista de segmentação pretendida.
3. Para cada critério obsoleto, crie uma CampaignCriterionOperation com remove definido como o resource_name do critério atual.
4. Para cada novo local ou segmentação por proximidade, crie uma CampaignCriterionOperation com create preenchido com o novo critério LocationInfo ou ProximityInfo.
5. Transmita as operações remove e create em uma única chamada MutateCampaignCriteria para que a transição aconteça de forma atômica.

Observação: na v24 e versões mais recentes, tentar remover todos os critérios de local de uma campanha Performance Max de serviços locais retorna CampaignCriterionError.CANNOT_REMOVE_ALL_LOCATIONS_FROM_LOCAL_SERVICES_PMAX_CAMPAIGN.

Excluir segmentações geográficas

Também é possível excluir LocationInfo, mas não ProximityInfo. Esse recurso é mais útil se você quiser segmentar uma região, mas excluir uma sub-região (por exemplo, segmentar todos os Estados Unidos, exceto a cidade de Nova York). Para excluir uma região, defina o negative campo em CampaignCriterion como true.

Segmentar várias regiões geográficas

Se você usar um LocationGroupInfo, poderá ativar uma campanha para segmentar várias regiões geográficas centradas em locais definidos por recursos de local ou filtradas por uma região geográfica:

• Conjuntos de recursos de local: defina enable_customer_level_location_asset_set = true (para segmentar o conjunto de recursos de local do cliente) ou location_group_asset_sets (para segmentar nomes de recursos AssetSet específicos). Esses dois campos não podem ser definidos juntos, e nenhum deles pode ser combinado com geo_target_constants.
• Raio e unidades: o raio em LocationGroupInfo define uma região circular em torno de cada local e exige radius e radius_units (LocationGroupRadiusUnitsEnum):
  • Ao usar conjuntos de recursos de local (enable_customer_level_location_asset_set ou location_group_asset_sets), os valores radius_units aceitos são MILLI_MILES e METERS.
  • Ao filtrar por geo_target_constants (em que no máximo um ID de critério é permitido e os campos AssetSet não estão definidos), os valores radius_units aceitos são MILES e METERS.

Opções de local avançadas com GeoTargetTypeSetting

Além de especificar os locais a serem segmentados ou excluídos, você pode refinar como o Google Ads corresponde aos usuários nesses locais usando opções de local avançadas. Essas configurações são gerenciadas por Campaign.GeoTargetTypeSetting.

Essa configuração consiste em dois campos:

• positive_geo_target_type: determina como os usuários são correspondidos para os locais que você segmenta.
• negative_geo_target_type: determina como os usuários são correspondidos para os locais que você exclui.

Configurações de segmentação positiva (positive_geo_target_type)

Você pode escolher entre as seguintes opções para sua segmentação geográfica positiva, usando valores de PositiveGeoTargetTypeEnum:

• PRESENCE_OR_INTEREST (padrão recomendado):

  • Alcança pessoas que provavelmente estão ou costumam frequentar os locais segmentados, além de pessoas que demonstraram interesse nesses locais.
  • O interesse pode ser indicado por termos de pesquisa, visitas anteriores ou conteúdo consumido relacionado ao local.
  • Essa opção oferece o alcance mais amplo.

• PRESENCE:

  • Alcança apenas pessoas que provavelmente estão ou costumam frequentar as regiões de segmentação.
  • Essa opção é mais restritiva e útil se seus serviços ou produtos forem estritamente limitados a pessoas fisicamente presentes em uma área.

Observação: O valor SEARCH_INTEREST aciona anúncios quando um usuário pesquisa suas regiões de segmentação e só pode ser usado com campanhas de pesquisa e do Shopping padrão.

Configurações de segmentação negativa (negative_geo_target_type)

Para os locais que você quer excluir, use o NegativeGeoTargetTypeEnum:

• PRESENCE (padrão recomendado) :
  • Exclui pessoas que provavelmente estão fisicamente nos locais que você excluiu.
  • As pessoas fora das áreas excluídas, mesmo que estejam interessadas nelas, ainda podem ver seus anúncios, desde que correspondam à sua segmentação positiva.

Observação: O valor PRESENCE_OR_INTEREST geralmente não é aceito para segmentação geográfica negativa na maioria dos tipos de campanha.

Gerenciar opções de local avançadas

Você pode controlar essas configurações atualizando o objeto Campaign.geo_target_type_setting. O exemplo a seguir mostra a estrutura de uma atualização de CampaignOperation que define positive_geo_target_type como PRESENCE:

// Conceptual structure for a Campaign update operation
operations {
  update {
    resource_name: "customers/{customer_id}/campaigns/{campaign_id}"
    geo_target_type_setting {
      positive_geo_target_type: PRESENCE
      // negative_geo_target_type remains at its default PRESENCE
    }
  }
  update_mask {
    paths: "geo_target_type_setting.positive_geo_target_type"
  }
}

Para buscar as configurações atuais, inclua campaign.geo_target_type_setting.positive_geo_target_type e campaign.geo_target_type_setting.negative_geo_target_type na consulta de pesquisa GoogleAdsService.

Ao configurar essas configurações, você ganha um controle mais granular sobre quem vê seus anúncios com base no relacionamento deles com as localizações geográficas especificadas, alinhando-se mais de perto às suas metas de negócios.

Práticas recomendadas

• Escolha PRESENCE se seu produto ou serviço for estritamente limitado a pessoas fisicamente presentes em um local. Por exemplo, suponha que você exija que os usuários estejam na loja ou queiram entrega local.
• Escolha PRESENCE_OR_INTEREST se seu produto ou serviço também puder beneficiar pessoas interessadas em um local, mesmo que não estejam fisicamente presentes. Por exemplo, um usuário que planeja férias pode estar interessado em hotéis na cidade de destino.
• Use a segmentação por local negativa para refinar o alcance. Se você segmentar os EUA com PRESENCE_OR_INTEREST, mas não enviar para um estado específico, poderá excluir esse estado usando negative=true em um critério LocationInfo. Combinado com negative_geo_target_type definido como PRESENCE, isso impede que seus anúncios sejam mostrados aos usuários nesse estado, mas ainda alcança usuários fora desse estado que possam estar interessados em locais dos EUA.

A seguir

• Ajustar lances por critério no guia Modificadores de lances.