जगह के हिसाब से टारगेटिंग

इस गाइड में, जगह के हिसाब से टारगेटिंग के बारे में बताया गया है. साथ ही, यह भी बताया गया है कि अपने कैंपेन के लिए, जगह के हिसाब से टारगेटिंग जोड़ने, उसे वापस पाने, और अपडेट करने के लिए, Google Ads API का इस्तेमाल कैसे किया जा सकता है.

टारगेटिंग की सीमाओं के बारे में जानकारी के लिए, Google Ads खाते की सीमाओं के बारे में जानकारी लेख में, टारगेटिंग की सीमाओं वाला सेक्शन देखें.

इलाके के हिसाब से टारगेट करना क्यों ज़रूरी है?

जगह के हिसाब से टारगेटिंग की मदद से, किसी खास भौगोलिक इलाके में रहने वाले उपयोगकर्ताओं को विज्ञापन दिखाए जा सकते हैं. उदाहरण के लिए, मान लें कि सुपरमार्केट की किसी चेन का विज्ञापन दिखाया जा रहा है. जगह के हिसाब से टारगेटिंग के बिना, आपके विज्ञापन दुनिया भर के सभी इलाकों में दिखेंगे. साथ ही, आपके विज्ञापनों पर उन इलाकों के उपयोगकर्ताओं के क्लिक मिल सकते हैं जहां आपके सुपरमार्केट की कोई जगह नहीं है. इससे लागत तो बढ़ती है, लेकिन निवेश पर रिटर्न मिलने की संभावना नहीं होती. जगह के हिसाब से टारगेटिंग की मदद से, आपके कैंपेन सिर्फ़ उन इलाकों में विज्ञापन दिखाते हैं जहां आपके सुपरमार्केट खुले हैं. इस तरीके से, उन ग्राहकों को सीधे तौर पर टारगेट किया जा सकता है जो स्थानीय तौर पर सुपरमार्केट खोज रहे हैं.

Google Ads API की मदद से, देश, इलाके या किसी खास भौगोलिक जगह के आस-पास के हिसाब से विज्ञापनों को टारगेट किया जा सकता है.

किसी इलाके के लिए, इलाके के हिसाब से टारगेट करने वाले कैंपेन

कैंपेन को किसी भी ऐसी भौगोलिक जगह के लिए टारगेट किया जा सकता है जिसके लिए Google Ads, जगह के हिसाब से टारगेटिंग की सुविधा देता है. जैसे, कोई देश, राज्य, शहर या पिन कोड वाला इलाका. टारगेट की जा सकने वाली हर जगह की पहचान, क्राइटेरियन आईडी से की जाती है. GeoTargetConstantService.SuggestGeoTargetConstants का इस्तेमाल करके, क्राइटेरिया आईडी देखा जा सकता है. हर GeoTargetConstant का resource_name, geoTargetConstants/{Criterion ID} के फ़ॉर्मैट में होता है. उदाहरण के लिए, न्यूयॉर्क राज्य के लिए resource_name की वैल्यू geoTargetConstants/21167 है.

CampaignCriterionService का इस्तेमाल करके, अपने कैंपेन में इलाके के हिसाब से टारगेट जोड़े जा सकते हैं. इसके अलावा, विज्ञापन ग्रुप लेवल पर AdGroupCriterion का इस्तेमाल करके भी ऐसा किया जा सकता है. हालांकि, ऐसा सिर्फ़ उन कैंपेन टाइप के लिए किया जा सकता है जो इस सुविधा के साथ काम करते हैं. जैसे, मांग बढ़ाने में मदद करने वाले कैंपेन, जिनमें upgraded_targeting चालू है. यहां दिए गए कोड स्निपेट से पता चलता है कि मानदंड आईडी की मदद से, अपने कैंपेन को कैसे टारगेट किया जा सकता है.

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 कभी-कभी कई वजहों से, जगह के हिसाब से टारगेटिंग की कुछ शर्तों को हटा सकता है: जगह को छोटे या बड़े इलाकों में फिर से बांटा जा सकता है, जियो-पॉलिटिकल बदलाव वगैरह. GeoTargetConstant ऑब्जेक्ट के status फ़ील्ड को देखें. इससे यह पता चलता है कि कोई जगह ENABLED है या REMOVAL_PLANNED.

जगह के नाम से खोजना

GeoTargetConstantService.SuggestGeoTargetConstants का इस्तेमाल करके, जगह के नाम के हिसाब से भी क्राइटेरियन आईडी खोजा जा सकता है. यहां दिए गए कोड के उदाहरण से पता चलता है कि जगह के नाम के हिसाब से, जगह की जानकारी देने वाले क्राइटेरिया आईडी को कैसे खोजा जा सकता है.

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

किसी जगह के आस-पास के इलाकों को टारगेट करने के लिए कैंपेन

कभी-कभी ऐसा हो सकता है कि आपको किसी शहर या देश के बजाय, ज़्यादा सटीक तरीके से टारगेट करना हो. उदाहरण के लिए, हो सकता है कि आपको अपनी दुकान की जगह से 10 किलोमीटर के दायरे में मौजूद सुपरमार्केट के विज्ञापन दिखाने हों. ऐसे मामलों में, प्रॉक्सिमटी टारगेटिंग का इस्तेमाल किया जा सकता है. आस-पास की जगह को टारगेट करने वाला कोड बनाने का तरीका, टारगेट की गई जगह को जोड़ने जैसा ही है. हालांकि, आपको LocationInfo ऑब्जेक्ट के बजाय, 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

इलाके के हिसाब से टारगेट करने की सुविधा को वापस पाना

GoogleAdsService.SearchStream का इस्तेमाल करके, किसी कैंपेन के लिए इलाके के हिसाब से टारगेट किए गए विज्ञापन वापस पाए जा सकते हैं. SELECT क्लॉज़ में campaign_criterion.type और campaign_criterion.resource_name को शामिल करने से, LOCATION और PROXIMITY की शर्तों के बीच अंतर किया जा सकता है. साथ ही, बाद में अपडेट करने या हटाने के लिए, संसाधन के नाम रिकॉर्ड किए जा सकते हैं.

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

जियो-टारगेट अपडेट करना

कैंपेन बनाने के बाद, उसमें जगह की जानकारी की शर्तें नहीं बदली जा सकतीं. इसलिए, कैंपेन के लिए इलाके के हिसाब से टारगेट करने की जानकारी को अपडेट करने के लिए, पुरानी जानकारी को नई जानकारी से बदलना होगा. इसके लिए, एक ही CampaignCriterionService.MutateCampaignCriteria अनुरोध करना होगा:

  1. इलाके के हिसाब से टारगेट करने की सुविधा को वापस पाएं में GAQL क्वेरी का इस्तेमाल करके, कैंपेन की मौजूदा LOCATION और PROXIMITY शर्तों के बारे में क्वेरी करें.
  2. मौजूदा शर्तों की तुलना, टारगेट की जाने वाली सूची से करें.
  3. हर पुराने मानदंड के लिए, CampaignCriterionOperation बनाएं. इसमें remove को मौजूदा मानदंड के resource_name पर सेट करें.
  4. टारगेट की गई हर नई जगह या आस-पास की जगह के लिए, CampaignCriterionOperation बनाएं. इसमें create को नई LocationInfo या ProximityInfo शर्त के साथ पॉप्युलेट करें.
  5. remove और create, दोनों कार्रवाइयों को एक ही MutateCampaignCriteria कॉल में पास करें, ताकि ट्रांज़िशन अपने-आप हो जाए.

इलाके के हिसाब से टारगेट करने की सुविधा को बाहर रखना

LocationInfo को भी बाहर रखा जा सकता है, लेकिन ProximityInfo को नहीं. यह सुविधा तब सबसे ज़्यादा काम की होती है, जब आपको किसी इलाके को टारगेट करना हो, लेकिन उसके किसी उप-इलाके को बाहर रखना हो. उदाहरण के लिए, न्यूयॉर्क शहर को छोड़कर पूरे अमेरिका को टारगेट करना हो. किसी क्षेत्र को बाहर रखने के लिए, CampaignCriterion में negative फ़ील्ड को true पर सेट करें.

एक से ज़्यादा देशों या इलाकों को टारगेट करना

LocationGroupInfo का इस्तेमाल करने पर, किसी कैंपेन को कई भौगोलिक क्षेत्रों को टारगेट करने के लिए चालू किया जा सकता है. ये क्षेत्र, लोकेशन ऐसेट से तय की गई जगहों या किसी भौगोलिक क्षेत्र के हिसाब से फ़िल्टर की गई जगहों पर आधारित होते हैं:

  • लोकेशन ऐसेट सेट: enable_customer_level_location_asset_set = true (ग्राहक के लोकेशन ऐसेट सेट को टारगेट करने के लिए) या location_group_asset_sets (खास AssetSet रिसॉर्स नेम को टारगेट करने के लिए) सेट करें. इन दोनों फ़ील्ड को एक साथ सेट नहीं किया जा सकता. साथ ही, इनमें से किसी को भी geo_target_constants के साथ नहीं जोड़ा जा सकता.
  • दायरा और इकाइयां: LocationGroupInfo पर मौजूद दायरा, हर जगह के आस-पास के गोलाकार इलाके को तय करता है. इसके लिए, radius और radius_units (LocationGroupRadiusUnitsEnum) दोनों की ज़रूरत होती है:
    • लोकेशन ऐसेट सेट (enable_customer_level_location_asset_set या location_group_asset_sets) का इस्तेमाल करते समय, radius_units के लिए MILLI_MILES और METERS वैल्यू का इस्तेमाल किया जा सकता है.
    • geo_target_constants के हिसाब से फ़िल्टर करते समय, radius_units के लिए इस्तेमाल की जा सकने वाली वैल्यू MILES और METERS हैं. हालांकि, इसके लिए ज़रूरी है कि ज़्यादा से ज़्यादा एक क्राइटेरियन आईडी की अनुमति हो और AssetSet फ़ील्ड सेट न किए गए हों.

GeoTargetTypeSetting के साथ जगह के बेहतर विकल्प

टारगेट करने या बाहर रखने के लिए जगहों की जानकारी देने के अलावा, Google Ads में जगह की जानकारी के बेहतर विकल्पों का इस्तेमाल करके, यह तय किया जा सकता है कि उपयोगकर्ताओं को इन जगहों से कैसे मैच किया जाए. इन सेटिंग को Campaign.GeoTargetTypeSetting से मैनेज किया जाता है.

इस सेटिंग में दो फ़ील्ड होते हैं:

  • positive_geo_target_type: इससे यह तय होता है कि उपयोगकर्ताओं को आपकी टारगेट की गई जगहों के हिसाब से कैसे मैच किया जाए.
  • negative_geo_target_type: इससे यह तय होता है कि उपयोगकर्ताओं को आपकी बाहर रखी गई जगहों के लिए कैसे मैच किया जाए.

पॉज़िटिव टारगेटिंग की सेटिंग (positive_geo_target_type)

PositiveGeoTargetTypeEnum की वैल्यू का इस्तेमाल करके, शामिल की जाने वाली जगहों की टारगेटिंग के लिए, इनमें से कोई भी विकल्प चुना जा सकता है:

  • PRESENCE_OR_INTEREST (सुझाया गया डिफ़ॉल्ट):

    • इससे उन लोगों तक पहुंचा जा सकता है जो टारगेट की गई जगहों पर मौजूद हैं या नियमित रूप से वहां मौजूद होते हैं. साथ ही, उन लोगों तक भी पहुंचा जा सकता है जिन्होंने टारगेट की गई जगहों में दिलचस्पी दिखाई है.
    • दिलचस्पी का पता, खोज के लिए इस्तेमाल हुए शब्दों, पिछली विज़िट या जगह से जुड़े कॉन्टेंट से लगाया जा सकता है.
    • इस विकल्प से, सबसे ज़्यादा लोगों तक पहुंचा जा सकता है.

  • PRESENCE:

    • यह विकल्प सिर्फ़ उन लोगों तक पहुंचता है जो टारगेट की जाने वाली जगहों पर मौजूद हैं या नियमित रूप से वहां मौजूद होते हैं.
    • यह विकल्प ज़्यादा पाबंदी वाला और तब ज़्यादा काम का होता है, जब आपकी सेवाएं या प्रॉडक्ट किसी इलाके में मौजूद लोगों के लिए ही उपलब्ध हों.

नेगेटिव टारगेटिंग की सेटिंग (negative_geo_target_type)

जिन जगहों को शामिल नहीं करना है उनके लिए, NegativeGeoTargetTypeEnum का इस्तेमाल करें:

  • PRESENCE (सुझाया गया डिफ़ॉल्ट):
    • उन लोगों को टारगेटिंग से बाहर रखा जाता है जो टारगेटिंग से बाहर रखी गई जगहों पर मौजूद हो सकते हैं.
    • बाहर रखी गई जगहों से बाहर मौजूद लोगों को अब भी आपके विज्ञापन दिख सकते हैं. भले ही, वे उन जगहों में दिलचस्पी रखते हों. हालांकि, ऐसा तब होगा, जब वे आपकी पॉज़िटिव टारगेटिंग से मैच करते हों.

जगह के हिसाब से टारगेटिंग के बेहतर विकल्प मैनेज करना

Campaign.geo_target_type_setting ऑब्जेक्ट को अपडेट करके, इन सेटिंग को कंट्रोल किया जा सकता है. यहां दिए गए उदाहरण में, CampaignOperation के अपडेट का स्ट्रक्चर दिखाया गया है. इसमें positive_geo_target_type को 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"
  }
}

मौजूदा सेटिंग फ़ेच करने के लिए, अपनी GoogleAdsService सर्च क्वेरी में campaign.geo_target_type_setting.positive_geo_target_type और campaign.geo_target_type_setting.negative_geo_target_type शामिल करें.

इन सेटिंग को कॉन्फ़िगर करके, आपको इस बात पर ज़्यादा कंट्रोल मिलता है कि आपके विज्ञापन किसे दिखें. यह कंट्रोल, आपकी चुनी गई भौगोलिक जगहों से लोगों के संबंध के आधार पर तय होता है. इससे आपके कारोबार के लक्ष्यों को ज़्यादा बेहतर तरीके से हासिल किया जा सकता है.

सबसे सही तरीके

  • PRESENCE को तब चुनें, जब आपका प्रॉडक्ट या सेवा सिर्फ़ किसी जगह पर मौजूद लोगों के लिए उपलब्ध हो. उदाहरण के लिए, मान लें कि आपको उपयोगकर्ताओं को स्टोर में आने या स्थानीय डिलीवरी की ज़रूरत है.
  • PRESENCE_OR_INTEREST को तब चुनें, जब आपके प्रॉडक्ट या सेवा से उन लोगों को भी फ़ायदा हो सकता है जो किसी जगह में दिलचस्पी रखते हैं, भले ही वे वहां मौजूद न हों. उदाहरण के लिए, छुट्टियों की योजना बनाने वाले उपयोगकर्ता की दिलचस्पी, अपनी मंज़िल वाले शहर के होटलों में हो सकती है.
  • रीच को बेहतर बनाने के लिए, नेगेटिव लोकेशन टारगेटिंग का इस्तेमाल करें. अगर आपने PRESENCE_OR_INTEREST का इस्तेमाल करके अमेरिका को टारगेट किया है, लेकिन किसी राज्य में शिपिंग नहीं की जाती है, तो LocationInfo की शर्त पर negative=true का इस्तेमाल करके, उस राज्य को बाहर रखा जा सकता है. negative_geo_target_type को PRESENCE पर सेट करने से, आपके विज्ञापन उस राज्य के उपयोगकर्ताओं को नहीं दिखेंगे. हालांकि, उस राज्य से बाहर के उन उपयोगकर्ताओं को विज्ञापन दिखेंगे जो अमेरिका की जगहों में दिलचस्पी रखते हैं.

आगे क्या करना है

पीछे जाएं
बोली मॉडिफ़ायर
आगे बढ़ें
लक्ष्यीकरण सेटिंग