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à delle 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. Supponiamo, ad esempio, 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 di regioni in cui non hai supermercati. In questo modo, genereresti costi senza alcuna possibilità di un 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 degli annunci paesi, regioni o la prossimità a un punto geografico specifico.

Scegliere come target geografico le campagne 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, una regione, una città o una regione postale. Ogni località targetizzabile viene identificata in modo univoco da un ID criterio. Puoi cercare un ID criterio utilizzando GeoTargetConstantService.SuggestGeoTargetConstants. Il resource_name di ogni GeoTargetConstant ha il 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 il 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 abilitato). Il seguente snippet di codice mostra come scegliere come target della campagna 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 occasionalmente ritirare alcuni criteri per località per vari motivi: la località potrebbe essere ristrutturata in aree più piccole o più grandi, modifiche geopolitiche e così via. Consulta il status campo di un GeoTargetConstant oggetto per determinare se una località è ENABLED o REMOVAL_PLANNED.

Cercare per nome della località

Puoi anche cercare l'ID criterio per nome della località utilizzando GeoTargetConstantService.SuggestGeoTargetConstants. Il seguente esempio di codice mostra come cercare un ID criterio per 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 delle campagne la prossimità a una località

A volte potresti voler scegliere come target in modo 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 per prossimità. Il codice per creare un target per prossimità è simile all'aggiunta di un target per località, tranne per il fatto che devi creare un ProximityInfo oggetto anziché un LocationInfo oggetto.

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 di una campagna utilizzando GoogleAdsService.SearchStream. L'inclusione di campaign_criterion.type e campaign_criterion.resource_name nella clausola SELECT ti consente di distinguere tra i criteri LOCATION e PROXIMITY e di 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')

Aggiornare i target geografici

I criteri per 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 atomica CampaignCriterionService.MutateCampaignCriteria richiesta:

  1. Esegui una query sui criteri LOCATION e PROXIMITY esistenti della campagna utilizzando la query GAQL in Recuperare i target geografici.
  2. Confronta i criteri esistenti con l'elenco dei target previsto.
  3. Per ogni criterio obsoleto, crea un CampaignCriterionOperation con remove impostato sul resource_name del criterio esistente.
  4. Per ogni nuovo target per località o prossimità, crea un CampaignCriterionOperation con create compilato con il nuovo criterio LocationInfo o ProximityInfo.
  5. Trasmetti 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, scegliere come target tutti gli Stati Uniti, ad eccezione di New York City). Per escludere una regione, imposta il negative campo in CampaignCriterion su true.

Scegliere come target più regioni geografiche

Se utilizzi un LocationGroupInfo, puoi consentire a una campagna di scegliere come target più regioni geografiche centrate 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 non possono essere combinati con geo_target_constants.
  • Raggio e unità: il raggio in LocationGroupInfo definisce una regione 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 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 vengono gestite tramite Campaign.GeoTargetTypeSetting.

Questa impostazione è composta da due campi:

  • positive_geo_target_type: determina la modalità di corrispondenza degli utenti per le località target.
  • negative_geo_target_type: determina la modalità di corrispondenza degli utenti per le località escluse.

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 probabilmente si trovano nelle località target o le visitano regolarmente, oltre a 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 gli utenti che probabilmente si trovano fisicamente o regolarmente nelle località target.
    • Questa opzione è più restrittiva e utile se i tuoi servizi o prodotti sono strettamente limitati alle persone fisicamente presenti in un'area.

Impostazioni di targeting per esclusione (negative_geo_target_type)

Per le località che vuoi escludere, utilizza il NegativeGeoTargetTypeEnum:

  • PRESENCE (valore predefinito consigliato):
    • Esclude gli utenti che probabilmente si trovano fisicamente nelle località escluse.
    • Gli utenti al di fuori delle aree escluse, anche se interessati, potrebbero comunque visualizzare i tuoi annunci, a condizione che corrispondano al tuo 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 correnti, 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, allineandoti più strettamente 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 tu richieda la consegna locale.
  • Scegli PRESENCE_OR_INTEREST se il tuo prodotto o servizio può essere utile anche alle persone interessate a una località, anche se non 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à per esclusione 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. In combinazione con negative_geo_target_type impostato su PRESENCE, questa opzione impedisce la visualizzazione degli annunci agli utenti di questo stato, raggiungendo al contempo gli utenti al di fuori dello stato che potrebbero essere interessati alle località degli Stati Uniti.

Passaggi successivi

Indietro
Modificatori di offerta
Avanti
Impostazioni di targeting