Geografische Ausrichtung

In diesem Leitfaden erhalten Sie allgemeine Informationen zur geografischen Ausrichtung. Außerdem erfahren Sie, wie Sie mit der Google Ads API Ihren Kampagnen die geografische Ausrichtung hinzufügen oder abrufen und aktualisieren können.

Informationen zu Ausrichtungslimits finden Sie im Abschnitt „Ausrichtungslimits“ unter Google Ads-Kontolimits.

Warum ist geografisches Targeting wichtig?

Mit dem geografischen Targeting können Sie Anzeigen für Nutzer in einer bestimmten geografischen Region ausliefern. Angenommen, Sie werben für eine Supermarktkette. Ohne geografisches Targeting würden Ihre Anzeigen in allen Regionen weltweit ausgeliefert und möglicherweise von Nutzern in Regionen angeklickt, in denen Sie keine Supermärkte haben. Somit entstünden Kosten, ohne dass Gewinn erzielt würde. Mit geografischem Targeting werden Ihre Anzeigen nur in Regionen ausgeliefert, in denen Sie Supermärkte haben. Mit diesem Ansatz können Sie auch direkt Kunden ansprechen, die lokal nach Supermärkten suchen.

Mit der Google Ads API können Sie Ihre Anzeigen auf ein Land, eine Region oder einen Umkreis um einen bestimmten geografischen Punkt ausrichten.

Kampagnen mit geografischem Targeting für eine Region

Sie können Kampagnen auf jede geografische Region ausrichten, für die in Google Ads die geografische Ausrichtung unterstützt wird, z. B. ein Land, ein Bundesland, eine Stadt oder eine Postleitzahlregion. Die einzelnen Standorte, für die eine Ausrichtung möglich ist, sind eindeutig durch eine Kriteriums-ID definiert. Sie können eine Kriterien-ID mit GeoTargetConstantService.SuggestGeoTargetConstants abrufen. Der resource_name jedes GeoTargetConstant hat das Format geoTargetConstants/{Criterion ID}. Der resource_name-Wert des Bundesstaats New York ist beispielsweise geoTargetConstants/21167.

Sie können Ihren Kampagnen Ziele für das geografische Targeting hinzufügen. Verwenden Sie dazu CampaignCriterionService (oder auf Anzeigengruppenebene AdGroupCriterion für unterstützte Kampagnentypen, z. B. Demand Gen-Kampagnen mit aktiviertem upgraded_targeting). Im folgenden Code-Snippet sehen Sie, wie Sie Ihre Kampagne mit einer Kriterien-ID ausrichten.

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 kann gelegentlich aus verschiedenen Gründen einige Standortkriterien auslaufen lassen, z. B. wenn der Standort in kleinere oder größere Bereiche umstrukturiert wird oder wenn es geopolitische Änderungen gibt. Im Feld status eines GeoTargetConstant-Objekts können Sie nachsehen, ob ein Standort ENABLED oder REMOVAL_PLANNED ist.

Nach Standortname suchen

Sie können die Kriterien-ID auch anhand des Ortsnamens mit GeoTargetConstantService.SuggestGeoTargetConstants abrufen. Im folgenden Codebeispiel wird gezeigt, wie Sie eine Standortkriterien-ID anhand des Standortnamens abrufen.

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

Geografische Ausrichtung von Kampagnen im Hinblick auf die Nähe zu einem Standort

Manchmal möchten Sie vielleicht noch genauer als nach Stadt oder Land targeten. Beispielsweise möchten Sie Ihre Supermärkte im Umkreis von 10 Kilometern um Ihren Geschäftsstandort bewerben. In solchen Fällen können Sie Targeting nach Umkreis verwenden. Der Code zum Erstellen eines Umkreis-Ziels ähnelt dem zum Hinzufügen eines geografischen Ziels. Sie müssen jedoch ein ProximityInfo-Objekt anstelle eines LocationInfo-Objekts erstellen.

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

Ziele für geografisches Targeting abrufen

Sie können die Ziele für das geografische Targeting für eine Kampagne mit GoogleAdsService.SearchStream abrufen. Wenn Sie campaign_criterion.type und campaign_criterion.resource_name in die SELECT-Klausel aufnehmen, können Sie zwischen LOCATION- und PROXIMITY-Kriterien unterscheiden und die Ressourcennamen für nachfolgende Aktualisierungen oder Entfernungen aufzeichnen.

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

Geo-Targeting aktualisieren

Standortkriterien für eine Kampagne können nach der Erstellung nicht mehr geändert werden. Wenn Sie die geografischen Ziele einer Kampagne aktualisieren möchten, müssen Sie die veralteten Ziele in einer einzigen atomaren CampaignCriterionService.MutateCampaignCriteria-Anfrage durch neue ersetzen:

  1. Fragen Sie die vorhandenen LOCATION- und PROXIMITY-Kriterien der Kampagne mit der GAQL-Abfrage unter Geografische Ziele abrufen ab.
  2. Vergleichen Sie die vorhandenen Kriterien mit der gewünschten Zielliste.
  3. Erstellen Sie für jedes veraltete Kriterium ein CampaignCriterionOperation, wobei remove auf die resource_name des vorhandenen Kriteriums festgelegt ist.
  4. Erstellen Sie für jedes neue geografische Ziel oder Umkreisziel ein CampaignCriterionOperation-Objekt, wobei create mit dem neuen LocationInfo- oder ProximityInfo-Kriterium ausgefüllt ist.
  5. Übergeben Sie sowohl den remove- als auch den create-Vorgang in einem einzigen MutateCampaignCriteria-Aufruf, damit die Umstellung atomar erfolgt.

Geo-Targeting ausschließen

Sie können auch LocationInfo ausschließen, aber nicht ProximityInfo. Diese Funktion ist besonders nützlich, wenn Sie eine Region als Ziel festlegen, aber eine Unterregion ausschließen möchten (z. B. die gesamten USA mit Ausnahme von New York City). Wenn Sie eine Region ausschließen möchten, setzen Sie das Feld negative in CampaignCriterion auf true.

Ausrichtung auf mehrere geografische Regionen

Wenn Sie ein LocationGroupInfo verwenden, können Sie eine Kampagne auf mehrere geografische Regionen ausrichten, die sich auf Standorte beziehen, die durch Standort-Assets definiert oder nach einer geografischen Region gefiltert wurden:

  • Standort-Asset-Sammlungen: Legen Sie entweder enable_customer_level_location_asset_set = true (um die Standort-Asset-Sammlung des Kunden als Ziel festzulegen) oder location_group_asset_sets (um bestimmte AssetSet-Ressourcennamen als Ziel festzulegen) fest. Diese beiden Felder können nicht zusammen festgelegt werden und keines von beiden kann mit geo_target_constants kombiniert werden.
  • Radius und Einheiten: Der Radius in LocationGroupInfo definiert einen kreisförmigen Bereich um jeden Standort und erfordert sowohl radius als auch radius_units (LocationGroupRadiusUnitsEnum):
    • Wenn Sie Asset-Sets für Standorte (enable_customer_level_location_asset_set oder location_group_asset_sets) verwenden, sind die unterstützten radius_units-Werte MILLI_MILES und METERS.
    • Beim Filtern nach geo_target_constants (wobei höchstens eine Kriterien-ID zulässig ist und AssetSet-Felder nicht festgelegt sind) sind die unterstützten radius_units-Werte MILES und METERS.

Erweiterte Standortoptionen mit GeoTargetTypeSetting

Sie können nicht nur Standorte für die Ausrichtung oder den Ausschluss angeben, sondern auch mithilfe der erweiterten Standortoptionen genauer festlegen, wie Google Ads Nutzer diesen Standorten zuordnet. Diese Einstellungen werden über Campaign.GeoTargetTypeSetting verwaltet.

Diese Einstellung besteht aus zwei Feldern:

  • positive_geo_target_type: Bestimmt, wie Nutzer für Orte abgeglichen werden, auf die Sie das Targeting festlegen.
  • negative_geo_target_type: Bestimmt, wie Nutzer für Standorte zugeordnet werden, die Sie ausschließen.

Einstellungen für einschließendes Targeting (positive_geo_target_type)

Für das Targeting auf einzuschließende geografische Ziele können Sie aus den folgenden Optionen auswählen und dabei Werte aus der PositiveGeoTargetTypeEnum verwenden:

  • PRESENCE_OR_INTEREST (empfohlener Standardwert):

    • Sie erreichen Nutzer, die sich wahrscheinlich in Ihren Zielregionen befinden oder sich regelmäßig dort aufhalten, sowie Nutzer, die Interesse an Ihren Zielregionen gezeigt haben.
    • Interesse kann sich durch Suchbegriffe, frühere Besuche oder konsumierte Inhalte im Zusammenhang mit dem Ort äußern.
    • Diese Option bietet die größte Reichweite.

  • PRESENCE:

    • Sie erreichen nur Nutzer, die sich wahrscheinlich in Ihren Zielregionen befinden oder sich regelmäßig dort aufhalten.
    • Diese Option ist restriktiver und nützlich, wenn Ihre Dienste oder Produkte streng auf Personen beschränkt sind, die sich physisch in einem Gebiet befinden.

Einstellungen für ausschließendes Targeting (negative_geo_target_type)

Für Orte, die Sie ausschließen möchten, verwenden Sie NegativeGeoTargetTypeEnum:

  • PRESENCE (empfohlener Standardwert):
    • Nutzer, die sich wahrscheinlich an den von Ihnen ausgeschlossenen Standorten befinden, werden ausgeschlossen.
    • Nutzer außerhalb der ausgeschlossenen Gebiete, die sich für diese interessieren, sehen Ihre Anzeigen möglicherweise weiterhin, sofern sie Ihrem positiven Targeting entsprechen.

Erweiterte Standortoptionen verwalten

Sie können diese Einstellungen steuern, indem Sie das Objekt Campaign.geo_target_type_setting aktualisieren. Das folgende Beispiel zeigt die Struktur eines CampaignOperation-Updates, bei dem positive_geo_target_type auf PRESENCE gesetzt wird:

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

Wenn Sie die aktuellen Einstellungen abrufen möchten, fügen Sie campaign.geo_target_type_setting.positive_geo_target_type und campaign.geo_target_type_setting.negative_geo_target_type in Ihre GoogleAdsService-Suchanfrage ein.

Durch die Konfiguration dieser Einstellungen erhalten Sie eine genauere Kontrolle darüber, wer Ihre Anzeigen sieht, basierend auf der Beziehung der Nutzer zu den von Ihnen angegebenen geografischen Standorten. So können Sie Ihre Anzeigen besser auf Ihre Geschäftsziele abstimmen.

Best Practices

  • Wählen Sie PRESENCE aus, wenn Ihr Produkt oder Ihre Dienstleistung ausschließlich für Personen bestimmt ist, die sich physisch an einem Ort befinden. Angenommen, Sie möchten, dass Nutzer im Geschäft sind oder eine lokale Lieferung benötigen.
  • Wählen Sie PRESENCE_OR_INTEREST aus, wenn Ihr Produkt oder Ihre Dienstleistung auch für Nutzer interessant sein könnte, die sich für einen Standort interessieren, auch wenn sie nicht physisch dort sind. Beispielsweise könnte ein Nutzer, der einen Urlaub plant, an Hotels in der Stadt interessiert sein, die er besuchen möchte.
  • Verwenden Sie auszuschließende geografische Ziele, um die Reichweite zu optimieren. Wenn Sie die USA mit PRESENCE_OR_INTEREST als Ziel festlegen, aber nicht in einen bestimmten Bundesstaat liefern, können Sie diesen Bundesstaat mit negative=true für ein LocationInfo-Kriterium ausschließen. In Kombination mit negative_geo_target_type, das auf PRESENCE festgelegt ist, wird so verhindert, dass Ihre Anzeigen für Nutzer in diesem Bundesstaat ausgeliefert werden. Gleichzeitig erreichen Sie Nutzer außerhalb dieses Bundesstaats, die an US-Standorten interessiert sein könnten.

Nächste Schritte

Zurück
Gebotsanpassungen
Weiter
Targeting-Einstellungen