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.

Więcej informacji 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ę Twoje reklamy wyświetlałyby się we wszystkich regionach na świecie i mogłyby otrzymywać kliknięcia od użytkowników z regionów, w których nie masz supermarketów. Generuje to koszty, nie dając możliwości zwrotu z inwestycji. Dzięki kierowaniu na lokalizację Twoje kampanie wyświetlają reklamy tylko w regionach, w których masz otwarte supermarkety. To podejście pozwala też bezpośrednio kierować reklamy do klientów, którzy szukają supermarketów w swojej okolicy.

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

Kampanie kierowane geograficznie na 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 znaleźć za pomocą GeoTargetConstantService.SuggestGeoTargetConstants. resource_name każdego GeoTargetConstant ma postać geoTargetConstants/{Criterion ID}. Na przykład wartość resource_name stanu Nowy Jork to geoTargetConstants/21167.

Do kampanii możesz dodawać lokalizacje docelowe za pomocą CampaignCriterionService (lub na poziomie grupy reklam za pomocą AdGroupCriterion w przypadku obsługiwanych typów kampanii, np. kampanii generujących popyt z włączoną opcją upgraded_targeting). Poniższy fragment kodu pokazuje, jak kierować kampanię na podstawie 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

Z różnych powodów Google może czasami wycofywać niektóre kryteria lokalizacji. Może to być spowodowane np. zmianą struktury lokalizacji na mniejsze lub większe obszary albo zmianami geopolitycznymi. Aby sprawdzić, czy lokalizacja ma stan ENABLED czy REMOVAL_PLANNED, zapoznaj się z polem status obiektu GeoTargetConstant.

Wyszukiwanie według nazwy lokalizacji

Identyfikator kryterium możesz też znaleźć według nazwy lokalizacji za pomocą GeoTargetConstantService.SuggestGeoTargetConstants. Poniższy przykład kodu pokazuje, jak znaleźć 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.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 obszar wokół lokalizacji

Czasami możesz chcieć kierować reklamy jeszcze dokładniej niż na miasto lub kraj. Możesz na przykład chcieć reklamować swoje supermarkety w promieniu 10 kilometrów od lokalizacji sklepu. W takich przypadkach możesz użyć kierowania na zbliżony obszar. Kod tworzenia kierowania na zbliżony obszar jest podobny do kodu dodawania kierowania na lokalizację, z tą różnicą, że zamiast obiektu LocationInfomusisz 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::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 lokalizacji docelowych

Docelowe regiony geograficzne kampanii możesz pobrać za pomocą GoogleAdsService.SearchStream. Uwzględnienie campaign_criterion.type i campaign_criterion.resource_name w klauzuli SELECT umożliwia rozróżnianie kryteriów LOCATION i PROXIMITY oraz rejestrowanie nazw zasobów na potrzeby kolejnych 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

Po utworzeniu kryteria lokalizacji w kampanii są niezmienne, dlatego aby zaktualizować lokalizacje docelowe kampanii, musisz zastąpić przestarzałe lokalizacje nowymi w jednym niepodzielnym CampaignCriterionService.MutateCampaignCriteria żądaniu:

  1. Za pomocą zapytania GAQL w sekcji Pobieranie celów kierowania geograficznego wyszukaj dotychczasowe kryteria LOCATION i PROXIMITY kampanii.
  2. Porównaj dotychczasowe kryteria z listą docelową.
  3. W przypadku każdego przestarzałego kryterium utwórz CampaignCriterionOperation z ustawioną wartością remove na resource_name dotychczasowego kryterium.
  4. W przypadku każdej nowej lokalizacji docelowej lub zbliżonego obszaru docelowego utwórz CampaignCriterionOperation z wypełnionym polem create nowym kryterium LocationInfo lub ProximityInfo.
  5. Przekaż operacje remove i create w jednym wywołaniu MutateCampaignCriteria, aby przejście nastąpiło niepodzielnie.

Wykluczanie lokalizacji docelowych

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 filtrowane 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). Tych 2 pól nie można ustawić razem ani połączyć z geo_target_constants.
  • Promień i jednostki: promień w LocationGroupInfo określa okrągły obszar wokół każdej lokalizacji i wymaga zarówno radius, jak i radius_units (LocationGroupRadiusUnitsEnum):
    • W przypadku korzystania z 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.
    • W przypadku filtrowania według geo_target_constants (gdzie dozwolony jest co najwyżej jeden identyfikator kryterium, a pola AssetSet nie są ustawione) obsługiwane wartości radius_units to MILES i METERS.

Zaawansowane opcje lokalizacji z GeoTargetTypeSetting

Oprócz określania lokalizacji, na które chcesz kierować reklamy lub które chcesz wykluczyć, możesz też doprecyzować, jak Google Ads dopasowuje użytkowników do tych lokalizacji, za pomocą zaawansowanych opcji lokalizacji. Te ustawienia są zarządzane za pomocą 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 kierowania niewykluczającego na lokalizację możesz wybrać jedną z tych opcji, używając wartości z PositiveGeoTargetTypeEnum:

  • 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ą, a także do osób, które wykazały zainteresowanie tymi 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.

  • PRESENCE:

    • Dociera tylko do osób, które prawdopodobnie znajdują się w wybranych przez Ciebie lokalizacjach lub regularnie w nich bywają.
    • Ta opcja jest bardziej restrykcyjna i przydatna, jeśli Twoje usługi lub produkty są ściśle ograniczone do osób fizycznie obecnych w danym obszarze.

Ustawienia kierowania wykluczającego (negative_geo_target_type)

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

  • PRESENCE (zalecana wartość domyślna):
    • 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 niewykluczającego.

Zarządzanie zaawansowanymi opcjami lokalizacji

Tymi ustawieniami możesz sterować, 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, w zapytaniu wyszukiwania GoogleAdsService uwzględnij campaign.geo_target_type_setting.positive_geo_target_type i campaign.geo_target_type_setting.negative_geo_target_type.

Konfigurując te ustawienia, zyskujesz większą kontrolę nad tym, kto widzi Twoje reklamy, na podstawie jego powiązania z określonymi przez Ciebie położeniami geograficznymi, co pozwala lepiej realizować cele biznesowe.

Sprawdzone metody

  • Wybierz PRESENCE jeśli Twój produkt lub usługa jest ściśle ograniczona do osób fizycznie obecnych w danej lokalizacji. Możesz na przykład wymagać od użytkowników, aby byli w sklepie lub korzystali z dostawy lokalnej.
  • Wybierz PRESENCE_OR_INTEREST jeśli Twój produkt lub usługa może też przynieść korzyści osobom zainteresowanym daną lokalizacją, nawet jeśli nie są w niej fizycznie obecne. Na przykład użytkownik planujący wakacje może być zainteresowany hotelami w mieście docelowym.
  • Aby zawęzić zasięg, użyj kierowania wykluczającego na lokalizację. 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 za pomocą negative=true w kryterium LocationInfo. W połączeniu z negative_geo_target_type ustawionym 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 Stanach Zjednoczonych.

Co dalej?

Wstecz
Modyfikatory stawek
Dalej
Ustawienia kierowania