Ciblage géographique

Ce guide décrit le ciblage géographique et explique comment utiliser l'API Google Ads pour ajouter, récupérer et mettre à jour le ciblage géographique de vos campagnes.

Pour en savoir plus sur les limites de ciblage, consultez la section "Limites de ciblage" de l'article À propos des limites du compte Google Ads.

Pourquoi le ciblage géographique est-il important ?

Le ciblage géographique vous permet de diffuser des annonces auprès des utilisateurs d'une région géographique spécifique. Par exemple, supposons que vous faites la promotion d'une chaîne de supermarchés. Sans ciblage géographique, vos annonces seraient diffusées dans toutes les régions du monde et pourraient enregistrer des clics d'utilisateurs situés dans des régions où vous ne possédez pas de supermarché. Cela génère des coûts sans aucune possibilité de retour sur investissement. Grâce au ciblage géographique, vos campagnes ne diffusent des annonces que dans les régions où vous avez des supermarchés ouverts. Cette approche vous permet également de cibler directement les clients qui recherchent des supermarchés à proximité.

L'API Google Ads vous permet de cibler vos annonces par pays, région ou proximité autour d'un point géographique spécifique.

Cibler géographiquement des campagnes pour une région

Vous pouvez cibler vos campagnes sur n'importe quelle région géographique pour laquelle Google Ads accepte le ciblage géographique, comme un pays, un État, une ville ou une région postale. Chaque emplacement pouvant être ciblé est identifié de façon unique par un identifiant de critère. Vous pouvez rechercher un ID de critère à l'aide de GeoTargetConstantService.SuggestGeoTargetConstants. La valeur resource_name de chaque GeoTargetConstant est au format geoTargetConstants/{Criterion ID}. Par exemple, la valeur resource_name de l'État de New York est geoTargetConstants/21167.

Vous pouvez ajouter des cibles géographiques à vos campagnes à l'aide de CampaignCriterionService (ou au niveau du groupe d'annonces à l'aide de AdGroupCriterion pour les types de campagnes compatibles, comme les campagnes Demand Gen avec upgraded_targeting activé). L'extrait de code suivant montre comment cibler votre campagne à l'aide d'un ID de critère.

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

Remarque : Bien qu'aucun exemple de code REST direct ne soit fourni ici pour cette étape, vous pouvez effectuer cette opération à l'aide d'une requête REST manuelle.

Consultez la documentation sur l'interface REST de l'API Google Ads et les pages de référence spécifiques aux méthodes. Vous devrez créer la charge utile JSON en fonction des définitions proto.

Ressources clés :

• Utiliser REST
• Structure de l'interface REST
• Mappages de champs JSON
• Consultez la documentation de référence de l'API REST pour connaître le service et la méthode spécifiques.

Google peut parfois supprimer certains critères de localisation pour diverses raisons : la zone géographique peut être restructurée en zones plus petites ou plus grandes, des changements géopolitiques peuvent survenir, etc. Reportez-vous au champ status d'un objet GeoTargetConstant pour déterminer si un établissement est ENABLED ou REMOVAL_PLANNED.

Rechercher par nom de lieu

Vous pouvez également rechercher l'ID de critère par nom de zone géographique à l'aide de GeoTargetConstantService.SuggestGeoTargetConstants. L'exemple de code suivant montre comment rechercher l'ID d'un critère de zone géographique à l'aide du nom de la zone géographique.

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

Remarque : Bien qu'aucun exemple de code REST direct ne soit fourni ici pour cette étape, vous pouvez effectuer cette opération à l'aide d'une requête REST manuelle.

Consultez la documentation sur l'interface REST de l'API Google Ads et les pages de référence spécifiques aux méthodes. Vous devrez créer la charge utile JSON en fonction des définitions proto.

Ressources clés :

• Utiliser REST
• Structure de l'interface REST
• Mappages de champs JSON
• Consultez la documentation de référence de l'API REST pour connaître le service et la méthode spécifiques.

Cibler des campagnes en fonction de la proximité d'un lieu

Il peut arriver que vous souhaitiez cibler une zone encore plus précise qu'une ville ou un pays. Par exemple, vous pouvez promouvoir vos supermarchés dans un rayon de 10 kilomètres autour de l'emplacement de votre magasin. Dans ce cas, vous pouvez utiliser le ciblage par proximité. Le code permettant de créer une cible de proximité est semblable à celui permettant d'ajouter une cible géographique, sauf que vous devez créer un objet ProximityInfo au lieu d'un objet 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

Remarque : Bien qu'aucun exemple de code REST direct ne soit fourni ici pour cette étape, vous pouvez effectuer cette opération à l'aide d'une requête REST manuelle.

Consultez la documentation sur l'interface REST de l'API Google Ads et les pages de référence spécifiques aux méthodes. Vous devrez créer la charge utile JSON en fonction des définitions proto.

Ressources clés :

• Utiliser REST
• Structure de l'interface REST
• Mappages de champs JSON
• Consultez la documentation de référence de l'API REST pour connaître le service et la méthode spécifiques.

Récupérer des cibles géographiques

Vous pouvez récupérer les cibles géographiques d'une campagne à l'aide de GoogleAdsService.SearchStream. En incluant campaign_criterion.type et campaign_criterion.resource_name dans la clause SELECT, vous pouvez distinguer les critères LOCATION et PROXIMITY, et enregistrer les noms de ressources pour les mises à jour ou les suppressions ultérieures.

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

Mettre à jour les cibles géographiques

Les critères de zone géographique d'une campagne sont immuables après leur création. Par conséquent, pour mettre à jour les cibles géographiques d'une campagne, vous devez remplacer les cibles obsolètes par de nouvelles cibles dans une seule requête CampaignCriterionService.MutateCampaignCriteria atomique :

1. Interrogez les critères LOCATION et PROXIMITY existants de la campagne à l'aide de la requête GAQL dans Récupérer les cibles géographiques.
2. Comparez les critères existants avec votre liste de cibles prévue.
3. Pour chaque critère obsolète, créez un CampaignCriterionOperation avec remove défini sur le resource_name du critère existant.
4. Pour chaque nouvelle cible géographique ou de proximité, créez un CampaignCriterionOperation avec un create renseigné avec le nouveau critère LocationInfo ou ProximityInfo.
5. Transmettez les opérations remove et create dans un seul appel MutateCampaignCriteria afin que la transition se produise de manière atomique.

Remarque : Dans la version 24 et les versions ultérieures, si vous tentez de supprimer tous les critères de zone géographique d'une campagne Performance Max pour les annonces Local Services, l'erreur CampaignCriterionError.CANNOT_REMOVE_ALL_LOCATIONS_FROM_LOCAL_SERVICES_PMAX_CAMPAIGN est renvoyée.

Exclure des cibles géographiques

Vous pouvez également exclure LocationInfo, mais pas ProximityInfo. Cette fonctionnalité est particulièrement utile si vous souhaitez cibler une région, mais exclure une sous-région (par exemple, pour cibler l'ensemble des États-Unis, à l'exception de New York). Pour exclure une région, définissez le champ negative dans CampaignCriterion sur true.

Cibler plusieurs régions géographiques

Si vous utilisez un LocationGroupInfo, vous pouvez activer une campagne pour cibler plusieurs régions géographiques centrées sur des emplacements définis par des composants Lieu ou filtrés par une région géographique :

• Ensembles de composants Lieu : définissez enable_customer_level_location_asset_set = true (pour cibler l'ensemble de composants Lieu du client) ou location_group_asset_sets (pour cibler des noms de ressources AssetSet spécifiques). Ces deux champs ne peuvent pas être définis ensemble, et aucun d'eux ne peut être combiné avec geo_target_constants.
• Rayon et unités : le rayon sur LocationGroupInfo définit une région circulaire autour de chaque emplacement et nécessite à la fois radius et radius_units (LocationGroupRadiusUnitsEnum) :
  • Lorsque vous utilisez des ensembles de composants Lieu (enable_customer_level_location_asset_set ou location_group_asset_sets), les valeurs radius_units acceptées sont MILLI_MILES et METERS.
  • Lorsque vous filtrez par geo_target_constants (où un seul ID de critère est autorisé et où les champs AssetSet ne sont pas définis), les valeurs radius_units acceptées sont MILES et METERS.

Options de ciblage géographique avancées avec GeoTargetTypeSetting

En plus de spécifier les zones géographiques à cibler ou à exclure, vous pouvez affiner la façon dont Google Ads met en correspondance les utilisateurs avec ces zones géographiques à l'aide des options de ciblage géographique avancées. Ces paramètres sont gérés via Campaign.GeoTargetTypeSetting.

Ce paramètre se compose de deux champs :

• positive_geo_target_type : détermine la façon dont les utilisateurs sont mis en correspondance avec les zones géographiques que vous ciblez.
• negative_geo_target_type : détermine la façon dont les utilisateurs sont mis en correspondance avec les zones géographiques que vous excluez.

Paramètres de ciblage positif (positive_geo_target_type)

Vous pouvez choisir parmi les options suivantes pour votre ciblage géographique positif, en utilisant les valeurs de la colonne PositiveGeoTargetTypeEnum :

• PRESENCE_OR_INTEREST (par défaut, recommandé) :

  • Touchez les personnes susceptibles de se trouver dans les zones que vous ciblez ou qui s'y rendent régulièrement, ainsi que celles qui sont intéressées par ces zones.
  • L'intérêt peut être signalé par des termes de recherche, des visites passées ou des contenus consultés en lien avec le lieu.
  • Cette option offre la couverture la plus large.

• PRESENCE :

  • Cette option ne touche que les personnes susceptibles de se trouver physiquement ou régulièrement dans les zones que vous ciblez.
  • Cette option est plus restrictive et utile si vos services ou produits sont strictement limités aux personnes physiquement présentes dans une zone.

Remarque : La valeur SEARCH_INTEREST déclenche la diffusion d'annonces lorsqu'un utilisateur recherche vos zones ciblées. Elle ne peut être utilisée qu'avec les campagnes Shopping standards et sur le Réseau de Recherche.

Paramètres de ciblage par exclusion (negative_geo_target_type)

Pour les zones géographiques que vous souhaitez exclure, utilisez NegativeGeoTargetTypeEnum :

• PRESENCE (par défaut, recommandé) :
  • Exclut les personnes susceptibles de se trouver physiquement dans les zones géographiques que vous avez exclues.
  • Les personnes situées en dehors des zones exclues, même si elles s'y intéressent, peuvent toujours voir vos annonces, à condition qu'elles correspondent à votre ciblage positif.

Remarque : La valeur PRESENCE_OR_INTEREST n'est généralement pas acceptée pour le ciblage géographique négatif dans la plupart des types de campagnes.

Gérer les options avancées de ciblage géographique

Vous pouvez contrôler ces paramètres en mettant à jour l'objet Campaign.geo_target_type_setting. L'exemple suivant montre la structure d'une mise à jour CampaignOperation qui définit positive_geo_target_type sur 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"
  }
}

Pour récupérer les paramètres actuels, incluez campaign.geo_target_type_setting.positive_geo_target_type et campaign.geo_target_type_setting.negative_geo_target_type dans votre requête de recherche GoogleAdsService.

En configurant ces paramètres, vous pouvez contrôler plus précisément qui voit vos annonces en fonction de leur relation avec les emplacements géographiques que vous avez spécifiés, ce qui vous permet de mieux vous aligner sur vos objectifs commerciaux.

Bonnes pratiques

• Choisissez PRESENCE si votre produit ou service est strictement limité aux personnes physiquement présentes dans une zone géographique. Par exemple, supposons que vous demandiez aux utilisateurs d'être en magasin ou que vous proposiez la livraison locale.
• Choisissez PRESENCE_OR_INTEREST si votre produit ou service peut également intéresser les personnes qui s'intéressent à une zone géographique, même si elles ne s'y trouvent pas physiquement. Par exemple, un utilisateur qui planifie des vacances peut être intéressé par les hôtels de la ville de destination.
• Utilisez le ciblage géographique par exclusion pour affiner la couverture. Si vous ciblez les États-Unis avec PRESENCE_OR_INTEREST, mais que vous ne livrez pas dans un État spécifique, vous pouvez exclure cet État en utilisant negative=true sur un critère LocationInfo. Si vous définissez également negative_geo_target_type sur PRESENCE, vos annonces ne seront pas diffusées auprès des utilisateurs de cet État, mais elles toucheront toujours les utilisateurs situés en dehors de cet État qui pourraient être intéressés par des zones géographiques aux États-Unis.

Étape suivante

• Ajustez les enchères par critère en suivant le guide sur les modificateurs d'enchères.