Segmentación geográfica

En esta guía, se describe la segmentación geográfica y cómo puedes usar la API de Google Ads para agregar, recuperar y actualizar la segmentación geográfica de tus campañas.

Para obtener información sobre los límites de segmentación, consulta la sección Límites de segmentación del artículo Acerca de los límites de la cuenta de Google Ads.

¿Por qué es importante la segmentación geográfica?

La segmentación geográfica te permite publicar anuncios para los usuarios de una región geográfica determinada. Por ejemplo, supongamos que publicas anuncios para una cadena de supermercados. Sin la segmentación geográfica, tus anuncios se mostrarían en todas las regiones del mundo y podrían recibir clics de usuarios que se encuentran en regiones donde no tienes supermercados. Esto genera costos, pero no ofrece ninguna posibilidad de obtener un retorno de la inversión. Con la segmentación geográfica, tus campañas muestran anuncios solo en las regiones donde tienes supermercados abiertos. Este enfoque también te permite segmentar tus anuncios directamente para los clientes que buscan supermercados de forma local.

La API de Google Ads te permite segmentar tus anuncios por país, región o proximidad en torno a un punto geográfico específico.

Segmenta geográficamente las campañas para una región

Puedes segmentar las campañas para cualquier región geográfica en la que Google Ads admita la segmentación geográfica, como un país, un estado, una ciudad o una región postal. Cada ubicación segmentable se identifica de forma única con un ID de criterio. Puedes buscar un ID de criterio con GeoTargetConstantService.SuggestGeoTargetConstants. El resource_name de cada GeoTargetConstant tiene el formato geoTargetConstants/{Criterion ID}. Por ejemplo, el valor resource_name del estado de Nueva York es geoTargetConstants/21167.

Puedes agregar regiones geográficas de segmentación a tus campañas con CampaignCriterionService (o a nivel del grupo de anuncios con AdGroupCriterion para los tipos de campañas compatibles, como las campañas de generación de demanda con upgraded_targeting habilitado). En el siguiente fragmento de código, se muestra cómo segmentar tu campaña con un ID de criterio.

Java

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

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

  return criterionBuilder.build();
}

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

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]);
}

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

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

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
    });
}

curl

En ocasiones, Google puede eliminar gradualmente algunos criterios de ubicación por varios motivos: la ubicación puede reestructurarse en áreas más pequeñas o más grandes, cambios geopolíticos, etcétera. Consulta el campo status de un objeto GeoTargetConstant para determinar si una ubicación es ENABLED o REMOVAL_PLANNED.

Buscar por nombre de ubicación

También puedes buscar el ID del criterio por nombre de ubicación con GeoTargetConstantService.SuggestGeoTargetConstants. En el siguiente ejemplo de código, se muestra cómo buscar un ID de criterio de ubicación por nombre de ubicación.

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

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;
    }
}

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
        );
    }
}

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

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

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;
}

curl

Cómo segmentar las campañas para que se muestren cerca de una ubicación

En ocasiones, es posible que desees segmentar tus anuncios con mayor precisión que por ciudad o país. Por ejemplo, es posible que quieras promocionar tus supermercados en un radio de 10 kilómetros de la ubicación de tu tienda. En esos casos, puedes usar la segmentación por proximidad. El código para crear una segmentación por proximidad es similar al que se usa para agregar una segmentación geográfica, excepto que debes crear un objeto ProximityInfo en lugar de un 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();
}

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
    };
}

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]);
}

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

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

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
    });
}

curl

Recupera las regiones geográficas de segmentación

Puedes recuperar las regiones geográficas de segmentación de una campaña con GoogleAdsService.SearchStream. Incluir campaign_criterion.type y campaign_criterion.resource_name en la cláusula SELECT te permite distinguir entre los criterios LOCATION y PROXIMITY, y registrar los nombres de los recursos para las actualizaciones o eliminaciones posteriores.

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

Actualiza las regiones geográficas de segmentación

Los criterios de ubicación de una campaña son inmutables después de su creación, por lo que, para actualizar las segmentaciones geográficas de una campaña, se deben reemplazar las segmentaciones obsoletas por otras nuevas en una sola solicitud CampaignCriterionService.MutateCampaignCriteria atómica:

  1. Consulta los criterios LOCATION y PROXIMITY existentes de la campaña con la consulta de GAQL en Recupera las ubicaciones de segmentación geográfica.
  2. Compara los criterios existentes con la lista de segmentación que deseas utilizar.
  3. Para cada criterio obsoleto, compila un CampaignCriterionOperation con remove establecido en el resource_name del criterio existente.
  4. Para cada ubicación o segmentación por proximidad nueva, crea un objeto CampaignCriterionOperation con un objeto create propagado con el nuevo criterio LocationInfo o ProximityInfo.
  5. Pasa las operaciones remove y create en una sola llamada a MutateCampaignCriteria para que la transición se realice de forma atómica.

Excluye ubicaciones geográficas de segmentación

También puedes excluir LocationInfo, pero no ProximityInfo. Esta función es más útil si deseas segmentar tus anuncios para una región, pero excluir una subregión (por ejemplo, para segmentar tus anuncios para todo Estados Unidos, excepto la ciudad de Nueva York). Para excluir una región, establece el campo negative en CampaignCriterion en true.

Segmentar anuncios para varias regiones geográficas

Si usas un LocationGroupInfo, puedes habilitar una campaña para segmentarla para varias regiones geográficas centradas en ubicaciones definidas por recursos de ubicación o filtradas por una región geográfica:

  • Conjuntos de recursos de ubicación: Establece enable_customer_level_location_asset_set = true (para segmentar los anuncios para el conjunto de recursos de ubicación del cliente) o location_group_asset_sets (para segmentar los anuncios para nombres de recursos de AssetSet específicos). Estos dos campos no se pueden configurar juntos, y tampoco se pueden combinar con geo_target_constants.
  • Radio y unidades: El radio en LocationGroupInfo define una región circular alrededor de cada ubicación y requiere radius y radius_units (LocationGroupRadiusUnitsEnum):
    • Cuando se usan conjuntos de recursos de ubicación (enable_customer_level_location_asset_set o location_group_asset_sets), los valores de radius_units admitidos son MILLI_MILES y METERS.
    • Cuando se filtra por geo_target_constants (donde se permite como máximo un ID de criterio y no se establecen los campos AssetSet), los valores de radius_units admitidos son MILES y METERS.

Opciones de ubicación avanzadas con GeoTargetTypeSetting

Además de especificar las ubicaciones que deseas incluir o excluir en la segmentación, puedes definir mejor cómo Google Ads asocia a los usuarios con estas ubicaciones a través de las opciones de ubicación avanzadas. Estos parámetros de configuración se administran a través de Campaign.GeoTargetTypeSetting.

Este parámetro de configuración consta de dos campos:

  • positive_geo_target_type: Determina cómo se asocian los usuarios con las ubicaciones que segmentas.
  • negative_geo_target_type: Determina cómo se segmentan los anuncios para los usuarios en función de las ubicaciones que excluyes.

Configuración de la segmentación positiva (positive_geo_target_type)

Puedes elegir entre las siguientes opciones para tu segmentación geográfica positiva con los valores de PositiveGeoTargetTypeEnum:

  • PRESENCE_OR_INTEREST (opción predeterminada recomendada):

    • Llega a las personas que es probable que se encuentren o suelan estar en tus ubicaciones de segmentación, así como a aquellas que muestran interés en estas regiones.
    • El interés se puede indicar mediante términos de búsqueda, visitas anteriores o contenido consumido relacionado con la ubicación.
    • Esta opción proporciona el alcance más amplio.

  • PRESENCE

    • Llega solo a las personas que probablemente se encuentren o suelan encontrarse en tus ubicaciones de segmentación.
    • Esta opción es más restrictiva y útil si tus servicios o productos se limitan estrictamente a las personas que se encuentran físicamente en un área.

Configuración de la segmentación negativa (negative_geo_target_type)

En el caso de las ubicaciones que quieras excluir, usa el campo NegativeGeoTargetTypeEnum:

  • PRESENCE (predeterminado recomendado):
    • Excluye a las personas que probablemente se encuentren en las ubicaciones que excluiste.
    • Las personas que se encuentren fuera de las áreas excluidas, incluso si están interesadas en ellas, podrían ver tus anuncios, siempre que coincidan con tu segmentación positiva.

Cómo administrar las opciones avanzadas de ubicación

Puedes controlar estos parámetros de configuración actualizando el objeto Campaign.geo_target_type_setting. En el siguiente ejemplo, se muestra la estructura de una actualización de CampaignOperation que establece positive_geo_target_type en 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 recuperar la configuración actual, incluye campaign.geo_target_type_setting.positive_geo_target_type y campaign.geo_target_type_setting.negative_geo_target_type en tu búsqueda de GoogleAdsService.

Si configuras estos parámetros, obtendrás un control más detallado sobre quién ve tus anuncios en función de su relación con las ubicaciones geográficas que especificaste, lo que te permitirá alinearte más con tus objetivos comerciales.

Prácticas recomendadas

  • Elige PRESENCE si tu producto o servicio se limita estrictamente a las personas que se encuentran físicamente en una ubicación. Por ejemplo, supongamos que exiges que los usuarios estén en la tienda o que requieres la entrega local.
  • Elige PRESENCE_OR_INTEREST si tu producto o servicio también puede beneficiar a las personas interesadas en una ubicación, incluso si no están presentes físicamente. Por ejemplo, un usuario que planea unas vacaciones podría estar interesado en hoteles en su ciudad de destino.
  • Utiliza la segmentación geográfica negativa para definir mejor el alcance. Si segmentas tus anuncios para EE.UU. con PRESENCE_OR_INTEREST, pero no realizas envíos a un estado específico, puedes excluir ese estado con negative=true en un criterio LocationInfo. Si se combina con el parámetro negative_geo_target_type establecido en PRESENCE, se evita que tus anuncios se muestren a los usuarios de ese estado, pero se llega a los usuarios que se encuentran fuera de ese estado y que podrían estar interesados en ubicaciones de EE.UU.

¿Qué sigue?

Anterior
Modificadores de puja
Siguiente
Ajustes de segmentación