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 di Informazioni sui limiti dell'account Google Ads.

Perché il targeting geografico è importante?

Il targeting per località ti consente di pubblicare annunci per gli utenti di una determinata regione geografica. Ad esempio, supponiamo che tu stia pubblicizzando una catena di supermercati. Senza il targeting per località, i tuoi annunci verrebbero mostrati in tutte le regioni del mondo e potrebbero ricevere clic da utenti in 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 direttamente i clienti che cercano supermercati a livello locale.

L'API Google Ads ti consente di indirizzare i tuoi annunci in base a paese, regione o prossimità intorno a un punto geografico specifico.

Campagne con targeting geografico per una regione

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

Puoi aggiungere target geografici alle tue campagne utilizzando CampaignCriterionService (o a livello di gruppo di annunci utilizzando AdGroupCriterion per i tipi di campagna supportati, ad esempio le campagne Demand Gen con upgraded_targeting attivato). Il seguente snippet di codice mostra come scegliere il target della 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::V26::Resources::CampaignCriterion->new({
      # Create a location using the specified location ID.
      location => Google::Ads::GoogleAds::V26::Common::LocationInfo->new({
          # Besides using location ID, you can also search by location names
          # using GeoTargetConstantService::suggest() and directly apply
          # GeoTargetConstant->{resourceName} here. An example can be found
          # in get_geo_target_constants_by_names.pl.
          geoTargetConstant =>
            Google::Ads::GoogleAds::V26::Utils::ResourceNames::geo_target_constant(
            $location_id)}
      ),
      campaign => $campaign_resource_name
    });

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

curl

Occasionalmente, Google potrebbe eliminare 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.

Cerca 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.V26.GeoTargetConstantService);

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

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

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

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

    request.LocationNames.Names.AddRange(locations);

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

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

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::V26::Services::GeoTargetConstantService::LocationNames
        ->new({
          names => $location_names
        })});

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

  return 1;
}

curl

Scegliere il target delle campagne in base alla vicinanza a una località

A volte potresti voler scegliere un target ancora più preciso di una città o di 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 di prossimità. Il codice per creare un target di prossimità è simile a quello per aggiungere una località target, con la differenza 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::V26::Resources::CampaignCriterion->new({
      proximity => Google::Ads::GoogleAds::V26::Common::ProximityInfo->new({
          address => Google::Ads::GoogleAds::V26::Common::AddressInfo->new({
              streetAddress => "38 avenue de l'Opéra",
              cityName      => "cityName",
              postalCode    => "75002",
              countryCode   => "FR"
            }
          ),
          radius => 10.0,
          # Default is kilometers.
          radiusUnits => MILES
        }
      ),
      campaign => $campaign_resource_name
    });

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

curl

Recupera i target geografici

Puoi recuperare i target geografici di una campagna utilizzando GoogleAdsService.SearchStream. Includendo campaign_criterion.type e campaign_criterion.resource_name nella clausola SELECT, puoi 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 non possono essere modificati dopo la creazione, pertanto l'aggiornamento dei target geografici di una campagna richiede la sostituzione dei target obsoleti con quelli nuovi in un'unica richiesta CampaignCriterionService.MutateCampaignCriteria atomica:

  1. Esegui una query sui criteri LOCATION e PROXIMITY esistenti della campagna utilizzando la query GAQL in Recupera i target geografici.
  2. Confronta i criteri esistenti con l'elenco di destinazione previsto.
  3. Per ogni criterio obsoleto, crea un CampaignCriterionOperation con remove impostato su 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. Passa entrambe le operazioni remove e create in una singola chiamata MutateCampaignCriteria in modo che la transizione avvenga in modo atomico.

Escludi target geografici

Puoi anche escludere LocationInfo, ma non ProximityInfo. Questa funzionalità è particolarmente 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). Per escludere una regione, imposta il campo negative in CampaignCriterion su true.

Scegli come target più regioni geografiche

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

  • Gruppi 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 un'area circolare intorno a ogni località e richiede sia radius sia radius_units (LocationGroupRadiusUnitsEnum):
    • Quando utilizzi gli insiemi 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 in base a 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 di località avanzate con GeoTargetTypeSetting

Oltre a specificare le località da scegliere come target o da escludere, puoi perfezionare il modo in cui Google Ads abbina gli utenti a queste località utilizzando le opzioni di località avanzate. Queste impostazioni vengono gestite tramite Campaign.GeoTargetTypeSetting.

Questa impostazione è composta da due campi:

  • positive_geo_target_type: determina il modo in cui gli utenti vengono abbinati alle località che scegli come target.
  • negative_geo_target_type: determina il modo in cui gli utenti vengono abbinati alle 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 (impostazione predefinita consigliata):

    • Raggiunge le persone che è probabile si trovino o che si trovano abitualmente nelle località target, nonché quelle 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 potrebbero trovarsi fisicamente o regolarmente nelle località target.
    • Questa opzione è più restrittiva e utile se i tuoi servizi o prodotti sono limitati esclusivamente alle persone fisicamente presenti in un'area.

Impostazioni di targeting per esclusione (negative_geo_target_type)

Per le località che vuoi escludere, utilizza NegativeGeoTargetTypeEnum:

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

Gestisci le opzioni di targeting per località avanzate

Puoi controllare queste impostazioni aggiornando l'oggetto Campaign.geo_target_type_setting. L'esempio seguente mostra la struttura di un aggiornamento 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 alla relazione con le posizioni geografiche che hai specificato, in modo da allinearti meglio ai tuoi obiettivi commerciali.

Best practice

  • Scegli PRESENCE se il tuo prodotto o servizio è strettamente limitato alle persone fisicamente presenti in una località. Ad esempio, supponiamo che tu richieda agli utenti di essere in negozio o che richieda la consegna locale.
  • Scegli PRESENCE_OR_INTEREST se il tuo prodotto o servizio può anche essere utile per le persone interessate a una località, anche se non sono fisicamente presenti. Ad esempio, un utente che sta pianificando una vacanza potrebbe essere interessato agli hotel nella 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 spedisci in uno stato specifico, puoi escludere questo stato utilizzando negative=true su un criterio LocationInfo. In combinazione con negative_geo_target_type impostato su PRESENCE, questo impedisce la pubblicazione dei tuoi annunci per gli utenti di quello stato, pur raggiungendo gli utenti al di fuori di quello stato che potrebbero essere interessati alle località degli Stati Uniti.

Passaggi successivi

Indietro
Modificatori di offerta
Avanti
Impostazioni di targeting