위치 타겟팅

이 가이드에서는 위치 타겟팅과 Google Ads API를 사용하여 캠페인의 위치 타겟팅을 추가, 검색, 업데이트하는 방법을 설명합니다.

타겟팅 한도에 대한 자세한 내용은 Google Ads 계정 한도 정보의 타겟팅 한도 섹션을 참고하세요.

지역 타겟팅이 중요한 이유는 무엇인가요?

위치 타겟팅을 사용하면 특정 지리적 지역의 사용자에게 광고를 게재할 수 있습니다. 예를 들어 슈퍼마켓 체인을 광고한다고 가정해 보겠습니다. 위치 타겟팅이 없으면 전 세계 모든 지역에 광고가 게재되며, 슈퍼마켓이 없는 지역의 사용자가 광고를 클릭할 수 있습니다. 이러한 상황은 비용을 발생시키지만 투자 수익을 창출할 가능성은 없습니다. 위치 타겟팅을 사용하면 영업 중인 슈퍼마켓이 있는 지역에만 캠페인에서 광고를 게재합니다. 이 방법을 사용하면 지역에서 슈퍼마켓을 검색하는 고객을 직접 타겟팅할 수도 있습니다.

Google Ads API를 사용하면 국가, 지역 또는 특정 지리적 지점 주변의 근접성을 기준으로 광고를 타겟팅할 수 있습니다.

광고를 지리적 위치에 타겟팅하는 방법을 자세히 알아보세요.

지역별로 캠페인 지역 타겟팅

국가, 주, 도시, 우편 지역 등 Google Ads에서 위치 타겟팅을 지원하는 모든 지리적 지역에 캠페인을 타겟팅할 수 있습니다. 타겟팅 가능한 각 위치는 기준 ID로 고유하게 식별됩니다. GeoTargetConstantService.SuggestGeoTargetConstants를 사용하여 기준 ID를 조회할 수 있습니다. 각 GeoTargetConstant의 resource_name은 geoTargetConstants/{Criterion ID} 형식입니다. 예를 들어 뉴욕주의 resource_name 값은 geoTargetConstants/21167입니다.

CampaignCriterionService를 사용하여 캠페인에 지역 타겟을 추가할 수 있습니다. 다음 코드 스니펫은 기준 ID로 캠페인을 타겟팅하는 방법을 보여줍니다.

자바

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에서는 다양한 이유로 일부 위치 기준을 단계적으로 중단할 수 있습니다. 예를 들어 위치가 더 작거나 큰 지역으로 재구성되거나 지정학적 변화가 있을 수 있습니다. 위치가 ENABLED인지 REMOVAL_PLANNED인지 확인하려면 GeoTargetConstant 객체의 status 필드를 참고하세요.

위치 이름으로 검색

GeoTargetConstantService.SuggestGeoTargetConstants를 사용하여 위치 이름으로 기준 ID를 조회할 수도 있습니다. 다음 코드 예에서는 위치 이름으로 위치 기준 ID를 조회하는 방법을 보여줍니다.

자바

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

위치 인접도에 따라 캠페인 타겟팅

도시나 국가보다 더 정확하게 타겟팅해야 하는 경우도 있습니다. 예를 들어 매장 위치에서 10km 이내의 슈퍼마켓을 광고할 수 있습니다. 이러한 경우 근접성 타겟팅을 사용할 수 있습니다. 근접도 타겟을 만드는 코드는 위치 타겟을 추가하는 것과 비슷하지만 LocationInfo 객체 대신 ProximityInfo 객체를 만들어야 합니다.

자바

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

지역 타겟 가져오기

GoogleAdsService.SearchStream를 사용하여 캠페인의 지역 타겟을 가져올 수 있습니다. 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)

지역 타겟 업데이트

캠페인의 위치 타겟을 업데이트하려면 기존 지역 타겟 목록을 가져와 새 타겟 목록과 비교해야 합니다. 그런 다음 remove 작업을 사용하여 필요하지 않은 타겟을 삭제하고 create 작업을 사용하여 필요한 새 지역 타겟을 추가할 수 있습니다 (기존 캠페인에는 없음).

지역 타겟 제외

LocationInfo는 제외할 수 있지만 ProximityInfo는 제외할 수 없습니다. 이 기능은 지역을 타겟팅하되 하위 지역을 제외하려는 경우 (예: 뉴욕시를 제외한 미국 전체를 타겟팅)에 가장 유용합니다. 지역을 제외하려면 CampaignCriterion의 negative 필드를 true로 설정합니다.

여러 지리적 리전 타겟팅

LocationGroupInfo를 사용하면 캠페인에서 여러 지리적 리전을 타겟팅할 수 있습니다. 지역은 캠페인의 위치 광고 확장으로 정의된 위치를 중심으로 합니다.

LocationGroupInfo에 정의된 반지름은 각 위치 주변에 원형 영역을 부여하며 radius 객체, 길이, 미터 또는 마일 (LocationGroupRadiusUnitsEnum)일 수 있는 radius_units로 구성됩니다.

LocationGroupInfo의 위치는 geo_target_constant 필드에 지정된 지리적 타겟팅 기준 ID 목록으로 필터링할 수 있습니다. 정의된 경우 지정된 기준 ID 외부에 있는 위치는 타겟팅되지 않습니다.

GeoTargetTypeSetting의 고급 위치 옵션

타겟팅하거나 제외할 위치를 지정하는 것 외에도 고급 위치 옵션을 사용하여 Google Ads에서 사용자를 이러한 위치와 일치시키는 방법을 세부적으로 조정할 수 있습니다. 이러한 설정은 Campaign.GeoTargetTypeSetting을 통해 관리됩니다.

이 설정은 두 개의 필드로 구성됩니다.

  • positive_geo_target_type: 사용자가 타겟팅하는 위치에 대해 사용자가 매칭되는 방식을 결정합니다.
  • negative_geo_target_type: 제외한 위치에 대해 사용자가 매칭되는 방식을 결정합니다.

포함 타겟팅 설정 (positive_geo_target_type)

PositiveGeoTargetTypeEnum의 값을 사용하여 긍정적 위치 타겟팅에 다음 옵션 중에서 선택할 수 있습니다.

  1. PRESENCE_OR_INTEREST (권장 기본값):

    • 타겟 지역에 거주하고 있을 가능성이 크거나 자주 방문하는 사용자 PLUS 타겟 지역에 관심을 보인 사용자에게 도달합니다.
    • 관심은 검색어, 이전 방문 또는 위치와 관련된 소비된 콘텐츠로 표시될 수 있습니다.
    • 이 옵션은 가장 넓은 도달범위를 제공합니다.

  2. PRESENCE:

    • 타겟 위치에 실제로 거주하거나 타겟 위치를 정기적으로 방문할 가능성이 높은 사용자에게만 도달합니다.
    • 이 옵션은 서비스 또는 제품이 특정 지역에 있는 사용자에게만 제공되는 경우에 더 제한적이고 유용합니다.

참고: SEARCH_INTEREST과 같은 다른 값은 지원이 중단되어 대부분의 캠페인 유형에서 더 이상 설정할 수 없습니다.

제외 타겟팅 설정 (negative_geo_target_type)

제외하려는 위치의 경우 NegativeGeoTargetTypeEnum를 사용합니다.

  1. PRESENCE (권장 기본값):
    • 제외한 위치에 실제 거주할 가능성이 높은 사용자를 제외합니다.
    • 제외 지역 외부에 있는 사용자는 해당 지역에 관심이 있더라도 긍정적 타겟팅과 일치하는 경우 광고가 계속 게재됩니다.

참고: 대부분의 캠페인 유형에서 PRESENCE_OR_INTEREST 값은 일반적으로 제외 지역 타겟팅에 지원되지 않습니다.

고급 위치 옵션 관리

Campaign.geo_target_type_setting 객체를 업데이트하여 이러한 설정을 제어할 수 있습니다.

예: PRESENCE만 타겟팅하도록 캠페인 설정

다음은 positive_geo_target_type를 수정하기 위해 API 호출을 구조화하는 방법의 개념적 예입니다. 정확한 코드는 클라이언트 라이브러리 언어에 따라 다릅니다.

// 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"
  }
}

현재 설정을 가져오려면 GoogleAdsService 검색어에 campaign.geo_target_type_setting.positive_geo_target_type 및 campaign.geo_target_type_setting.negative_geo_target_type를 포함하세요.

이러한 설정을 구성하면 지정한 지리적 위치와의 관계에 따라 광고를 보는 사용자를 더 세부적으로 관리하여 비즈니스 목표에 더 가깝게 맞출 수 있습니다.

이전
입찰가 조정
다음
타겟팅 설정