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 modifier le ciblage géographique de vos campagnes.

Pour en savoir plus sur les limites de ciblage, consultez la section Limites de ciblage de À propos des limites de votre 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 zone 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 générer des clics d'utilisateurs situés dans des régions où vous n'avez pas de supermarchés. Cela générerait des coûts sans possibilité de retour sur investissement. Avec le ciblage géographique, vos campagnes ne diffusent des annonces que dans les régions où vos supermarchés sont 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, par région ou par proximité autour d'un point géographique spécifique.

Cibler des campagnes géographiquement pour une région

Vous pouvez cibler des campagnes dans n'importe quelle région géographique pour laquelle Google Ads est compatible avec 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 identifiant de critère à l'aide de GeoTargetConstantService.SuggestGeoTargetConstants. Le resource_name de chaque GeoTargetConstant se présente sous la forme 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 du 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 avec un identifiant 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::V25::Resources::CampaignCriterion->new({
      # Create a location using the specified location ID.
      location => Google::Ads::GoogleAds::V25::Common::LocationInfo->new({
          # Besides using location ID, you can also search by location names
          # using GeoTargetConstantService::suggest() and directly apply
          # GeoTargetConstant->{resourceName} here. An example can be found
          # in get_geo_target_constants_by_names.pl.
          geoTargetConstant =>
            Google::Ads::GoogleAds::V25::Utils::ResourceNames::geo_target_constant(
            $location_id)}
      ),
      campaign => $campaign_resource_name
    });

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

curl

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

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

Key Resources:

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

Google peut parfois supprimer certains critères géographiques 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 emplacement est ENABLED ou REMOVAL_PLANNED.

Rechercher par nom de lieu

Vous pouvez également rechercher l'identifiant de critère par nom de lieu à l'aide de GeoTargetConstantService.SuggestGeoTargetConstants. L'exemple de code suivant montre comment rechercher un identifiant de critère géographique par nom de lieu.

Java

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

    SuggestGeoTargetConstantsRequest.Builder requestBuilder =
        SuggestGeoTargetConstantsRequest.newBuilder();

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

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

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

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

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

C#

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

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

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

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

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

    request.LocationNames.Names.AddRange(locations);

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

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

PHP

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

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

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

Python

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

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

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

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

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

Ruby

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

  gtc_service = client.service.geo_target_constant

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

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

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

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

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

Perl

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

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

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

  return 1;
}
get_geo_target_constants_by_names.pl
      

curl

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

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

Key Resources:

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

Cibler des campagnes par proximité d'un lieu

Il peut arriver que vous souhaitiez cibler une zone plus précisément qu'une ville ou un pays. Par exemple, vous pouvez faire la promotion de vos supermarchés dans un rayon de 10 kilomètres autour 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::V25::Resources::CampaignCriterion->new({
      proximity => Google::Ads::GoogleAds::V25::Common::ProximityInfo->new({
          address => Google::Ads::GoogleAds::V25::Common::AddressInfo->new({
              streetAddress => "38 avenue de l'Opéra",
              cityName      => "cityName",
              postalCode    => "75002",
              countryCode   => "FR"
            }
          ),
          radius => 10.0,
          # Default is kilometers.
          radiusUnits => MILES
        }
      ),
      campaign => $campaign_resource_name
    });

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

curl

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

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

Key Resources:

• Utiliser REST
• Structure de l'interface REST
• Mappages de champs JSON
• Consultez la documentation de référence de l'API REST pour 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. L'inclusion de campaign_criterion.type et campaign_criterion.resource_name dans la clause SELECT vous permet de faire la distinction entre les critères LOCATION et PROXIMITY, et d'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')

Modifier des cibles géographiques

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

1. Interrogez les critères LOCATION et PROXIMITY existants de la campagne à l'aide de la requête GAQL dans Récupérer des cibles géographiques.
2. Comparez les critères existants avec la liste de cibles souhaitée.
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 create renseigné avec le nouveau critère LocationInfo ou ProximityInfo.
5. Transmettez les opérations remove et create dans un seul appel MutateCampaignCriteria pour 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 géographiques d'une campagne Performance Max pour les services locaux, vous recevrez l'erreur CampaignCriterionError.CANNOT_REMOVE_ALL_LOCATIONS_FROM_LOCAL_SERVICES_PMAX_CAMPAIGN.

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, cibler l'ensemble des États-Unis, à l'exception de la ville de New York). Pour exclure une région, définissez le negative champ dans CampaignCriterion sur true.

Cibler plusieurs régions géographiques

Si vous utilisez un LocationGroupInfo, vous pouvez autoriser une campagne à cibler plusieurs régions géographiques centrées sur des zones géographiques définies par des composants Lieu ou filtrées 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 ne peut être combiné avec geo_target_constants.
• Rayon et unités : le rayon de LocationGroupInfo définit une région circulaire autour de chaque zone géographique 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 compatibles sont MILLI_MILES et METERS.
  • Lorsque vous filtrez par geo_target_constants (où au maximum un identifiant de critère est autorisé et où les champs AssetSet ne sont pas définis), les valeurs radius_units compatibles 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 associe les utilisateurs à 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 comporte deux champs :

• positive_geo_target_type: détermine comment les utilisateurs sont associés aux zones géographiques que vous ciblez.
• negative_geo_target_type: détermine comment les utilisateurs sont associés aux 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 PositiveGeoTargetTypeEnum :

• PRESENCE_OR_INTEREST (valeur par défaut recommandée) :

  • Touche les personnes susceptibles de se trouver dans les zones géographiques que vous ciblez ou qui s'y rendent régulièrement, ainsi que les personnes qui ont manifesté un intérêt pour ces zones géographiques.
  • L'intérêt peut être signalé par des termes de recherche, des visites précédentes ou des contenus consommés en lien avec la zone géographique.
  • Cette option offre la couverture la plus large.

• PRESENCE:

  • Ne touche que les personnes susceptibles de se trouver physiquement dans les zones géographiques que vous ciblez ou qui s'y rendent régulièrement.
  • 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 des annonces lorsqu'un utilisateur recherche les zones géographiques que vous ciblez et ne peut être utilisée qu'avec les campagnes sur le Réseau de Recherche et les campagnes Shopping standards.

Paramètres de ciblage par exclusion (negative_geo_target_type)

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

• PRESENCE (valeur par défaut recommandée) :
  • 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 compatible avec le ciblage géographique par exclusion dans la plupart des types de campagnes.

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

Vous pouvez contrôler ces paramètres en modifiant 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 bénéficiez d'un contrôle plus précis sur les personnes qui voient vos annonces en fonction de leur relation avec les emplacements géographiques que vous avez spécifiés, ce qui vous permet de mieux aligner vos campagnes sur vos objectifs commerciaux.

Bonnes pratiques

• Choisissez PRESENCE si votre produit ou service est strictement limité aux personnes physiquement présentes dans une zone. Par exemple, si vous exigez que les utilisateurs soient en magasin ou que vous proposez la livraison locale.
• Choisissez PRESENCE_OR_INTEREST si votre produit ou service peut également profiter aux personnes intéressées par une zone géographique, même si elles ne sont pas physiquement présentes. Par exemple, un utilisateur qui planifie des vacances peut être intéressé par les hôtels de sa ville de destination.
• Utilisez le ciblage géographique par exclusion pour affiner votre 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 à l'aide de negative=true sur un critère LocationInfo. Combiné à negative_geo_target_type défini sur PRESENCE, cela empêche la diffusion de vos annonces auprès des utilisateurs de cet État, tout en touchant les utilisateurs situés en dehors de cet État qui pourraient être intéressés par les zones géographiques des États-Unis.

Étape suivante

• Ajustez les enchères par critère dans le guide Modificateurs d'enchères.