This guide describes location targeting, and how you can use the Google Ads API to add,
retrieve, and update location targeting for your campaigns.

For information about targeting limits, see the Targeting Limits section of
[About Google Ads account limits](https://support.google.com/google-ads/answer/6372658).

## Why is geo-targeting important?

Location targeting lets you serve ads to users in a particular geographical
region. For example, assume you're advertising for a chain of supermarkets.
Without location targeting, your ads would show in all regions worldwide, and
your ads might receive clicks from users in regions where you have no
supermarket locations. This generates cost while providing no possibility of a
return on the investment. With location targeting, your campaigns show ads only
in regions where you have open supermarkets. This approach also lets you
directly target customers searching locally for supermarkets.

The Google Ads API lets you [target your ads by country, region, or proximity around a
specific geographical point](https://support.google.com/google-ads/answer/1722043).

## Geo-target campaigns for a region

You can target campaigns to any geographical region for which Google Ads
supports location targeting, such as a country, a state, a city, or a postal
region. Each targetable location is uniquely identified by a Criterion ID. You
can look up a criterion ID using
[`GeoTargetConstantService.SuggestGeoTargetConstants`](https://developers.google.com/google-ads/api/reference/rpc/v26/GeoTargetConstantService/SuggestGeoTargetConstants.md.txt).
The `resource_name` of each [`GeoTargetConstant`](https://developers.google.com/google-ads/api/reference/rpc/v26/GeoTargetConstant.md.txt) is of the
form `geoTargetConstants/{Criterion ID}`. For example, the `resource_name` value
of New York state is `geoTargetConstants/21167`.

You can add geo targets to your campaigns using the
[`CampaignCriterionService`](https://developers.google.com/google-ads/api/reference/rpc/v26/CampaignCriterionService.md.txt) (or at the ad group
level using [`AdGroupCriterion`](https://developers.google.com/google-ads/api/reference/rpc/v26/AdGroupCriterion.md.txt) for supported campaign
types, such as Demand Gen campaigns with `upgraded_targeting` enabled). The
following code snippet shows how to target your campaign with a criterion ID.


### Java

```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#

```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

```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

```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

```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

```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

> [!NOTE]
> **Note:** While a direct REST code sample for this step isn't provided here, you can achieve this using a manual REST request.   
>
> Refer to the Google Ads API REST interface documentation and the method-specific reference pages. You will need to construct the JSON payload based on the proto definitions.   
>
> Key Resources:
>
> - [Using REST](https://developers.google.com/google-ads/api/rest/overview.md.txt)
> - [REST Interface Structure](https://developers.google.com/google-ads/api/rest/design/overview.md.txt)
> - [JSON Field Mappings](https://developers.google.com/google-ads/api/rest/design/json-mappings.md.txt)
> - Consult the [REST API Reference](https://developers.google.com/google-ads/api/reference/rpc/latest/overview) for the specific service and method.

<br />

Google may occasionally phase out some location criteria for various reasons:
the location may be restructured into smaller or larger areas, geo-political
changes, and so forth. Refer to the [`status`](https://developers.google.com/google-ads/api/reference/rpc/v26/GeoTargetConstant.md.txt) field of a
`GeoTargetConstant` object to determine if a location is
[`ENABLED`](https://developers.google.com/google-ads/api/reference/rpc/v26/GeoTargetConstantStatusEnum.GeoTargetConstantStatus.md.txt#enabled) or [`REMOVAL_PLANNED`](https://developers.google.com/google-ads/api/reference/rpc/v26/GeoTargetConstantStatusEnum.GeoTargetConstantStatus.md.txt#removal_planned).

## Look up by location name

You can also look up the criterion ID by location name using
[`GeoTargetConstantService.SuggestGeoTargetConstants`](https://developers.google.com/google-ads/api/reference/rpc/v26/GeoTargetConstantService/SuggestGeoTargetConstants.md.txt).
The following code example shows how to look up a location criterion ID by
location name.


### Java

```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#

```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

```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

```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

```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

```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

> [!NOTE]
> **Note:** While a direct REST code sample for this step isn't provided here, you can achieve this using a manual REST request.   
>
> Refer to the Google Ads API REST interface documentation and the method-specific reference pages. You will need to construct the JSON payload based on the proto definitions.   
>
> Key Resources:
>
> - [Using REST](https://developers.google.com/google-ads/api/rest/overview.md.txt)
> - [REST Interface Structure](https://developers.google.com/google-ads/api/rest/design/overview.md.txt)
> - [JSON Field Mappings](https://developers.google.com/google-ads/api/rest/design/json-mappings.md.txt)
> - Consult the [REST API Reference](https://developers.google.com/google-ads/api/reference/rpc/latest/overview) for the specific service and method.

<br />

## Target campaigns for proximity to a location

There are times when you might want to target even more precisely than a city or
country. For example, you may want to advertise your supermarkets within 10
kilometers of your shop location. In such cases, you can use
[proximity targeting](https://support.google.com/google-ads/answer/1722043#radius). The code to create a proximity
target is similar to adding a location target, except that you have to create a
[`ProximityInfo`](https://developers.google.com/google-ads/api/reference/rpc/v26/ProximityInfo.md.txt) object instead of a
[`LocationInfo`](https://developers.google.com/google-ads/api/reference/rpc/v26/LocationInfo.md.txt) object.


### Java

```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#

```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

```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

```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

```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

```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

> [!NOTE]
> **Note:** While a direct REST code sample for this step isn't provided here, you can achieve this using a manual REST request.   
>
> Refer to the Google Ads API REST interface documentation and the method-specific reference pages. You will need to construct the JSON payload based on the proto definitions.   
>
> Key Resources:
>
> - [Using REST](https://developers.google.com/google-ads/api/rest/overview.md.txt)
> - [REST Interface Structure](https://developers.google.com/google-ads/api/rest/design/overview.md.txt)
> - [JSON Field Mappings](https://developers.google.com/google-ads/api/rest/design/json-mappings.md.txt)
> - Consult the [REST API Reference](https://developers.google.com/google-ads/api/reference/rpc/latest/overview) for the specific service and method.

<br />

## Retrieve geo-targets

You can retrieve the geo targets for a campaign using
[`GoogleAdsService.SearchStream`](https://developers.google.com/google-ads/api/reference/rpc/v26/GoogleAdsService/SearchStream.md.txt). Including
`campaign_criterion.type` and `campaign_criterion.resource_name` in the `SELECT`
clause lets you distinguish between `LOCATION` and `PROXIMITY` criteria and
record the resource names for subsequent updates or removals.

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

## Update geo-targets

Location criteria on a campaign are immutable after creation, so updating a
campaign's geo targets requires replacing obsolete targets with new ones in a
single atomic
[`CampaignCriterionService.MutateCampaignCriteria`](https://developers.google.com/google-ads/api/reference/rpc/v26/CampaignCriterionService.md.txt)
request:

1. Query the campaign's existing `LOCATION` and `PROXIMITY` criteria using the GAQL query in [Retrieve geo-targets](https://developers.google.com/google-ads/api/docs/targeting/location-targeting.md.txt#retrieve-geo-targets).
2. Compare the existing criteria with your intended target list.
3. For each obsolete criterion, build a `CampaignCriterionOperation` with `remove` set to the existing criterion's `resource_name`.
4. For each new location or proximity target, build a `CampaignCriterionOperation` with `create` populated with the new `LocationInfo` or `ProximityInfo` criterion.
5. Pass both the `remove` and `create` operations in a single `MutateCampaignCriteria` call so the transition happens atomically.

> [!NOTE]
> **Note:** In v24 and later, attempting to remove all location criteria from a Local Services Performance Max campaign returns `CampaignCriterionError.CANNOT_REMOVE_ALL_LOCATIONS_FROM_LOCAL_SERVICES_PMAX_CAMPAIGN`.

## Exclude geo-targets

You can also exclude [`LocationInfo`](https://developers.google.com/google-ads/api/reference/rpc/v26/LocationInfo.md.txt), but not
[`ProximityInfo`](https://developers.google.com/google-ads/api/reference/rpc/v26/ProximityInfo.md.txt). This feature is most useful if you want to
target a region, but exclude a sub-region (for example, to target the entire
United States, except for New York City). To exclude a region, set the
[`negative`](https://developers.google.com/google-ads/api/reference/rpc/v26/CampaignCriterion.md.txt#negative) field in
[`CampaignCriterion`](https://developers.google.com/google-ads/api/reference/rpc/v26/CampaignCriterion.md.txt) to `true`.

## Target multiple geographic regions

If you use a [`LocationGroupInfo`](https://developers.google.com/google-ads/api/reference/rpc/v26/LocationGroupInfo.md.txt), you can enable a
campaign to target multiple geographic regions centered on locations defined by
location assets or filtered by a geographic region:

- **Location asset sets** : Set either `enable_customer_level_location_asset_set = true` (to target the customer's location asset set) or `location_group_asset_sets` (to target specific `AssetSet` resource names). These two fields cannot be set together, and neither can be combined with `geo_target_constants`.
- **Radius and units** : The radius on `LocationGroupInfo` defines a circular region around each location and requires both [`radius`](https://developers.google.com/google-ads/api/reference/rpc/v26/LocationGroupInfo.md.txt#radius) and [`radius_units`](https://developers.google.com/google-ads/api/reference/rpc/v26/LocationGroupInfo.md.txt#radius_units) ([`LocationGroupRadiusUnitsEnum`](https://developers.google.com/google-ads/api/reference/rpc/v26/LocationGroupRadiusUnitsEnum.LocationGroupRadiusUnits.md.txt)):
  - When using location asset sets (`enable_customer_level_location_asset_set` or `location_group_asset_sets`), supported `radius_units` values are `MILLI_MILES` and `METERS`.
  - When filtering by `geo_target_constants` (where at most one [criterion ID](https://developers.google.com/google-ads/api/data/geotargets.md.txt) is allowed, and `AssetSet` fields are not set), supported `radius_units` values are `MILES` and `METERS`.

## Advanced location options with `GeoTargetTypeSetting`

Beyond specifying locations to target or exclude, you can refine how Google Ads
matches users to these locations using advanced location options. These settings
are managed through [`Campaign.GeoTargetTypeSetting`](https://developers.google.com/google-ads/api/reference/rpc/v26/Campaign.GeoTargetTypeSetting.md.txt).

This setting consists of two fields:

- `positive_geo_target_type`: Determines how users are matched for locations you **target**.
- `negative_geo_target_type`: Determines how users are matched for locations you **exclude**.

### Positive targeting settings (`positive_geo_target_type`)

You can choose from the following options for your positive location targeting,
using values from the [`PositiveGeoTargetTypeEnum`](https://developers.google.com/google-ads/api/reference/rpc/v26/PositiveGeoTargetTypeEnum.PositiveGeoTargetType.md.txt):

- **`PRESENCE_OR_INTEREST` (Recommended default)**:

  - Reaches people who are likely to be in, or regularly in, your targeted locations, plus people who have shown interest in your targeted locations.
  - Interest can be signaled by search terms, past visits, or content consumed related to the location.
  - This option provides the broadest reach.
- **`PRESENCE`**:

  - Reaches only people who are likely to be physically located or regularly in your targeted locations.
  - This is more restrictive and useful if your services or products are strictly limited to people physically present in an area.

> [!NOTE]
> **Note:** The `SEARCH_INTEREST` value triggers ads when a user searches for your targeted locations and can only be used with Search and standard Shopping campaigns.

### Negative targeting settings (`negative_geo_target_type`)

For locations you want to exclude, you use the
[`NegativeGeoTargetTypeEnum`](https://developers.google.com/google-ads/api/reference/rpc/v26/NegativeGeoTargetTypeEnum.NegativeGeoTargetType.md.txt):

- **`PRESENCE` (Recommended default)** :
  - Excludes people who are likely to be physically located in the locations you've excluded.
  - People outside the excluded areas, even if interested in them, may still see your ads, provided they match your positive targeting.

> [!NOTE]
> **Note:** The `PRESENCE_OR_INTEREST` value is generally not supported for negative geotargeting in most campaign types.

### Manage advanced location options

You can control these settings by updating the
`Campaign.geo_target_type_setting` object. The following example shows the
structure of a `CampaignOperation` update that sets `positive_geo_target_type`
to `PRESENCE`:

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

To fetch the current settings, include
`campaign.geo_target_type_setting.positive_geo_target_type` and
`campaign.geo_target_type_setting.negative_geo_target_type` in your
`GoogleAdsService` search query.

By configuring these settings, you gain more granular control over who sees your
ads based on their relationship to the geographic locations you've specified,
aligning more closely with your business goals.

### Best practices

- **Choose `PRESENCE` if** your product or service is strictly limited to people physically present in a location. For example, suppose you require users to be in-store or require local delivery.
- **Choose `PRESENCE_OR_INTEREST` if** your product or service can also benefit people interested in a location, even if not physically present. For example, a user planning a vacation might be interested in hotels in their destination city.
- **Use negative location targeting to refine reach.** If you target the US with `PRESENCE_OR_INTEREST`, but don't ship to a specific state, you can exclude that state using `negative=true` on a `LocationInfo` criterion. Combined with `negative_geo_target_type` set to `PRESENCE`, this prevents your ads from showing to users in that state, while still reaching users outside that state who might be interested in US locations.

## What's next

- Adjust bids by criterion in the [Bid modifiers guide](https://developers.google.com/google-ads/api/docs/targeting/bid-modifiers.md.txt).