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 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 de la publicité pour une chaîne de supermarchés. Sans ciblage géographique, vos annonces seraient diffusées dans toutes les régions du monde et pourraient recevoir 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 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, région ou proximité autour d'un point géographique spécifique.

Découvrez comment configurer vos annonces pour cibler certaines zones géographiques.

Cibler des campagnes géographiquement pour une région

Vous pouvez cibler des campagnes dans n'importe quelle zone 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 ID 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 de CampaignCriterionService. 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();
}
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::V24::Resources::CampaignCriterion->new({
      # Create a location using the specified location ID.
      location => Google::Ads::GoogleAds::V24::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::V24::Utils::ResourceNames::geo_target_constant(
            $location_id)}
      ),
      campaign => $campaign_resource_name
    });

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

curl

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. Consultez le status champ d'un GeoTargetConstant objet pour déterminer si un emplacement est ENABLED ou REMOVAL_PLANNED.

Rechercher par nom de lieu

Vous pouvez également rechercher l'ID de 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());
    }
  }
}
GetGeoTargetConstantsByNames.java

C#

public void Run(GoogleAdsClient client)
{
    // Get the GeoTargetConstantServiceClient.
    GeoTargetConstantServiceClient geoService =
        client.GetService(Services.V24.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::V24::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

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

Il peut arriver que vous souhaitiez cibler une zone géographique de manière plus précise qu'une ville ou un pays. Par exemple, vous pouvez vouloir faire de la publicité pour 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 zone de proximité ciblée est semblable à celui permettant d'ajouter une cible géographique, sauf que vous devez créer un ProximityInfo objet au lieu d'un LocationInfo objet.

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

curl

Récupérer des cibles géographiques

Vous pouvez récupérer les cibles géographiques d'une campagne à l'aide des GoogleAdsService.SearchStream. Vous pouvez filtrer vos résultats dans la clause WHERE.

SELECT
  campaign_criterion.campaign,
  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.negative
FROM campaign_criterion
WHERE
  campaign_criterion.campaign = 'customers/{customer_id}/campaigns/{campaign_id}'
  AND campaign_criterion.type IN (LOCATION, PROXIMITY)

Mettre à jour des cibles géographiques

Pour mettre à jour les cibles géographiques d'une campagne, vous devez récupérer la liste des cibles géographiques existantes et la comparer à la liste des nouvelles cibles. Vous pouvez ensuite utiliser l'opération remove pour supprimer les cibles dont vous n'avez pas besoin, et l'opération create pour ajouter les nouvelles cibles géographiques dont vous avez besoin (mais qui ne figurent pas dans la campagne existante).

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 être true.

Cibler plusieurs zones géographiques

Si vous utilisez un LocationGroupInfo, vous pouvez permettre à une campagne de cibler plusieurs zones géographiques. Une région est centrée sur les établissements définis par les extensions de lieu de la campagne.

Le rayon défini sur le LocationGroupInfo attribue une région circulaire autour de chaque établissement et se compose d'un radius objet, d'une longueur et d' radius_units, qui peuvent être des mètres ou des miles avec LocationGroupRadiusUnitsEnum.

Les établissements d'un LocationGroupInfo peuvent être filtrés par une liste d'ID de critères de ciblage géographique prescrits dans le geo_target_constant field. Si cette option est définie, aucun établissement en dehors des ID de critères donnés ne sera ciblé.

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

  1. PRESENCE_OR_INTEREST (par défaut recommandé) :

    • Touche les personnes susceptibles de se trouver dans les zones géographiques ciblées ou d'y résider régulièrement, PLUS les personnes qui ont manifesté 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 la zone géographique.
    • Cette option offre la plus large couverture.

  2. PRESENCE:

    • Ne touche que les personnes susceptibles de se trouver physiquement dans les zones géographiques ciblées ou d'y résider 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 : D'autres valeurs telles que SEARCH_INTEREST sont obsolètes et ne peuvent plus être définies pour la plupart des types de campagnes.

Paramètres de ciblage par exclusion (negative_geo_target_type)

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

  1. 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 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 mettant à jour l'objet Campaign.geo_target_type_setting.

Exemple : Définir une campagne pour qu'elle ne cible que par PRESENCE

Voici un exemple conceptuel de la façon dont vous pouvez structurer un appel d'API pour modifier le positive_geo_target_type. Le code exact varie en fonction du langage de la bibliothèque cliente.

// 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 if not specified
    }
  }
  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 zones géographiques que vous avez spécifiées, 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 géographique. Par exemple, si vous exigez que les utilisateurs soient en magasin ou que la livraison soit 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 s'y trouvent pas physiquement. Par exemple, un utilisateur qui planifie des vacances peut être intéressé par les hôtels de sa ville de destination.
  • 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. 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

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