Geografische Ausrichtung

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

Informationen zu Ausrichtungslimits finden Sie im Abschnitt Ausrichtungslimits des Artikels 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 Sie würden möglicherweise Klicks von Nutzern in Regionen erhalten, in denen Sie keine Supermärkte haben. Somit entstünden Kosten, ohne dass Gewinn erzielt würde. Mit der geografischen Ausrichtung werden Ihre Anzeigen nur in Regionen ausgeliefert, in denen Sie Supermärkte haben. So können Sie auch direkt Kunden ansprechen, die lokal nach Supermärkten suchen.

Mit der Google Ads API können Sie Ihre Anzeigen nach Land, Region oder Nähe zu einem bestimmten geografischen Punkt ausrichten.

Kampagnen geografisch auf eine Region ausrichten

Sie können Kampagnen auf jede geografische Region ausrichten, für die Google Ads die geografische Ausrichtung unterstützt, z. B. ein Land, einen Bundesstaat, 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 Kriteriums-ID mit GeoTargetConstantService.SuggestGeoTargetConstants suchen. Der resource_name der einzelnen GeoTargetConstant hat das Format geoTargetConstants/{Criterion ID}. Der resource_name-Wert für den Bundesstaat New York ist beispielsweise geoTargetConstants/21167.

Sie können Ihren Kampagnen geografische Ziele mit dem CampaignCriterionService hinzufügen. Bei unterstützten Kampagnen typen wie Demand Gen-Kampagnen mit aktivierter Option upgraded_targeting ist das auch auf Anzeigengruppen ebene mit AdGroupCriterion möglich. Das folgende Code-Snippet zeigt, wie Sie Ihre Kampagne mit einer Kriteriums-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::V25::Resources::CampaignCriterion->new({
      # Create a location using the specified location ID.
      location => Google::Ads::GoogleAds::V25::Common::LocationInfo->new({
          # Besides using location ID, you can also search by location names
          # using GeoTargetConstantService::suggest() and directly apply
          # GeoTargetConstant->{resourceName} here. An example can be found
          # in get_geo_target_constants_by_names.pl.
          geoTargetConstant =>
            Google::Ads::GoogleAds::V25::Utils::ResourceNames::geo_target_constant(
            $location_id)}
      ),
      campaign => $campaign_resource_name
    });

  return
    Google::Ads::GoogleAds::V25::Services::CampaignCriterionService::CampaignCriterionOperation
    ->new({
      create => $campaign_criterion
    });
}

curl

Google kann einige Standortkriterien aus verschiedenen Gründen gelegentlich einstellen. So kann der Standort in kleinere oder größere Gebiete unterteilt werden oder es können geopolitische Änderungen eintreten. Im status Feld eines GeoTargetConstant Objekts können Sie sehen, ob ein Standort ENABLED oder REMOVAL_PLANNED ist.

Nach Standortname suchen

Sie können die Kriteriums-ID auch nach Standortname mit GeoTargetConstantService.SuggestGeoTargetConstants suchen. Das folgende Codebeispiel zeigt, wie Sie eine Standortkriteriums-ID nach Standortname suchen.

Java

private void runExample(GoogleAdsClient googleAdsClient) {
  try (GeoTargetConstantServiceClient geoTargetClient =
      googleAdsClient.getLatestVersion().createGeoTargetConstantServiceClient()) {

    SuggestGeoTargetConstantsRequest.Builder requestBuilder =
        SuggestGeoTargetConstantsRequest.newBuilder();

    // Locale is using ISO 639-1 format. If an invalid locale is given, 'en' is used by default.
    requestBuilder.setLocale("en");

    // A list of country codes can be referenced here:
    // https://developers.google.com/google-ads/api/reference/data/geotargets
    requestBuilder.setCountryCode("FR");

    requestBuilder
        .getLocationNamesBuilder()
        .addAllNames(ImmutableList.of("Paris", "Quebec", "Spain", "Deutschland"));

    SuggestGeoTargetConstantsResponse response =
        geoTargetClient.suggestGeoTargetConstants(requestBuilder.build());

    for (GeoTargetConstantSuggestion suggestion :
        response.getGeoTargetConstantSuggestionsList()) {
      System.out.printf(
          "%s (%s,%s,%s,%s) is found in locale (%s) with reach (%d) for search term (%s).%n",
          suggestion.getGeoTargetConstant().getResourceName(),
          suggestion.getGeoTargetConstant().getName(),
          suggestion.getGeoTargetConstant().getCountryCode(),
          suggestion.getGeoTargetConstant().getTargetType(),
          suggestion.getGeoTargetConstant().getStatus().name(),
          suggestion.getLocale(),
          suggestion.getReach(),
          suggestion.getSearchTerm());
    }
  }
}

C#

public void Run(GoogleAdsClient client)
{
    // Get the GeoTargetConstantServiceClient.
    GeoTargetConstantServiceClient geoService =
        client.GetService(Services.V25.GeoTargetConstantService);

    // Locale is using ISO 639-1 format. If an invalid locale is given,
    // 'en' is used by default.
    string locale = "en";

    // A list of country codes can be referenced here:
    // https://developers.google.com/google-ads/api/reference/data/geotargets
    string countryCode = "FR";

    string[] locations = { "Paris", "Quebec", "Spain", "Deutschland" };

    SuggestGeoTargetConstantsRequest request = new SuggestGeoTargetConstantsRequest()
    {
        Locale = locale,
        CountryCode = countryCode,
        LocationNames = new SuggestGeoTargetConstantsRequest.Types.LocationNames()
    };

    request.LocationNames.Names.AddRange(locations);

    try
    {
        SuggestGeoTargetConstantsResponse response =
            geoService.SuggestGeoTargetConstants(request);

        foreach (GeoTargetConstantSuggestion suggestion
            in response.GeoTargetConstantSuggestions)
        {
            Console.WriteLine(
                $"{suggestion.GeoTargetConstant.ResourceName} " +
                $"({suggestion.GeoTargetConstant.Name}, " +
                $"{suggestion.GeoTargetConstant.CountryCode}, " +
                $"{suggestion.GeoTargetConstant.TargetType}, " +
                $"{suggestion.GeoTargetConstant.Status}) is found in locale " +
                $"({suggestion.Locale}) with reach ({suggestion.Reach}) " +
                $"for search term ({suggestion.SearchTerm}).");
        }
    }
    catch (GoogleAdsException e)
    {
        Console.WriteLine("Failure:");
        Console.WriteLine($"Message: {e.Message}");
        Console.WriteLine($"Failure: {e.Failure}");
        Console.WriteLine($"Request ID: {e.RequestId}");
        throw;
    }
}

PHP

public static function runExample(
    GoogleAdsClient $googleAdsClient,
    array $locationNames,
    string $locale,
    string $countryCode
) {
    $geoTargetConstantServiceClient = $googleAdsClient->getGeoTargetConstantServiceClient();

    $response = $geoTargetConstantServiceClient->suggestGeoTargetConstants(
        new SuggestGeoTargetConstantsRequest([
            'locale' => $locale,
            'country_code' => $countryCode,
            'location_names' => new LocationNames(['names' => $locationNames])
        ])
    );

    // Iterates over all geo target constant suggestion objects and prints the requested field
    // values for each one.
    foreach ($response->getGeoTargetConstantSuggestions() as $geoTargetConstantSuggestion) {
        /** @var GeoTargetConstantSuggestion $geoTargetConstantSuggestion */
        printf(
            "Found '%s' ('%s','%s','%s',%s) in locale '%s' with reach %d"
            . " for the search term '%s'.%s",
            $geoTargetConstantSuggestion->getGeoTargetConstant()->getResourceName(),
            $geoTargetConstantSuggestion->getGeoTargetConstant()->getName(),
            $geoTargetConstantSuggestion->getGeoTargetConstant()->getCountryCode(),
            $geoTargetConstantSuggestion->getGeoTargetConstant()->getTargetType(),
            GeoTargetConstantStatus::name(
                $geoTargetConstantSuggestion->getGeoTargetConstant()->getStatus()
            ),
            $geoTargetConstantSuggestion->getLocale(),
            $geoTargetConstantSuggestion->getReach(),
            $geoTargetConstantSuggestion->getSearchTerm(),
            PHP_EOL
        );
    }
}

Python

def main(client: GoogleAdsClient) -> None:
    gtc_service: GeoTargetConstantServiceClient = client.get_service(
        "GeoTargetConstantService"
    )

    gtc_request: SuggestGeoTargetConstantsRequest = client.get_type(
        "SuggestGeoTargetConstantsRequest"
    )
    gtc_request.locale = LOCALE
    gtc_request.country_code = COUNTRY_CODE

    # The location names to get suggested geo target constants.
    # Type hint for gtc_request.location_names.names is not straightforward
    # as it's part of a complex protobuf object.
    gtc_request.location_names.names.extend(
        ["Paris", "Quebec", "Spain", "Deutschland"]
    )

    results: SuggestGeoTargetConstantsResponse = (
        gtc_service.suggest_geo_target_constants(gtc_request)
    )

    suggestion: GeoTargetConstantSuggestion
    for suggestion in results.geo_target_constant_suggestions:
        geo_target_constant: GeoTargetConstant = suggestion.geo_target_constant
        print(
            f"{geo_target_constant.resource_name} "
            f"({geo_target_constant.name}, "
            f"{geo_target_constant.country_code}, "
            f"{geo_target_constant.target_type}, "
            f"{geo_target_constant.status.name}) "
            f"is found in locale ({suggestion.locale}) "
            f"with reach ({suggestion.reach}) "
            f"from search term ({suggestion.search_term})."
        )

Ruby

def get_geo_target_constants_by_names
  # GoogleAdsClient will read a config file from
  # ENV['HOME']/google_ads_config.rb when called without parameters
  client = Google::Ads::GoogleAds::GoogleAdsClient.new

  gtc_service = client.service.geo_target_constant

  location_names = client.resource.location_names do |ln|
    ['Paris', 'Quebec', 'Spain', 'Deutschland'].each do |name|
      ln.names << name
    end
  end

  # Locale is using ISO 639-1 format. If an invalid locale is given,
  # 'en' is used by default.
  locale = 'en'

  # A list of country codes can be referenced here:
  # https://developers.google.com/google-ads/api/reference/data/geotargets
  country_code = 'FR'

  response = gtc_service.suggest_geo_target_constants(
    locale: locale,
    country_code: country_code,
    location_names: location_names
  )

  response.geo_target_constant_suggestions.each do |suggestion|
    puts sprintf("%s (%s,%s,%s,%s) is found in locale (%s) with reach (%d)" \
        " from search term (%s).", suggestion.geo_target_constant.resource_name,
        suggestion.geo_target_constant.name,
        suggestion.geo_target_constant.country_code,
        suggestion.geo_target_constant.target_type,
        suggestion.geo_target_constant.status,
        suggestion.locale,
        suggestion.reach,
        suggestion.search_term)
  end
end

Perl

sub get_geo_target_constants_by_names {
  my ($api_client, $location_names, $locale, $country_code) = @_;

  my $suggest_response = $api_client->GeoTargetConstantService()->suggest({
      locale        => $locale,
      countryCode   => $country_code,
      locationNames =>
        Google::Ads::GoogleAds::V25::Services::GeoTargetConstantService::LocationNames
        ->new({
          names => $location_names
        })});

  # Iterate over all geo target constant suggestion objects and print the requested
  # field values for each one.
  foreach my $geo_target_constant_suggestion (
    @{$suggest_response->{geoTargetConstantSuggestions}})
  {
    printf "Found '%s' ('%s','%s','%s',%s) in locale '%s' with reach %d" .
      " for the search term '%s'.\n",
      $geo_target_constant_suggestion->{geoTargetConstant}{resourceName},
      $geo_target_constant_suggestion->{geoTargetConstant}{name},
      $geo_target_constant_suggestion->{geoTargetConstant}{countryCode},
      $geo_target_constant_suggestion->{geoTargetConstant}{targetType},
      $geo_target_constant_suggestion->{geoTargetConstant}{status},
      $geo_target_constant_suggestion->{locale},
      $geo_target_constant_suggestion->{reach},
      $geo_target_constant_suggestion->{searchTerm};
  }

  return 1;
}

curl

Kampagnen geografisch im Hinblick auf die Nähe zu einem Standort ausrichten

Manchmal möchten Sie Ihre Ausrichtung noch genauer festlegen als auf eine Stadt oder ein Land. Vielleicht möchten Sie beispielsweise für Ihre Supermärkte im Umkreis von 10 Kilometern um Ihren Standort werben. In solchen Fällen können Sie die Ausrichtung nach Nähe verwenden proximity targeting. Der Code zum Erstellen eines Ziels für die Ausrichtung nach Nähe ähnelt dem 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::V25::Resources::CampaignCriterion->new({
      proximity => Google::Ads::GoogleAds::V25::Common::ProximityInfo->new({
          address => Google::Ads::GoogleAds::V25::Common::AddressInfo->new({
              streetAddress => "38 avenue de l'Opéra",
              cityName      => "cityName",
              postalCode    => "75002",
              countryCode   => "FR"
            }
          ),
          radius => 10.0,
          # Default is kilometers.
          radiusUnits => MILES
        }
      ),
      campaign => $campaign_resource_name
    });

  return
    Google::Ads::GoogleAds::V25::Services::CampaignCriterionService::CampaignCriterionOperation
    ->new({
      create => $campaign_criterion
    });
}

curl

Geografische Ziele abrufen

Sie können die Ziele für das Geo-Targeting für eine Kampagne mit GoogleAdsService.SearchStream abrufen. Wenn Sie campaign_criterion.type und campaign_criterion.resource_name in die SELECT-Klausel einfügen, können Sie zwischen LOCATION- und PROXIMITY-Kriterien unterscheiden und die Ressourcennamen für spätere 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')

Geografische Ziele 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 Ihrer gewünschten Zielliste.
  3. Erstellen Sie für jedes veraltete Kriterium eine CampaignCriterionOperation mit remove auf den resource_name des vorhandenen Kriteriums gesetzt.
  4. Erstellen Sie für jedes neue geografische Ziel oder Ziel für die Ausrichtung nach Nähe eine CampaignCriterionOperation mit create und dem neuen LocationInfo- oder ProximityInfo-Kriterium.
  5. Übergeben Sie sowohl die remove- als auch die create-Vorgänge in einem einzigen MutateCampaignCriteria-Aufruf, damit die Umstellung atomar erfolgt.

Geografische Ziele ausschließen

Sie können auch LocationInfo ausschließen, aber nicht ProximityInfo. Diese Funktion ist besonders nützlich, wenn Sie eine Region ausrichten, 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 negative Feld in CampaignCriterion auf true.

Auf mehrere geografische Regionen ausrichten

Wenn Sie LocationGroupInfo verwenden, können Sie eine Kampagne auf mehrere geografische Regionen ausrichten, die auf Standorten basieren, die durch Standort-Assets definiert oder nach einer geografischen Region gefiltert werden:

  • Standort-Asset-Sammlungen: Legen Sie entweder enable_customer_level_location_asset_set = true fest, um auf die Standort-Asset-Sammlung des Kunden auszurichten, oder location_group_asset_sets, um auf bestimmte AssetSet Ressourcennamen auszurichten. Diese beiden Felder können nicht zusammen festgelegt werden und auch nicht mit geo_target_constants kombiniert werden.
  • Radius und Einheiten: Der Radius in LocationGroupInfo definiert eine kreisförmige Region um jeden Standort und erfordert sowohl radius als auch radius_units (LocationGroupRadiusUnitsEnum):
    • Wenn Sie Standort-Asset-Sammlungen verwenden (enable_customer_level_location_asset_set oder location_group_asset_sets), sind die unterstützten radius_units-Werte MILLI_MILES und METERS.
    • Wenn Sie nach geo_target_constants filtern (wobei maximal eine Kriteriums-ID zulässig ist und keine AssetSet-Felder festgelegt sind), sind die unterstützten radius_units-Werte MILES und METERS.

Erweiterte Standortoptionen mit GeoTargetTypeSetting

Neben der Angabe von Standorten, auf die Sie Ihre Anzeigen ausrichten oder die Sie ausschließen möchten, können Sie mit erweiterten Standortoptionen 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 Standorte zugeordnet werden, auf die Sie Ihre Anzeigen ausrichten.
  • 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)

Sie können für Ihr einschließendes Standort-Targeting aus den folgenden Optionen auswählen, verwenden Sie dazu Werte aus PositiveGeoTargetTypeEnum:

  • PRESENCE_OR_INTEREST (empfohlener Standard):

    • Erreicht Nutzer, die sich wahrscheinlich in Ihren Zielregionen aufhalten oder regelmäßig dort sind, sowie Nutzer, die Interesse an Ihren Zielregionen gezeigt haben.
    • Interesse kann durch Suchbegriffe, frühere Besuche oder Inhalte signalisiert werden, die sich auf den Standort beziehen.
    • Diese Option bietet die größte Reichweite.

  • PRESENCE:

    • Erreicht nur Nutzer, die sich wahrscheinlich in Ihren Zielregionen aufhalten oder regelmäßig dort sind.
    • Diese Option ist restriktiver und nützlich, wenn Ihre Dienstleistungen oder Produkte ausschließlich für Nutzer verfügbar sind, die sich physisch in einer Region aufhalten.

Einstellungen für ausschließendes Targeting (negative_geo_target_type)

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

  • PRESENCE (empfohlener Standard):
    • Schließt Nutzer aus, die sich wahrscheinlich in den von Ihnen ausgeschlossenen Regionen aufhalten.
    • Nutzer außerhalb der ausgeschlossenen Regionen können Ihre Anzeigen weiterhin sehen, auch wenn sie sich für diese interessieren, sofern sie mit Ihrem einschließenden Targeting übereinstimmen.

Erweiterte Standortoptionen verwalten

Sie können diese Einstellungen verwalten, indem Sie das Objekt Campaign.geo_target_type_setting aktualisieren. Das folgende Beispiel zeigt die Struktur einer CampaignOperation-Aktualisierung, bei der 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 haben Sie eine detailliertere 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 Nutzer verfügbar ist, die sich physisch an einem Standort aufhalten. Beispielsweise müssen Nutzer sich in einem Ladengeschäft befinden oder eine lokale Lieferung in Anspruch nehmen.
  • Wählen Sie PRESENCE_OR_INTEREST aus, wenn Ihr Produkt oder Ihre Dienstleistung auch für Nutzer von Vorteil sein kann, die sich für einen Standort interessieren, auch wenn sie sich nicht physisch dort aufhalten. Ein Nutzer, der einen Urlaub plant, könnte sich beispielsweise für Hotels in der Zielstadt interessieren.
  • Verwenden Sie das ausschließende Geo-Targeting, um die Reichweite zu optimieren. Wenn Sie mit PRESENCE_OR_INTEREST auf die USA ausrichten, 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 auf PRESENCE gesetzt wird so verhindert, dass Ihre Anzeigen für Nutzer in diesem Bundesstaat ausgeliefert werden. Gleichzeitig erreichen Sie aber Nutzer außerhalb dieses Bundesstaats, die sich für Standorte in den USA interessieren.

Nächste Schritte

  • Informationen zum Anpassen von Geboten nach Kriterium finden Sie im Leitfaden Gebotsanpassungen.
Zurück
Gebotsanpassungen
Weiter
Targeting-Einstellungen