Penargetan lokasi

Panduan ini menjelaskan penargetan lokasi, dan cara menggunakan Google Ads API untuk menambahkan, mengambil, dan memperbarui penargetan lokasi untuk kampanye Anda.

Untuk mengetahui informasi tentang batas penargetan, lihat bagian Batas Penargetan di Tentang batas akun Google Ads.

Mengapa penargetan geografis penting?

Penargetan lokasi memungkinkan Anda menayangkan iklan kepada pengguna di wilayah geografis tertentu. Misalnya, Anda mengiklankan jaringan supermarket. Tanpa penargetan lokasi, iklan Anda akan ditampilkan di semua wilayah di seluruh dunia, dan iklan Anda mungkin menerima klik dari pengguna di wilayah tempat Anda tidak memiliki lokasi supermarket. Hal ini akan menimbulkan biaya tanpa memberikan kemungkinan laba atas investasi. Dengan penargetan lokasi, kampanye Anda hanya menampilkan iklan di wilayah tempat Anda memiliki supermarket yang buka. Pendekatan ini juga memungkinkan Anda menargetkan pelanggan yang menelusuri supermarket secara lokal.

Google Ads API memungkinkan Anda menargetkan iklan menurut negara, wilayah, atau kedekatan di sekitar titik geografis tertentu.

Menargetkan kampanye secara geografis untuk suatu wilayah

Anda dapat menargetkan kampanye ke wilayah geografis mana pun yang penargetan lokasinya didukung oleh Google Ads, seperti negara, negara bagian, kota, atau wilayah kode pos. Setiap lokasi yang dapat ditargetkan diidentifikasi secara unik oleh ID Kriteria. Anda dapat mencari ID kriteria menggunakan GeoTargetConstantService.SuggestGeoTargetConstants. resource_name setiap GeoTargetConstant memiliki format geoTargetConstants/{Criterion ID}. Misalnya, nilai resource_name negara bagian New York adalah geoTargetConstants/21167.

Anda dapat menambahkan target geografis ke kampanye menggunakan CampaignCriterionService (atau di tingkat grup iklan menggunakan AdGroupCriterion untuk jenis kampanye yang didukung, seperti kampanye Peningkat Permintaan dengan upgraded_targeting diaktifkan). Cuplikan kode berikut menunjukkan cara menargetkan kampanye Anda dengan ID kriteria.

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 terkadang menghentikan penggunaan beberapa kriteria lokasi karena berbagai alasan: lokasi dapat direstrukturisasi menjadi area yang lebih kecil atau lebih besar, perubahan geopolitik, dan sebagainya. Lihat kolom status objek GeoTargetConstant untuk menentukan apakah lokasi ENABLED atau REMOVAL_PLANNED.

Mencari berdasarkan nama lokasi

Anda juga dapat mencari ID kriteria berdasarkan nama lokasi menggunakan GeoTargetConstantService.SuggestGeoTargetConstants. Contoh kode berikut menunjukkan cara mencari ID kriteria lokasi berdasarkan nama lokasi.

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

Menargetkan kampanye untuk kedekatan dengan suatu lokasi

Terkadang, Anda mungkin ingin menargetkan lebih akurat daripada kota atau negara. Misalnya, Anda mungkin ingin mengiklankan supermarket dalam jarak 10 kilometer dari lokasi toko Anda. Dalam kasus seperti itu, Anda dapat menggunakan penargetan kedekatan. Kode untuk membuat target kedekatan mirip dengan menambahkan target lokasi, kecuali Anda harus membuat objek ProximityInfo bukan objek 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

Mengambil target geografis

Anda dapat mengambil target geografis untuk kampanye menggunakan GoogleAdsService.SearchStream. Menyertakan campaign_criterion.type dan campaign_criterion.resource_name dalam klausa SELECT memungkinkan Anda membedakan antara kriteria LOCATION dan PROXIMITY serta mencatat nama resource untuk pembaruan atau penghapusan berikutnya.

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

Memperbarui target geografis

Kriteria lokasi pada kampanye tidak dapat diubah setelah dibuat, sehingga memperbarui target geografis kampanye memerlukan penggantian target yang tidak digunakan dengan target baru dalam satu permintaan atomik CampaignCriterionService.MutateCampaignCriteria:

  1. Kueri kriteria LOCATION dan PROXIMITY kampanye yang ada menggunakan kueri GAQL di Mengambil target geografis.
  2. Bandingkan kriteria yang ada dengan daftar target yang Anda inginkan.
  3. Untuk setiap kriteria yang tidak digunakan, buat CampaignCriterionOperation dengan remove yang ditetapkan ke resource_name kriteria yang ada.
  4. Untuk setiap target lokasi atau kedekatan baru, buat CampaignCriterionOperation dengan create yang diisi dengan kriteria LocationInfo atau ProximityInfo baru.
  5. Teruskan operasi remove dan create dalam satu panggilan MutateCampaignCriteria sehingga transisi terjadi secara atomik.

Mengecualikan target geografis

Anda juga dapat mengecualikan LocationInfo, tetapi tidak ProximityInfo. Fitur ini paling berguna jika Anda ingin menargetkan wilayah, tetapi mengecualikan sub-wilayah (misalnya, untuk menargetkan seluruh Amerika Serikat, kecuali New York City). Untuk mengecualikan wilayah, tetapkan kolom negative di CampaignCriterion ke true.

Menargetkan beberapa wilayah geografis

Jika menggunakan LocationGroupInfo, Anda dapat mengaktifkan kampanye untuk menargetkan beberapa wilayah geografis yang berpusat pada lokasi yang ditentukan oleh aset lokasi atau difilter menurut wilayah geografis:

  • Kumpulan aset lokasi: Tetapkan enable_customer_level_location_asset_set = true (untuk menargetkan kumpulan aset lokasi pelanggan) atau location_group_asset_sets (untuk menargetkan nama resource AssetSet tertentu). Kedua kolom ini tidak dapat ditetapkan bersama-sama, dan tidak dapat digabungkan dengan geo_target_constants.
  • Radius dan unit: Radius di LocationGroupInfo menentukan wilayah melingkar di sekitar setiap lokasi dan memerlukan radius dan radius_units (LocationGroupRadiusUnitsEnum):
    • Saat menggunakan kumpulan aset lokasi (enable_customer_level_location_asset_set atau location_group_asset_sets), nilai radius_units yang didukung adalah MILLI_MILES dan METERS.
    • Saat memfilter menurut geo_target_constants (dengan maksimal satu ID kriteria diizinkan, dan kolom AssetSet tidak ditetapkan), nilai radius_units yang didukung adalah MILES dan METERS.

Opsi lokasi lanjutan dengan GeoTargetTypeSetting

Selain menentukan lokasi yang akan ditargetkan atau dikecualikan, Anda dapat menyempurnakan cara Google Ads mencocokkan pengguna dengan lokasi ini menggunakan opsi lokasi lanjutan. Setelan ini dikelola melalui Campaign.GeoTargetTypeSetting.

Setelan ini terdiri dari dua kolom:

  • positive_geo_target_type: Menentukan cara pengguna dicocokkan untuk lokasi yang Anda targetkan.
  • negative_geo_target_type: Menentukan cara pengguna dicocokkan untuk lokasi yang Anda kecualikan.

Setelan penargetan positif (positive_geo_target_type)

Anda dapat memilih dari opsi berikut untuk penargetan lokasi positif, menggunakan nilai dari PositiveGeoTargetTypeEnum:

  • PRESENCE_OR_INTEREST (Default yang direkomendasikan):

    • Menjangkau orang-orang yang kemungkinan berada di, atau sering berada di, target lokasi Anda, serta orang-orang yang telah menunjukkan minat terhadap target lokasi Anda.
    • Minat dapat ditandai dengan istilah penelusuran, kunjungan sebelumnya, atau konten yang digunakan terkait dengan lokasi.
    • Opsi ini memberikan jangkauan terluas.

  • PRESENCE:

    • Hanya menjangkau orang-orang yang kemungkinan berada secara fisik atau sering berada di lokasi yang ditarget.
    • Opsi ini lebih ketat dan berguna jika layanan atau produk Anda dibatasi secara ketat untuk orang-orang yang hadir secara fisik di suatu area.

Setelan penargetan negatif (negative_geo_target_type)

Untuk lokasi yang ingin dikecualikan, Anda menggunakan NegativeGeoTargetTypeEnum:

  • PRESENCE (Default yang direkomendasikan):
    • Mengecualikan orang-orang yang kemungkinan berada secara fisik di lokasi yang telah Anda kecualikan.
    • Orang-orang di luar area yang dikecualikan, meskipun tertarik dengan area tersebut, mungkin masih dapat melihat iklan Anda, asalkan mereka cocok dengan penargetan positif Anda.

Mengelola opsi lokasi lanjutan

Anda dapat mengontrol setelan ini dengan memperbarui objek Campaign.geo_target_type_setting. Contoh berikut menunjukkan struktur pembaruan CampaignOperation yang menetapkan positive_geo_target_type ke 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"
  }
}

Untuk mengambil setelan saat ini, sertakan campaign.geo_target_type_setting.positive_geo_target_type dan campaign.geo_target_type_setting.negative_geo_target_type dalam kueri penelusuran GoogleAdsService Anda.

Dengan mengonfigurasi setelan ini, Anda akan mendapatkan kontrol yang lebih mendetail atas siapa yang melihat iklan Anda berdasarkan hubungan mereka dengan lokasi geografis yang telah Anda tentukan, sehingga lebih selaras dengan sasaran bisnis Anda.

Praktik terbaik

  • Pilih PRESENCE jika produk atau layanan Anda dibatasi secara ketat untuk orang-orang yang hadir secara fisik di suatu lokasi. Misalnya, Anda mewajibkan pengguna untuk berada di toko atau mewajibkan pengiriman lokal.
  • Pilih PRESENCE_OR_INTEREST jika produk atau layanan Anda juga dapat bermanfaat bagi orang-orang yang tertarik dengan suatu lokasi, meskipun tidak hadir secara fisik. Misalnya, pengguna yang merencanakan liburan mungkin tertarik dengan hotel di kota tujuan mereka.
  • Gunakan penargetan lokasi negatif untuk menyempurnakan jangkauan. Jika Anda menargetkan Amerika Serikat dengan PRESENCE_OR_INTEREST, tetapi tidak mengirim ke negara bagian tertentu, Anda dapat mengecualikan negara bagian tersebut menggunakan negative=true pada kriteria LocationInfo. Jika digabungkan dengan negative_geo_target_type yang ditetapkan ke PRESENCE, hal ini akan mencegah iklan Anda ditampilkan kepada pengguna di negara bagian tersebut, sekaligus menjangkau pengguna di luar negara bagian tersebut yang mungkin tertarik dengan lokasi di Amerika Serikat.

Langkah berikutnya

  • Menyesuaikan bid menurut kriteria dalam panduan Pengubah bid.
Sebelumnya
Pengubah bid
Berikutnya
Setelan penargetan