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 applicables à 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ère des coûts sans offrir la possibilité d'un 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 (pays, État, ville ou région postale, par exemple). 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. Le 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 de génération de la demande avec upgraded_targeting activé). L'extrait de code suivant montre comment cibler votre campagne avec 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();
}

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

curl

Google peut parfois supprimer certains critères géographiques pour diverses raisons : restructuration de la zone géographique en zones plus petites ou plus grandes, changements géopolitiques, etc. Consultez le champ status d'un objet GeoTargetConstant pour déterminer si un lieu est ENABLED ou REMOVAL_PLANNED.

Rechercher par nom de lieu

Vous pouvez également rechercher l'ID du critère par nom de lieu à l'aide de GeoTargetConstantService.SuggestGeoTargetConstants. L'exemple de code suivant montre comment rechercher un ID 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());
    }
  }
}

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

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

curl

Cibler les campagnes en fonction de la 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 choisir de promouvoir 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();
}

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

curl

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 les cibles géographiques

Les critères géographiques d'une campagne sont immuables après leur création. Pour mettre à jour les cibles géographiques d'une campagne, vous devez donc 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 les cibles géographiques.
  2. Comparez les critères existants à la liste cible que vous souhaitez utiliser.
  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 zone géographique ou zone de proximité ciblée, 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.

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 la ville 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 qu'elle cible plusieurs régions géographiques centrées sur des lieux 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 ne peuvent pas non plus être combinés 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ù au maximum un 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 associe les utilisateurs à ces zones à l'aide des options de situation géographique avancées. Ces paramètres sont gérés par le biais de Campaign.GeoTargetTypeSetting.

Ce paramètre comprend deux champs :

  • positive_geo_target_type : détermine comment les utilisateurs sont mis en correspondance avec les zones géographiques que vous ciblez.
  • negative_geo_target_type : détermine comment les utilisateurs sont mis en correspondance pour les lieux 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 (par défaut, recommandé) :

    • Permet de toucher les personnes susceptibles de se trouver dans les zones que vous ciblez ou qui s'y rendent régulièrement, ainsi que celles qui ont montré un intérêt pour ces zones.
    • 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 le lieu.
    • Cette option offre la couverture la plus large.

  • PRESENCE :

    • Ne touche que les personnes susceptibles de se trouver physiquement dans les zones ciblées ou qui s'y rendent régulièrement.
    • Cette option est plus restrictive et utile si vos services ou produits sont strictement réservés aux personnes physiquement présentes dans une zone.

Paramètres de ciblage par exclusion (negative_geo_target_type)

Pour les zones géographiques à exclure, vous devez utiliser NegativeGeoTargetTypeEnum :

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

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 contrôlez plus précisément qui voit vos annonces en fonction de sa relation avec les zones géographiques que vous avez spécifiées, ce qui correspond mieux à vos objectifs commerciaux.

Bonnes pratiques

  • Choisissez PRESENCE si votre produit ou service est strictement limité aux personnes physiquement présentes dans un lieu. Par exemple, imaginons que vous exigiez que les utilisateurs soient en magasin ou que vous proposiez la livraison locale.
  • Choisissez PRESENCE_OR_INTEREST si votre produit ou service peut également intéresser les personnes intéressées par un lieu, même si elles ne s'y trouvent pas physiquement. Par exemple, un utilisateur qui prévoit des vacances peut être intéressé par les hôtels de la ville où il se rend.
  • Utilisez les zones géographiques à exclure 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. Si vous combinez ce paramètre avec negative_geo_target_type défini sur PRESENCE, vos annonces ne seront pas diffusées auprès des utilisateurs de cet État, mais vous pourrez toujours toucher les utilisateurs situés en dehors de cet État qui pourraient être intéressés par des lieux aux États-Unis.

Étape suivante

Précédent
Modificateurs d'enchères
Suivant
Paramètres de ciblage