Targeting per località

Questa guida descrive il targeting per località e come utilizzare l'API Google Ads per aggiungere, recuperare e aggiornare il targeting per località per le tue campagne.

Per informazioni sui limiti di targeting, consulta la sezione Limiti di targeting dell'articolo Informazioni sui limiti dell'account Google Ads.

Perché il geotargeting è importante?

Il targeting per località ti consente di pubblicare annunci per gli utenti di una determinata regione geografica. Supponiamo, ad esempio, che tu stia facendo pubblicità per una catena di supermercati. Senza il targeting per località, i tuoi annunci verranno mostrati in tutte le regioni del mondo e potrebbero ricevere clic da utenti di regioni in cui non hai supermercati. Ciò genera costi senza offrire alcuna possibilità di ritorno sull'investimento. Con il targeting per località, le tue campagne mostrano annunci solo nelle regioni in cui hai supermercati aperti. Questo approccio ti consente anche di scegliere come target diretto i clienti che cercano supermercati a livello locale.

L'API Google Ads ti consente di scegliere come target dei tuoi annunci un paese, una regione o una prossimità intorno a un punto geografico specifico.

Campagne con targeting geografico per una regione

Puoi scegliere come target delle campagne qualsiasi regione geografica per la quale Google Ads supporta il targeting per località, ad esempio un paese, uno stato, una città o una regione postale. Ogni località selezionabile come target è identificata in modo univoco da un ID criterio. Puoi cercare l'ID di un criterio utilizzando GeoTargetConstantService.SuggestGeoTargetConstants. Il resource_name di ogni GeoTargetConstant è della forma geoTargetConstants/{Criterion ID}. Ad esempio, il valore resource_name dello stato di New York è geoTargetConstants/21167.

Puoi aggiungere località target alle tue campagne utilizzando CampaignCriterionService (o a livello di gruppo di annunci utilizzando AdGroupCriterion per i tipi di campagna supportati, come le campagne Demand Gen con upgraded_targeting attivato). Il seguente snippet di codice mostra come scegliere come target la campagna con un ID criterio.

Java

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

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

  return criterionBuilder.build();
}

C#

private CampaignCriterion buildLocationCriterion(long locationId,
    string campaignResourceName)
{
    GeoTargetConstantName location = new GeoTargetConstantName(locationId.ToString());
    return new CampaignCriterion()
    {
        Campaign = campaignResourceName,
        Location = new LocationInfo()
        {
            GeoTargetConstant = location.ToString()
        }
    };
}

PHP

private static function createLocationCampaignCriterionOperation(
    int $locationId,
    string $campaignResourceName
) {
    // Constructs a campaign criterion for the specified campaign ID using the specified
    // location ID.
    $campaignCriterion = new CampaignCriterion([
        // Creates a location using the specified location ID.
        'location' => new LocationInfo([
            // Besides using location ID, you can also search by location names using
            // GeoTargetConstantServiceClient::suggestGeoTargetConstants() and directly
            // apply GeoTargetConstant::$resourceName here. An example can be found
            // in GetGeoTargetConstantByNames.php.
            'geo_target_constant' => ResourceNames::forGeoTargetConstant($locationId)
        ]),
        'campaign' => $campaignResourceName
    ]);

    return new CampaignCriterionOperation(['create' => $campaignCriterion]);
}

Python

def create_location_op(
    client: GoogleAdsClient,
    customer_id: str,
    campaign_id: str,
    location_id: str,
) -> CampaignCriterionOperation:
    campaign_service: CampaignServiceClient = client.get_service(
        "CampaignService"
    )
    geo_target_constant_service: GeoTargetConstantServiceClient = (
        client.get_service("GeoTargetConstantService")
    )

    # Create the campaign criterion.
    campaign_criterion_operation: CampaignCriterionOperation = client.get_type(
        "CampaignCriterionOperation"
    )
    campaign_criterion: CampaignCriterion = campaign_criterion_operation.create
    campaign_criterion.campaign = campaign_service.campaign_path(
        customer_id, campaign_id
    )

    # Besides using location_id, you can also search by location names from
    # GeoTargetConstantService.suggest_geo_target_constants() and directly
    # apply GeoTargetConstant.resource_name here. An example can be found
    # in get_geo_target_constant_by_names.py.
    campaign_criterion.location.geo_target_constant = (
        geo_target_constant_service.geo_target_constant_path(location_id)
    )

    return campaign_criterion_operation

Ruby

def create_location(client, customer_id, campaign_id, location_id)
  client.operation.create_resource.campaign_criterion do |criterion|
    criterion.campaign = client.path.campaign(customer_id, campaign_id)

    criterion.location = client.resource.location_info do  |li|
      # Besides using location_id, you can also search by location names from
      # GeoTargetConstantService.suggest_geo_target_constants() and directly
      # apply GeoTargetConstant.resource_name here. An example can be found
      # in get_geo_target_constant_by_names.rb.
      li.geo_target_constant = client.path.geo_target_constant(location_id)
    end
  end
end

Perl

sub create_location_campaign_criterion_operation {
  my ($location_id, $campaign_resource_name) = @_;

  # Construct a campaign criterion for the specified campaign using the
  # specified location ID.
  my $campaign_criterion =
    Google::Ads::GoogleAds::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 potrebbe ritirare occasionalmente alcuni criteri di località per vari motivi: la località potrebbe essere ristrutturata in aree più piccole o più grandi, cambiamenti geopolitici e così via. Fai riferimento al campo status di un oggetto GeoTargetConstant per determinare se una località è ENABLED o REMOVAL_PLANNED.

Cercare per nome della località

Puoi anche cercare l'ID criterio in base al nome della località utilizzando GeoTargetConstantService.SuggestGeoTargetConstants. Il seguente esempio di codice mostra come cercare un ID criterio di località in base al nome della località.

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

Scegliere come target le campagne in base alla prossimità a una località

A volte potresti voler scegliere come target un'area ancora più precisa di una città o un paese. Ad esempio, potresti voler pubblicizzare i tuoi supermercati entro 10 chilometri dalla sede del tuo negozio. In questi casi, puoi utilizzare il targeting per prossimità. Il codice per creare un target di prossimità è simile a quello per aggiungere un target di località, tranne per il fatto che devi creare un oggetto ProximityInfo anziché un oggetto 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

Recuperare i target geografici

Puoi recuperare i target geografici per una campagna utilizzando GoogleAdsService.SearchStream. L'inclusione di campaign_criterion.type e campaign_criterion.resource_name nella clausola SELECT consente di distinguere tra i criteri LOCATION e PROXIMITY e registrare i nomi delle risorse per aggiornamenti o rimozioni successivi.

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

Aggiorna i target geografici

I criteri di località di una campagna sono immutabili dopo la creazione, pertanto l'aggiornamento dei target geografici di una campagna richiede la sostituzione dei target obsoleti con quelli nuovi in una singola richiesta CampaignCriterionService.MutateCampaignCriteria atomica:

  1. Esegui una query sui criteri LOCATION e PROXIMITY esistenti della campagna utilizzando la query GAQL in Recupera target geografici.
  2. Confronta i criteri esistenti con l'elenco dei target che intendi utilizzare.
  3. Per ogni criterio obsoleto, crea un CampaignCriterionOperation con remove impostato sul resource_name del criterio esistente.
  4. Per ogni nuova località o target di prossimità, crea un CampaignCriterionOperation con create compilato con il nuovo criterio LocationInfo o ProximityInfo.
  5. Trasferisci le operazioni remove e create in una singola chiamata MutateCampaignCriteria in modo che la transizione avvenga in modo atomico.

Escludere i target geografici

Puoi anche escludere LocationInfo, ma non ProximityInfo. Questa funzionalità è più utile se vuoi scegliere come target una regione, ma escludere una sottoregione (ad esempio, per scegliere come target tutti gli Stati Uniti, ad eccezione di New York City). Per escludere una regione, imposta il campo negative in CampaignCriterion su true.

Scegliere come target più regioni geografiche

Se utilizzi un LocationGroupInfo, puoi attivare una campagna per scegliere come target più regioni geografiche centrate sulle località definite dagli asset posizione o filtrate in base a una regione geografica:

  • Insiemi di asset posizione: imposta enable_customer_level_location_asset_set = true (per scegliere come target l'insieme di asset posizione del cliente) o location_group_asset_sets (per scegliere come target nomi di risorse AssetSet specifici). Questi due campi non possono essere impostati insieme e nessuno dei due può essere combinato con geo_target_constants.
  • Raggio e unità: il raggio su LocationGroupInfo definisce una regione circolare intorno a ogni località e richiede sia radius sia radius_units (LocationGroupRadiusUnitsEnum):
    • Quando utilizzi i set di asset posizione (enable_customer_level_location_asset_set o location_group_asset_sets), i valori radius_units supportati sono MILLI_MILES e METERS.
    • Quando filtri per geo_target_constants (dove è consentito al massimo un ID criterio e i campi AssetSet non sono impostati), i valori radius_units supportati sono MILES e METERS.

Opzioni avanzate di targeting per località con GeoTargetTypeSetting

Oltre a specificare le località target o escluse, puoi perfezionare il modo in cui Google Ads associa gli utenti a queste località utilizzando le opzioni avanzate di targeting per località. Queste impostazioni sono gestite tramite Campaign.GeoTargetTypeSetting.

Questa impostazione è costituita da due campi:

  • positive_geo_target_type: determina la corrispondenza degli utenti per le località che targetizzi.
  • negative_geo_target_type: determina la modalità di corrispondenza degli utenti per le località che escludi.

Impostazioni di targeting positivo (positive_geo_target_type)

Puoi scegliere tra le seguenti opzioni per il targeting per località positivo, utilizzando i valori di PositiveGeoTargetTypeEnum:

  • PRESENCE_OR_INTEREST (valore predefinito consigliato):

    • Raggiunge gli utenti che è probabile si trovino o che si trovano abitualmente nelle località target, nonché quelli che hanno mostrato interesse per le località target.
    • L'interesse può essere segnalato da termini di ricerca, visite precedenti o contenuti consumati correlati alla località.
    • Questa opzione offre la copertura più ampia.

  • PRESENCE:

    • Raggiunge solo le persone che probabilmente si trovano fisicamente o regolarmente nelle località target.
    • Questo tipo di targeting è più restrittivo e utile se i tuoi servizi o prodotti sono strettamente limitati alle persone fisicamente presenti in una zona.

Impostazioni di targeting per esclusione (negative_geo_target_type)

Per le località che vuoi escludere, utilizza NegativeGeoTargetTypeEnum:

  • PRESENCE (impostazione predefinita consigliata):
    • Esclude le persone che è probabile si trovino fisicamente nelle località che hai escluso.
    • Gli utenti al di fuori delle aree escluse, anche se interessati, potrebbero comunque visualizzare i tuoi annunci, a condizione che corrispondano al targeting positivo.

Gestire le opzioni avanzate di targeting per località

Puoi controllare queste impostazioni aggiornando l'oggetto Campaign.geo_target_type_setting. L'esempio seguente mostra la struttura di un aggiornamento di CampaignOperation che imposta positive_geo_target_type su 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"
  }
}

Per recuperare le impostazioni attuali, includi campaign.geo_target_type_setting.positive_geo_target_type e campaign.geo_target_type_setting.negative_geo_target_type nella query di ricerca GoogleAdsService.

Configurando queste impostazioni, ottieni un controllo più granulare su chi vede i tuoi annunci in base al rapporto con le località geografiche che hai specificato, allineandoti più strettamente ai tuoi obiettivi commerciali.

Best practice

  • Scegli PRESENCE se il tuo prodotto o servizio è strettamente limitato a persone fisicamente presenti in una località. Ad esempio, supponiamo che tu richieda che gli utenti si trovino in negozio o che richiedano la consegna locale.
  • Scegli PRESENCE_OR_INTEREST se il tuo prodotto o servizio può essere utile anche a persone interessate a una località, anche se non si trovano fisicamente lì. Ad esempio, un utente che sta pianificando una vacanza potrebbe essere interessato agli hotel della città di destinazione.
  • Utilizza il targeting per località escluse per perfezionare la copertura. Se scegli come target gli Stati Uniti con PRESENCE_OR_INTEREST, ma non effettui spedizioni in uno stato specifico, puoi escludere questo stato utilizzando negative=true in un criterio LocationInfo. Se combinata con negative_geo_target_type impostato su PRESENCE, questa impostazione impedisce la pubblicazione dei tuoi annunci per gli utenti di questo stato, consentendoti comunque di raggiungere gli utenti al di fuori di questo stato che potrebbero essere interessati alle località degli Stati Uniti.

Passaggi successivi

Indietro
Modificatori di offerta
Avanti
Impostazioni di targeting