Segmentação por local

Este guia descreve a segmentação por local e o modo de usar a Google Ads API 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" de Sobre os limites da conta do Google Ads.

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

Com a segmentação por local, você pode veicular anúncios para usuários em uma região geográfica específica. Por exemplo, imagine que você esteja anunciando uma rede de supermercados. Sem a segmentação por local, seus anúncios seriam exibidos 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 nas regiões em que você tem supermercados abertos. Essa abordagem também permite segmentar diretamente os clientes que pesquisam supermercados na região.

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

Segmentar campanhas por área geográfica para uma região

É possível segmentar campanhas para qualquer região geográfica que aceite a segmentação por local do Google Ads, como um país, um estado, uma cidade ou uma região postal. Cada local segmentável é identificado de forma exclusiva por um ID de critério. É possível procurar um ID de critério usando GeoTargetConstantService.SuggestGeoTargetConstants. O resource_name de cada GeoTargetConstant está no formato geoTargetConstants/{Criterion ID}. Por exemplo, o valor resource_name do estado de Nova York é geoTargetConstants/21167.

É possível 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::V26::Resources::CampaignCriterion->new({
      # Create a location using the specified location ID.
      location => Google::Ads::GoogleAds::V26::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::V26::Utils::ResourceNames::geo_target_constant(
            $location_id)}
      ),
      campaign => $campaign_resource_name
    });

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

curl

Observação: embora não seja fornecido um exemplo de código REST direto para esta etapa, é possível 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 de proto.

Principais recursos:

• Como 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, ocasionalmente, descontinuar 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 é ENABLED ou REMOVAL_PLANNED.

Pesquisar pelo nome do local

Também é possível pesquisar o ID do critério por nome de local usando GeoTargetConstantService.SuggestGeoTargetConstants. O exemplo de código a seguir mostra como procurar um ID de critério de local pelo nome do local.

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.V26.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::V26::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 não seja fornecido um exemplo de código REST direto para esta etapa, é possível 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 de proto.

Principais recursos:

• Como 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 com ainda mais precisão do que uma cidade ou um país. Por exemplo, talvez você queira anunciar seus supermercados em um raio de 10 quilômetros do local da loja. Nesses casos, use a segmentação por proximidade. O código para criar uma segmentação por proximidade é semelhante ao de adicionar uma segmentação por local, mas você precisa criar um objeto ProximityInfo em vez de um objeto LocationInfo.

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::V26::Resources::CampaignCriterion->new({
      proximity => Google::Ads::GoogleAds::V26::Common::ProximityInfo->new({
          address => Google::Ads::GoogleAds::V26::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::V26::Services::CampaignCriterionService::CampaignCriterionOperation
    ->new({
      create => $campaign_criterion
    });
}
add_campaign_targeting_criteria.pl
      

curl

Observação: embora não seja fornecido um exemplo de código REST direto para esta etapa, é possível 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 de proto.

Principais recursos:

• Como 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

É possível recuperar as segmentações por área geográfica de uma campanha usando GoogleAdsService.SearchStream. Incluir campaign_criterion.type e campaign_criterion.resource_name na cláusula SELECT permite distinguir entre os critérios LOCATION e PROXIMITY e registrar os nomes dos 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, para atualizar as segmentações por área geográfica de uma campanha, é necessário substituir as segmentações obsoletas por novas em uma única solicitação atômica CampaignCriterionService.MutateCampaignCriteria:

1. Consulte os critérios LOCATION e PROXIMITY da campanha usando a consulta da 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 um CampaignCriterionOperation com remove definido como o resource_name do critério atual.
4. Para cada novo local ou segmentação por proximidade, crie um 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 em versões mais recentes, tentar remover todos os critérios de local de uma campanha Performance Max para Serviços Locais retorna CampaignCriterionError.CANNOT_REMOVE_ALL_LOCATIONS_FROM_LOCAL_SERVICES_PMAX_CAMPAIGN.

Excluir segmentações por área geográfica

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 todo o Brasil, exceto a cidade de São Paulo). Para excluir uma região, defina o campo negative 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 centralizadas em locais definidos por recursos de local ou filtrados 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 ao redor de cada local e requer 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 de 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 de radius_units compatíveis são MILES e METERS.

Opções de local avançadas com GeoTargetTypeSetting

Além de especificar os locais que você quer segmentar ou excluir, é possível refinar como o Google Ads associa os usuários a esses locais usando as opções de local avançadas. Essas configurações são gerenciadas pelo Campaign.GeoTargetTypeSetting.

Essa configuração consiste em dois campos:

• positive_geo_target_type: determina como os usuários são correspondidos aos locais que você segmenta.
• negative_geo_target_type: determina como os usuários são correspondidos para 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 por local positiva, usando valores de PositiveGeoTargetTypeEnum:

• PRESENCE_OR_INTEREST (padrão recomendado):

  • Alcança pessoas que provavelmente estão ou costumam estar nas suas regiões de segmentação, além de pessoas que demonstraram interesse nessas regiões.
  • O interesse pode ser indicado por termos de pesquisa, visitas anteriores ou conteúdo consumido relacionado ao local.
  • Essa opção oferece o maior alcance.

• PRESENCE:

  • Alcança apenas pessoas que provavelmente estão fisicamente ou com frequência nas suas regiões de segmentação.
  • Essa opção é mais restritiva e útil se os serviços ou produtos são 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 padrão do Shopping.

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

Para locais que você quer excluir, use NegativeGeoTargetTypeEnum:

• PRESENCE (padrão recomendado):
  • Exclui as pessoas que provavelmente estão nos locais que você excluiu.
  • As pessoas fora das áreas excluídas, mesmo que estejam interessadas nelas, ainda poderão 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 avançadas de local

Para controlar essas configurações, atualize 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 sua consulta de pesquisa GoogleAdsService.

Ao definir essas configurações, você tem um controle mais granular sobre quem vê seus anúncios com base na relação com as localizações geográficas especificadas, o que se alinha melhor à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, imagine que você exige que os usuários estejam na loja ou que a entrega seja 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 está planejando as férias pode ter interesse em hotéis na cidade de destino.
• Use a segmentação por local negativo 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 para usuários nesse estado, mas ainda alcança usuários fora dele que possam estar interessados em locais dos EUA.

A seguir

• Ajuste os lances por critério no guia de modificadores de lances.