Kierowanie na lokalizację

Z tego przewodnika dowiesz się, czym jest kierowanie na lokalizację oraz 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 na koncie 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, że reklamujesz sieć supermarketów. Bez kierowania na lokalizację reklamy wyświetlałyby się we wszystkich regionach na świecie i mogłyby być klikane przez użytkowników z regionów, w których nie masz supermarketów. Generuje to koszty, ale nie daje możliwości uzyskania zwrotu z inwestycji. Dzięki kierowaniu na lokalizację kampanie wyświetlają reklamy tylko w regionach, w których masz otwarte supermarkety. Takie podejście pozwala też bezpośrednio kierować reklamy na klientów, którzy szukają supermarketów w okolicy.

Interfejs Google Ads API umożliwia kierowanie reklam na kraj, region lub obszar wokół określonego punktu geograficznego.

Kampanie kierowane geograficznie na dany region

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

Cele kierowania geograficznego możesz dodawać do kampanii za pomocą kolumny CampaignCriterionService (lub na poziomie grupy reklam za pomocą kolumny AdGroupCriterion w przypadku obsługiwanych typów kampanii, np. kampanii generujących popyt z włączonym ustawieniem 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::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

Google może czasami wycofać niektóre kryteria lokalizacji z różnych powodów, np. ze względu na zmiany geopolityczne lub podział lokalizacji na mniejsze lub większe obszary. Sprawdź pole status obiektu GeoTargetConstant, aby dowiedzieć się, czy lokalizacja jest ENABLED czy REMOVAL_PLANNED.

Wyszukiwanie według nazwy lokalizacji

Identyfikator kryterium możesz też wyszukać według nazwy lokalizacji, korzystając z GeoTargetConstantService.SuggestGeoTargetConstants. Poniższy przykładowy kod 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());
    }
  }
}

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

Kierowanie kampanii na obszar 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 kilometrów od lokalizacji sklepu. W takich przypadkach możesz użyć kierowania na obszar zbliżony do lokalizacji. Kod do tworzenia celu zbliżeniowego 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();
}

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

Pobieranie celów geograficznych

Cele kierowania geograficznego w kampanii możesz pobrać za pomocą GoogleAdsService.SearchStream. Uwzględnienie pól campaign_criterion.type i campaign_criterion.resource_name w klauzuli SELECT pozwala odróżnić kryteria LOCATION i PROXIMITY oraz rejestrować nazwy 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 celów kierowania geograficznego

Kryteria lokalizacji w kampanii są niezmienne po jej utworzeniu, więc aktualizacja docelowych regionów geograficznych kampanii wymaga zastąpienia nieaktualnych regionów nowymi w jednym żądaniu niepodzielnym CampaignCriterionService.MutateCampaignCriteria:

  1. Sprawdź dotychczasowe kryteria LOCATION i PROXIMITY kampanii, korzystając z zapytania GAQL w sekcji Pobieranie docelowych regionów geograficznych.
  2. Porównaj dotychczasowe kryteria z listą docelową.
  3. Dla każdego nieaktualnego kryterium utwórz obiekt CampaignCriterionOperation z polem remove ustawionym na wartość resource_name istniejącego kryterium.
  4. Dla każdej nowej lokalizacji lub lokalizacji zbliżonej utwórz obiekt CampaignCriterionOperation z polem create zawierającym nowe 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 kierowania geograficznego

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.

kierować reklamy na wiele regionów geograficznych,

Jeśli używasz LocationGroupInfo, możesz włączyć w kampanii kierowanie na wiele regionów geograficznych, których centrum stanowią lokalizacje określone przez komponenty z lokalizacją lub odfiltrowane według regionu geograficznego:

  • Zestawy komponentów z lokalizacją: ustaw wartość 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). Tych 2 pól nie można ustawić razem i żadnego z nich nie można połączyć z polem geo_target_constants.
  • Promień i jednostki: promień w kolumnie LocationGroupInfo definiuje okrągły obszar wokół każdej lokalizacji i wymaga podania wartości w kolumnach radius i radius_units (LocationGroupRadiusUnitsEnum):
    • Jeśli używasz zestawów komponentów z lokalizacją (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 (gdy 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 przypadku: GeoTargetTypeSetting

Oprócz określania lokalizacji, na które chcesz kierować reklamy lub które chcesz wykluczać, możesz też doprecyzować, jak Google Ads ma dopasowywać użytkowników do tych lokalizacji, korzystając z zaawansowanych opcji lokalizacji. Tymi ustawieniami zarządza Campaign.GeoTargetTypeSetting.

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

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

Ustawienia kierowania niewykluczającego (positive_geo_target_type)

W przypadku pozytywnego celu lokalizacji możesz wybrać jedną z tych opcji, używając wartości z PositiveGeoTargetTypeEnum:

  • PRESENCE_OR_INTEREST (zalecane ustawienie domyślne):

    • Dociera do osób, które prawdopodobnie znajdują się w wybranych przez Ciebie lokalizacjach lub regularnie w nich bywają, a także do osób, które są nimi zainteresowane.
    • Zainteresowanie może być sygnalizowane przez wyszukiwane słowa, 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ą przeznaczone wyłącznie dla osób fizycznie obecnych na danym obszarze.

Ustawienia kierowania wykluczającego (negative_geo_target_type)

W przypadku lokalizacji, które chcesz wykluczyć, użyj kolumny 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 pasują do 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ę aktualizacji CampaignOperation, 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, uwzględnij campaign.geo_target_type_setting.positive_geo_target_type i campaign.geo_target_type_setting.negative_geo_target_type w zapytaniu GoogleAdsService.

Skonfigurowanie tych ustawień pozwala uzyskać bardziej szczegółową kontrolę nad tym, kto widzi Twoje reklamy, na podstawie relacji użytkowników z określonymi przez Ciebie położeniami geograficznymi, co pozwala lepiej dopasować reklamy do celów biznesowych.

Sprawdzone metody

  • Wybierz PRESENCE, jeśli Twój produkt lub Twoja usługa są przeznaczone wyłącznie dla osób fizycznie obecnych w danej lokalizacji. Załóżmy na przykład, że wymagasz od użytkowników, aby byli w sklepie, lub wymagasz dostawy lokalnej.
  • Wybierz PRESENCE_OR_INTEREST, jeśli Twój produkt lub usługa może być przydatna również dla osób zainteresowanych daną lokalizacją, nawet jeśli nie przebywają w niej fizycznie. Na przykład użytkownik planujący wakacje może być zainteresowany hotelami w mieście, do którego się wybiera.
  • Używaj kierowania na wykluczone lokalizacje, aby zawęzić zasięg. Jeśli kierujesz reklamy na Stany Zjednoczone za pomocą PRESENCE_OR_INTEREST, ale nie wysyłasz produktów do określonego stanu, możesz wykluczyć ten stan, używając negative=true w kryterium LocationInfo. W połączeniu z ustawieniem negative_geo_target_type o wartości PRESENCE zapobiega to wyświetlaniu reklam użytkownikom w danym stanie, ale pozwala docierać do użytkowników spoza tego stanu, którzy mogą być zainteresowani lokalizacjami w USA.

Co dalej?

Wstecz
Modyfikatory stawek
Dalej
Ustawienia kierowania