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 masz 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.

Dowiedz się więcej o kierowaniu reklam na lokalizacje geograficzne.

Kierowanie kampanii na region

Kampanie możesz kierować na dowolny region geograficzny, w którym 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 wyszukać za pomocą narzędzia GeoTargetConstantService.SuggestGeoTargetConstants. resource_name każdego GeoTargetConstant ma postać geoTargetConstants/{Criterion ID}. Na przykład resource_name wartość stanu Nowy Jork to geoTargetConstants/21167.

Możesz dodawać do kampanii kierowanie geograficzne za pomocą ikony CampaignCriterionService. 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();
}
AddCampaignTargetingCriteria.java

C#

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

PHP

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

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

Python

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

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

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

    return campaign_criterion_operation
add_campaign_targeting_criteria.py

Ruby

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

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

Perl

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

  # Construct a campaign criterion for the specified campaign using the
  # specified location ID.
  my $campaign_criterion =
    Google::Ads::GoogleAds::V22::Resources::CampaignCriterion->new({
      # Create a location using the specified location ID.
      location => Google::Ads::GoogleAds::V22::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::V22::Utils::ResourceNames::geo_target_constant(
            $location_id)}
      ),
      campaign => $campaign_resource_name
    });

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

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 według 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());
    }
  }
}
GetGeoTargetConstantsByNames.java

C#

public void Run(GoogleAdsClient client)
{
    // Get the GeoTargetConstantServiceClient.
    GeoTargetConstantServiceClient geoService =
        client.GetService(Services.V22.GeoTargetConstantService);

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

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

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

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

    request.LocationNames.Names.AddRange(locations);

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

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

PHP

public static function runExample(
    GoogleAdsClient $googleAdsClient,
    array $locationNames,
    string $locale,
    string $countryCode
) {
    $geoTargetConstantServiceClient = $googleAdsClient->getGeoTargetConstantServiceClient();

    $response = $geoTargetConstantServiceClient->suggestGeoTargetConstants(
        new SuggestGeoTargetConstantsRequest([
            'locale' => $locale,
            'country_code' => $countryCode,
            'location_names' => new LocationNames(['names' => $locationNames])
        ])
    );

    // Iterates over all geo target constant suggestion objects and prints the requested field
    // values for each one.
    foreach ($response->getGeoTargetConstantSuggestions() as $geoTargetConstantSuggestion) {
        /** @var GeoTargetConstantSuggestion $geoTargetConstantSuggestion */
        printf(
            "Found '%s' ('%s','%s','%s',%s) in locale '%s' with reach %d"
            . " for the search term '%s'.%s",
            $geoTargetConstantSuggestion->getGeoTargetConstant()->getResourceName(),
            $geoTargetConstantSuggestion->getGeoTargetConstant()->getName(),
            $geoTargetConstantSuggestion->getGeoTargetConstant()->getCountryCode(),
            $geoTargetConstantSuggestion->getGeoTargetConstant()->getTargetType(),
            GeoTargetConstantStatus::name(
                $geoTargetConstantSuggestion->getGeoTargetConstant()->getStatus()
            ),
            $geoTargetConstantSuggestion->getLocale(),
            $geoTargetConstantSuggestion->getReach(),
            $geoTargetConstantSuggestion->getSearchTerm(),
            PHP_EOL
        );
    }
}
GetGeoTargetConstantsByNames.php

Python

def main(client: GoogleAdsClient) -> None:
    gtc_service: GeoTargetConstantServiceClient = client.get_service(
        "GeoTargetConstantService"
    )

    gtc_request: SuggestGeoTargetConstantsRequest = client.get_type(
        "SuggestGeoTargetConstantsRequest"
    )
    gtc_request.locale = LOCALE
    gtc_request.country_code = COUNTRY_CODE

    # The location names to get suggested geo target constants.
    # Type hint for gtc_request.location_names.names is not straightforward
    # as it's part of a complex protobuf object.
    gtc_request.location_names.names.extend(
        ["Paris", "Quebec", "Spain", "Deutschland"]
    )

    results: SuggestGeoTargetConstantsResponse = (
        gtc_service.suggest_geo_target_constants(gtc_request)
    )

    suggestion: GeoTargetConstantSuggestion
    for suggestion in results.geo_target_constant_suggestions:
        geo_target_constant: GeoTargetConstant = suggestion.geo_target_constant
        print(
            f"{geo_target_constant.resource_name} "
            f"({geo_target_constant.name}, "
            f"{geo_target_constant.country_code}, "
            f"{geo_target_constant.target_type}, "
            f"{geo_target_constant.status.name}) "
            f"is found in locale ({suggestion.locale}) "
            f"with reach ({suggestion.reach}) "
            f"from search term ({suggestion.search_term})."
        )
get_geo_target_constants_by_names.py

Ruby

def get_geo_target_constants_by_names
  # GoogleAdsClient will read a config file from
  # ENV['HOME']/google_ads_config.rb when called without parameters
  client = Google::Ads::GoogleAds::GoogleAdsClient.new

  gtc_service = client.service.geo_target_constant

  location_names = client.resource.location_names do |ln|
    ['Paris', 'Quebec', 'Spain', 'Deutschland'].each do |name|
      ln.names << name
    end
  end

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

  # A list of country codes can be referenced here:
  # https://developers.google.com/google-ads/api/reference/data/geotargets
  country_code = 'FR'

  response = gtc_service.suggest_geo_target_constants(
    locale: locale,
    country_code: country_code,
    location_names: location_names
  )

  response.geo_target_constant_suggestions.each do |suggestion|
    puts sprintf("%s (%s,%s,%s,%s) is found in locale (%s) with reach (%d)" \
        " from search term (%s).", suggestion.geo_target_constant.resource_name,
        suggestion.geo_target_constant.name,
        suggestion.geo_target_constant.country_code,
        suggestion.geo_target_constant.target_type,
        suggestion.geo_target_constant.status,
        suggestion.locale,
        suggestion.reach,
        suggestion.search_term)
  end
end
get_geo_target_constants_by_names.rb

Perl

sub get_geo_target_constants_by_names {
  my ($api_client, $location_names, $locale, $country_code) = @_;

  my $suggest_response = $api_client->GeoTargetConstantService()->suggest({
      locale        => $locale,
      countryCode   => $country_code,
      locationNames =>
        Google::Ads::GoogleAds::V22::Services::GeoTargetConstantService::LocationNames
        ->new({
          names => $location_names
        })});

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

  return 1;
}
get_geo_target_constants_by_names.pl

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ć supermarkety w promieniu 10 km od lokalizacji Twojego sklepu. W takich przypadkach możesz użyć targetowania na podstawie bliskości. Kod do tworzenia zbliżonego obszaru kierowania jest podobny do kodu dodawania lokalizacji docelowej, z tą różnicą, że zamiast obiektu LocationInfo musisz utworzyć obiekt ProximityInfo.

Java

private static CampaignCriterion buildProximityLocation(String campaignResourceName) {
  Builder builder = CampaignCriterion.newBuilder().setCampaign(campaignResourceName);

  ProximityInfo.Builder proximityBuilder = builder.getProximityBuilder();
  proximityBuilder.setRadius(10.0).setRadiusUnits(ProximityRadiusUnits.MILES);

  AddressInfo.Builder addressBuilder = proximityBuilder.getAddressBuilder();
  addressBuilder
      .setStreetAddress("38 avenue de l'Opéra")
      .setCityName("Paris")
      .setPostalCode("75002")
      .setCountryCode("FR");

  return builder.build();
}
AddCampaignTargetingCriteria.java

C#

private CampaignCriterion buildProximityCriterion(string campaignResourceName)
{
    ProximityInfo proximity = new ProximityInfo()
    {
        Address = new AddressInfo()
        {
            StreetAddress = "38 avenue de l'Opéra",
            CityName = "Paris",
            PostalCode = "75002",
            CountryCode = "FR"
        },
        Radius = 10d,
        // Default is kilometers.
        RadiusUnits = ProximityRadiusUnits.Miles
    };

    return new CampaignCriterion()
    {
        Campaign = campaignResourceName,
        Proximity = proximity
    };
}
AddCampaignTargetingCriteria.cs

PHP

private static function createProximityCampaignCriterionOperation(string $campaignResourceName)
{
    // Constructs a campaign criterion as a proximity.
    $campaignCriterion = new CampaignCriterion([
        'proximity' => new ProximityInfo([
            'address' => new AddressInfo([
                'street_address' => '38 avenue de l\'Opéra',
                'city_name' => 'Paris',
                'postal_code' => '75002',
                'country_code' => 'FR',
            ]),
            'radius' => 10.0,
            // Default is kilometers.
            'radius_units' => ProximityRadiusUnits::MILES
        ]),
        'campaign' => $campaignResourceName
    ]);

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

Python

def create_proximity_op(
    client: GoogleAdsClient, customer_id: str, campaign_id: str
) -> CampaignCriterionOperation:
    campaign_service: CampaignServiceClient = client.get_service(
        "CampaignService"
    )

    # Create the campaign criterion.
    campaign_criterion_operation: CampaignCriterionOperation = client.get_type(
        "CampaignCriterionOperation"
    )
    campaign_criterion: CampaignCriterion = campaign_criterion_operation.create
    campaign_criterion.campaign = campaign_service.campaign_path(
        customer_id, campaign_id
    )
    campaign_criterion.proximity.address.street_address = "38 avenue de l'Opera"
    campaign_criterion.proximity.address.city_name = "Paris"
    campaign_criterion.proximity.address.postal_code = "75002"
    campaign_criterion.proximity.address.country_code = "FR"
    campaign_criterion.proximity.radius = 10
    # Default is kilometers.
    campaign_criterion.proximity.radius_units = (
        client.enums.ProximityRadiusUnitsEnum.MILES
    )

    return campaign_criterion_operation
add_campaign_targeting_criteria.py

Ruby

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

    criterion.proximity = client.resource.proximity_info do |proximity|
      proximity.address = client.resource.address_info do |address|
        address.street_address = "38 avenue de l'Opéra"
        address.city_name = "Paris"
        address.postal_code = "75002"
        address.country_code = "FR"
      end

      proximity.radius = 10
      proximity.radius_units = :MILES
    end
  end
end
add_campaign_targeting_criteria.rb

Perl

sub create_proximity_campaign_criterion_operation {
  my ($campaign_resource_name) = @_;

  # Construct a campaign criterion as a proximity.
  my $campaign_criterion =
    Google::Ads::GoogleAds::V22::Resources::CampaignCriterion->new({
      proximity => Google::Ads::GoogleAds::V22::Common::ProximityInfo->new({
          address => Google::Ads::GoogleAds::V22::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::V22::Services::CampaignCriterionService::CampaignCriterionOperation
    ->new({
      create => $campaign_criterion
    });
}
add_campaign_targeting_criteria.pl

Pobieranie celów geograficznych

Cele geograficzne kampanii możesz pobrać za pomocą metody GoogleAdsService.SearchStream. Wyniki możesz filtrować w klauzuli WHERE.

SELECT
  campaign_criterion.campaign,
  campaign_criterion.location.geo_target_constant,
  campaign_criterion.proximity.geo_point.longitude_in_micro_degrees,
  campaign_criterion.proximity.geo_point.latitude_in_micro_degrees,
  campaign_criterion.proximity.radius,
  campaign_criterion.negative
FROM campaign_criterion
WHERE
  campaign_criterion.campaign = 'customers/{customer_id}/campaigns/{campaign_id}'
  AND campaign_criterion.type IN (LOCATION, PROXIMITY)

Aktualizowanie kierowania geograficznego

Aby zaktualizować lokalizacje docelowe w kampanii, musisz pobrać listę istniejących lokalizacji docelowych i porównać ją z listą nowych lokalizacji docelowych. Następnie możesz użyć operacji remove, aby usunąć niepotrzebne miejsca docelowe, oraz operacji create, aby dodać nowe miejsca docelowe, których potrzebujesz (ale których brakuje w dotychczasowej kampanii).

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

Za pomocą LocationGroupInfo możesz włączyć kierowanie kampanii na wiele regionów geograficznych. Region jest wyśrodkowany na lokalizacjach określonych przez rozszerzenia lokalizacji kampanii.

Promień zdefiniowany w LocationGroupInfo określa okrągły obszar wokół każdej lokalizacji i składa się z obiektu radius, długości i radius_units, która może być podana w metrach lub milach (LocationGroupRadiusUnitsEnum).

Lokalizacje w LocationGroupInfo można filtrować według listy identyfikatorów kryteriów kierowania geograficznego określonych w polu geo_target_constant. Jeśli zdefiniowano to ustawienie, nie będą kierowane reklamy na lokalizacje, które znajdują się poza podanymi identyfikatorami kryteriów.

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, w jaki Google Ads dopasowuje użytkowników do tych lokalizacji, korzystając z zaawansowanych opcji lokalizacji. Tymi ustawieniami zarządza się na stronie 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ści dodatniej możesz wybrać jedną z tych opcji, korzystając z wartości z PositiveGeoTargetTypeEnum:

  1. PRESENCE_OR_INTEREST (zalecana wartość domyślna):

    • Dociera do osób, które prawdopodobnie znajdują się w wybranych przez Ciebie lokalizacjach lub regularnie w nich bywają, PLUS do osób, które wykazały zainteresowanie wybranymi przez Ciebie lokalizacjami.
    • Zainteresowanie może być sygnalizowane przez wyszukiwane hasła, wcześniejsze wizyty lub treści związane z lokalizacją.
    • Ta opcja zapewnia najszerszy zasięg.

  2. PRESENCE:

    • Dociera tylko do osób, które prawdopodobnie znajdują się w wybranych lokalizacjach lub regularnie w nich przebywają.
    • 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.

Uwaga: inne wartości, np. SEARCH_INTEREST, zostały wycofane i nie można ich już ustawiać w przypadku większości typów kampanii.

Ustawienia kierowania wykluczającego (negative_geo_target_type)

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

  1. 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 pasują do Twojego kierowania pozytywnego.

Uwaga: wartość PRESENCE_OR_INTEREST nie jest zwykle obsługiwana w przypadku wykluczającego kierowania geograficznego w większości typów kampanii.

Zarządzanie zaawansowanymi opcjami lokalizacji

Możesz kontrolować te ustawienia, aktualizując obiekt Campaign.geo_target_type_setting.

Przykład: ustawianie kampanii tak, aby kierowała reklamy tylko na PRESENCE

Oto przykładowa struktura wywołania interfejsu API, które może modyfikować positive_geo_target_type. Kod zależy zawsze od języka biblioteki klienta.

// Conceptual structure for a Campaign update operation
operations {
  update {
    resource_name: "customers/{customer_id}/campaigns/{campaign_id}"
    geo_target_type_setting {
      positive_geo_target_type: PRESENCE
      // negative_geo_target_type remains at its default PRESENCE if not specified
    }
  }
  update_mask {
    paths: "geo_target_type_setting.positive_geo_target_type"
  }
}

Aby pobrać bieżące ustawienia, w zapytaniu wyszukiwania umieść 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ć kampanię do Twoich celów biznesowych.

Wstecz
Modyfikatory stawek
Dalej
Ustawienia kierowania