Kierowanie na lokalizację

Z tego przewodnika dowiesz się, czym jest kierowanie na lokalizację i jak za pomocą interfejsu Google Ads API dodawać, pobierać i aktualizować kierowanie na lokalizację w kampaniach.

Informacje o limitach kierowania znajdziesz w sekcji Limity kierowania w artykule Limity konta Google Ads.

Dlaczego kierowanie geograficzne jest ważne?

Kierowanie na lokalizację umożliwia wyświetlanie reklam użytkownikom w określonym regionie geograficznym. Załóżmy na przykład, że reklamujesz sieć supermarketów. Bez kierowania na lokalizację Twoje reklamy będą się wyświetlać we wszystkich regionach na całym świecie i mogą otrzymywać kliknięcia od użytkowników z regionów, w których nie masz supermarketów. Generuje to koszty, ale nie daje możliwości zwrotu z inwestycji. Dzięki kierowaniu na lokalizację kampanie wyświetlają reklamy tylko w regionach, w których znajdują się otwarte supermarkety. To podejście umożliwia też bezpośrednie kierowanie reklam do klientów, którzy szukają supermarketów w swojej okolicy.

Interfejs Google Ads API umożliwia kierowanie reklam na kraje, regiony lub obszary w pobliżu określonego punktu geograficznego.

Kierowanie kampanii na region

Kampanie możesz kierować na dowolny region geograficzny, w przypadku którego Google Ads obsługuje kierowanie na lokalizację, np. kraj, stan, miasto lub region pocztowy. Każda lokalizacja, na którą można kierować reklamy, jest jednoznacznie identyfikowana przez identyfikator kryterium. Identyfikator kryterium możesz znaleźć za pomocą GeoTargetConstantService.SuggestGeoTargetConstants. Identyfikator resource_name każdego elementu GeoTargetConstant ma postać geoTargetConstants/{Criterion ID}. Na przykład wartość resource_name stanu Nowy Jork to geoTargetConstants/21167.

Możesz dodawać kierowanie geograficzne do kampanii za pomocą parametru CampaignCriterionService (lub na poziomie grupy reklam za pomocą parametru AdGroupCriterion w przypadku obsługiwanych typów kampanii, np. kampanii generujących popyt z włączoną funkcją upgraded_targeting). Poniższy fragment kodu pokazuje, jak kierować kampanię za pomocą identyfikatora kryterium.

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 może czasami wycofywać niektóre kryteria lokalizacji z różnych powodów: lokalizacja może zostać podzielona na mniejsze lub większe obszary, mogą nastąpić zmiany geopolityczne itp. Aby sprawdzić, czy lokalizacja jest ENABLED czy REMOVAL_PLANNED, zapoznaj się z polem status obiektu GeoTargetConstant.

Wyszukiwanie według nazwy lokalizacji

Możesz też wyszukać identyfikator kryterium według nazwy lokalizacji za pomocą funkcji GeoTargetConstantService.SuggestGeoTargetConstants. Poniższy przykład kodu pokazuje, jak wyszukać identyfikator kryterium lokalizacji na podstawie nazwy lokalizacji.

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

Kierowanie kampanii na osoby znajdujące się w pobliżu lokalizacji

Czasami możesz chcieć kierować reklamy jeszcze dokładniej niż na miasto lub kraj. Możesz na przykład reklamować swoje supermarkety w promieniu 10 km od lokalizacji sklepu. W takich przypadkach możesz użyć kierowania na podstawie bliskości. Kod do utworzenia celu kierowania na bliskość jest podobny do kodu dodawania celu kierowania na lokalizację, z tym wyjątkiem, że musisz utworzyć obiekt ProximityInfo zamiast obiektu 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

Pobieranie celów geograficznych

Cele geograficzne kampanii możesz pobrać za pomocą metody GoogleAdsService.SearchStream. Uwzględnienie znaków campaign_criterion.type i campaign_criterion.resource_name w klauzuli SELECT umożliwia odróżnienie kryteriów LOCATION od kryteriów PROXIMITY i zarejestrowanie nazw zasobów na potrzeby późniejszych aktualizacji lub usunięć.

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

Aktualizowanie kierowania geograficznego

Kryteria lokalizacji w kampanii są niezmienne po jej utworzeniu, więc aktualizacja kierowania geograficznego kampanii wymaga zastąpienia przestarzałych celów nowymi w ramach jednej niepodzielnejCampaignCriterionService.MutateCampaignCriteria prośby:

  1. Wykonaj zapytanie GAQL dotyczące dotychczasowych kryteriów LOCATION i PROXIMITY kampanii, korzystając z zapytania GAQL w sekcji Pobieranie kierowania geograficznego.
  2. Porównaj obecne kryteria z docelową listą.
  3. W przypadku każdego przestarzałego kryterium utwórz CampaignCriterionOperation z ustawionym na remove resource_name istniejącego kryterium.
  4. W przypadku każdej nowej lokalizacji lub nowego kierowania na lokalizację przybliżoną utwórz element CampaignCriterionOperation z elementem create wypełnionym nowym kryterium LocationInfo lub ProximityInfo.
  5. Przekaż operacje remove i create w jednym wywołaniu MutateCampaignCriteria, aby przejście nastąpiło niepodzielnie.

Wykluczanie celów geograficznych

Możesz też wykluczyć LocationInfo, ale nie ProximityInfo. Ta funkcja jest najbardziej przydatna, jeśli chcesz kierować reklamy na region, ale wykluczyć podregion (np. kierować reklamy na całe Stany Zjednoczone z wyjątkiem Nowego Jorku). Aby wykluczyć region, ustaw pole negative w CampaignCriterion na true.

Kierowanie na wiele regionów geograficznych

Jeśli używasz LocationGroupInfo, możesz włączyć kierowanie kampanii na wiele regionów geograficznych, które są wyśrodkowane na lokalizacjach zdefiniowanych przez komponenty z lokalizacją lub odfiltrowane według regionu geograficznego:

  • Zestawy komponentów z lokalizacją: ustaw enable_customer_level_location_asset_set = true (aby kierować reklamy na zestaw komponentów z lokalizacją klienta) lub location_group_asset_sets (aby kierować reklamy na konkretne nazwy zasobów AssetSet). Nie można ustawić tych 2 pól jednocześnie ani połączyć ich z polem geo_target_constants.
  • Promień i jednostki: promień w LocationGroupInfo określa okrągły obszar wokół każdej lokalizacji i wymaga podania zarówno radius, jak i radius_units (LocationGroupRadiusUnitsEnum):
    • W przypadku korzystania z grup komponentów z lokalizacjami (enable_customer_level_location_asset_set lub location_group_asset_sets) obsługiwane wartości radius_units to MILLI_MILES i METERS.
    • Podczas filtrowania według geo_target_constants (gdzie dozwolony jest maksymalnie 1 identyfikator kryterium, a pola AssetSet nie są ustawione) obsługiwane wartości radius_units to MILES i METERS.

Zaawansowane opcje lokalizacji w GeoTargetTypeSetting

Oprócz określania lokalizacji, na które chcesz kierować reklamy lub z których chcesz wykluczać użytkowników, możesz doprecyzować sposób dopasowywania użytkowników do tych lokalizacji w Google Ads za pomocą zaawansowanych opcji lokalizacji. Tymi ustawieniami zarządza się w Campaign.GeoTargetTypeSetting.

To ustawienie składa się z 2 pól:

  • positive_geo_target_type: określa, w jaki sposób użytkownicy są dopasowywani do lokalizacji, na które kierujesz reklamy.
  • negative_geo_target_type: określa, w jaki sposób użytkownicy są dopasowywani do lokalizacji, które wykluczasz.

Ustawienia kierowania niewykluczającego (positive_geo_target_type)

W przypadku kierowania na lokalizacje o wartościach dodatnich możesz wybrać te opcje, korzystając z wartości z PositiveGeoTargetTypeEnum:

  • PRESENCE_OR_INTEREST (zalecana wartość domyślna):

    • Dociera do osób, które prawdopodobnie znajdują się lub często przebywają w wybranych przez Ciebie lokalizacjach, a także do osób, które się nimi interesują.
    • Zainteresowanie może być sygnalizowane przez wyszukiwane hasła, wcześniejsze wizyty lub treści związane z lokalizacją.
    • Ta opcja zapewnia największy zasięg.

  • PRESENCE:

    • Dociera tylko do osób, które prawdopodobnie znajdują się w wybranych przez Ciebie lokalizacjach lub regularnie w nich bywają.
    • Jest to bardziej restrykcyjne i przydatne, jeśli Twoje usługi lub produkty są ściśle ograniczone do osób fizycznie przebywających w danym obszarze.

Ustawienia kierowania wykluczającego (negative_geo_target_type)

W przypadku lokalizacji, które chcesz wykluczyć, użyj:NegativeGeoTargetTypeEnum

  • PRESENCE (Zalecane ustawienie domyślne):
    • Wyklucza osoby, które prawdopodobnie znajdują się w wykluczonych przez Ciebie lokalizacjach.
    • Osoby spoza wykluczonych obszarów, nawet jeśli są nimi zainteresowane, nadal mogą zobaczyć Twoje reklamy, o ile spełniają kryteria kierowania pozytywnego.

Zarządzanie zaawansowanymi opcjami lokalizacji

Możesz kontrolować te ustawienia, aktualizując obiekt Campaign.geo_target_type_setting. Poniższy przykład pokazuje strukturę CampaignOperation aktualizacji, która ustawia positive_geo_target_type na 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"
  }
}

Aby pobrać bieżące ustawienia, w zapytaniu wyszukiwania umieść znaki campaign.geo_target_type_setting.positive_geo_target_type i campaign.geo_target_type_setting.negative_geo_target_type.GoogleAdsService

Konfigurując te ustawienia, zyskujesz większą kontrolę nad tym, kto widzi Twoje reklamy, na podstawie jego relacji z określonymi przez Ciebie lokalizacjami geograficznymi, co pozwala lepiej dopasować reklamy do celów biznesowych.

Sprawdzone metody

  • Wybierz PRESENCE, jeśli Twój produkt lub usługa są ściśle ograniczone do osób fizycznie przebywających w danej lokalizacji. Załóżmy na przykład, że wymagasz, aby użytkownicy byli w sklepie lub korzystali z dostawy lokalnej.
  • Wybierz PRESENCE_OR_INTEREST, jeśli Twój produkt lub usługa mogą być przydatne dla osób zainteresowanych daną lokalizacją, nawet jeśli nie znajdują się w niej fizycznie. Na przykład użytkownik planujący wakacje może być zainteresowany hotelami w miejscowości, do której się wybiera.
  • Używaj wykluczonych lokalizacji, aby doprecyzować zasięg. Jeśli kierujesz reklamy na Stany Zjednoczone za pomocą kryterium PRESENCE_OR_INTEREST, ale nie wysyłasz produktów do konkretnego stanu, możesz wykluczyć ten stan za pomocą kryterium negative=true w kryterium LocationInfo. W połączeniu z ustawieniem negative_geo_target_type na PRESENCE zapobiega to wyświetlaniu reklam użytkownikom w tym stanie, a jednocześnie umożliwia docieranie do użytkowników spoza tego stanu, którzy mogą być zainteresowani lokalizacjami w USA.

Co dalej?

Wstecz
Modyfikatory stawek
Dalej
Ustawienia kierowania