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 Informationen zu Google Ads-Kontolimits.

Warum ist geografisches Targeting wichtig?

Mit der geografischen Ausrichtung können Sie Anzeigen für Nutzer in einer bestimmten geografischen Region schalten. Angenommen, Sie werben für eine Supermarktkette. Ohne geografische Ausrichtung 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.

Weitere Informationen zur geografischen Ausrichtung von Anzeigen.

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. 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();
}
AddCampaignTargetingCriteria.java

C#

private CampaignCriterion buildLocationCriterion(long locationId,
    string campaignResourceName)
{
    GeoTargetConstantName location = new GeoTargetConstantName(locationId.ToString());
    return new CampaignCriterion()
    {
        Campaign = campaignResourceName,
        Location = new LocationInfo()
        {
            GeoTargetConstant = location.ToString()
        }
    };
}
AddCampaignTargetingCriteria.cs

PHP

private static function createLocationCampaignCriterionOperation(
    int $locationId,
    string $campaignResourceName
) {
    // Constructs a campaign criterion for the specified campaign ID using the specified
    // location ID.
    $campaignCriterion = new CampaignCriterion([
        // Creates a location using the specified location ID.
        'location' => new LocationInfo([
            // Besides using location ID, you can also search by location names using
            // GeoTargetConstantServiceClient::suggestGeoTargetConstants() and directly
            // apply GeoTargetConstant::$resourceName here. An example can be found
            // in GetGeoTargetConstantByNames.php.
            'geo_target_constant' => ResourceNames::forGeoTargetConstant($locationId)
        ]),
        'campaign' => $campaignResourceName
    ]);

    return new CampaignCriterionOperation(['create' => $campaignCriterion]);
}
AddCampaignTargetingCriteria.php

Python

def create_location_op(
    client: GoogleAdsClient,
    customer_id: str,
    campaign_id: str,
    location_id: str,
) -> CampaignCriterionOperation:
    campaign_service: CampaignServiceClient = client.get_service(
        "CampaignService"
    )
    geo_target_constant_service: GeoTargetConstantServiceClient = (
        client.get_service("GeoTargetConstantService")
    )

    # Create the campaign criterion.
    campaign_criterion_operation: CampaignCriterionOperation = client.get_type(
        "CampaignCriterionOperation"
    )
    campaign_criterion: CampaignCriterion = campaign_criterion_operation.create
    campaign_criterion.campaign = campaign_service.campaign_path(
        customer_id, campaign_id
    )

    # Besides using location_id, you can also search by location names from
    # GeoTargetConstantService.suggest_geo_target_constants() and directly
    # apply GeoTargetConstant.resource_name here. An example can be found
    # in get_geo_target_constant_by_names.py.
    campaign_criterion.location.geo_target_constant = (
        geo_target_constant_service.geo_target_constant_path(location_id)
    )

    return campaign_criterion_operation
add_campaign_targeting_criteria.py

Ruby

def create_location(client, customer_id, campaign_id, location_id)
  client.operation.create_resource.campaign_criterion do |criterion|
    criterion.campaign = client.path.campaign(customer_id, campaign_id)

    criterion.location = client.resource.location_info do  |li|
      # Besides using location_id, you can also search by location names from
      # GeoTargetConstantService.suggest_geo_target_constants() and directly
      # apply GeoTargetConstant.resource_name here. An example can be found
      # in get_geo_target_constant_by_names.rb.
      li.geo_target_constant = client.path.geo_target_constant(location_id)
    end
  end
end
add_campaign_targeting_criteria.rb

Perl

sub create_location_campaign_criterion_operation {
  my ($location_id, $campaign_resource_name) = @_;

  # Construct a campaign criterion for the specified campaign using the
  # specified location ID.
  my $campaign_criterion =
    Google::Ads::GoogleAds::V24::Resources::CampaignCriterion->new({
      # Create a location using the specified location ID.
      location => Google::Ads::GoogleAds::V24::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::V24::Utils::ResourceNames::geo_target_constant(
            $location_id)}
      ),
      campaign => $campaign_resource_name
    });

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

curl

Google kann einige geografische Kriterien aus verschiedenen Gründen gelegentlich einstellen. So kann der Standort in kleinere oder größere Bereiche unterteilt werden oder es können geopolitische Änderungen eintreten. Im Feld status 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());
    }
  }
}
GetGeoTargetConstantsByNames.java

C#

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

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

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

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

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

    request.LocationNames.Names.AddRange(locations);

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

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

PHP

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

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

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

Python

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

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

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

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

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

Ruby

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

  gtc_service = client.service.geo_target_constant

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

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

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

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

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

Perl

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

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

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

  return 1;
}
get_geo_target_constants_by_names.pl

curl

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

Manchmal möchten Sie die Ausrichtung noch genauer festlegen als auf eine Stadt oder ein Land. Beispielsweise möchten Sie vielleicht 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 Umgebung-Ziels ä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();
}
AddCampaignTargetingCriteria.java

C#

private CampaignCriterion buildProximityCriterion(string campaignResourceName)
{
    ProximityInfo proximity = new ProximityInfo()
    {
        Address = new AddressInfo()
        {
            StreetAddress = "38 avenue de l'Opéra",
            CityName = "Paris",
            PostalCode = "75002",
            CountryCode = "FR"
        },
        Radius = 10d,
        // Default is kilometers.
        RadiusUnits = ProximityRadiusUnits.Miles
    };

    return new CampaignCriterion()
    {
        Campaign = campaignResourceName,
        Proximity = proximity
    };
}
AddCampaignTargetingCriteria.cs

PHP

private static function createProximityCampaignCriterionOperation(string $campaignResourceName)
{
    // Constructs a campaign criterion as a proximity.
    $campaignCriterion = new CampaignCriterion([
        'proximity' => new ProximityInfo([
            'address' => new AddressInfo([
                'street_address' => '38 avenue de l\'Opéra',
                'city_name' => 'Paris',
                'postal_code' => '75002',
                'country_code' => 'FR',
            ]),
            'radius' => 10.0,
            // Default is kilometers.
            'radius_units' => ProximityRadiusUnits::MILES
        ]),
        'campaign' => $campaignResourceName
    ]);

    return new CampaignCriterionOperation(['create' => $campaignCriterion]);
}
AddCampaignTargetingCriteria.php

Python

def create_proximity_op(
    client: GoogleAdsClient, customer_id: str, campaign_id: str
) -> CampaignCriterionOperation:
    campaign_service: CampaignServiceClient = client.get_service(
        "CampaignService"
    )

    # Create the campaign criterion.
    campaign_criterion_operation: CampaignCriterionOperation = client.get_type(
        "CampaignCriterionOperation"
    )
    campaign_criterion: CampaignCriterion = campaign_criterion_operation.create
    campaign_criterion.campaign = campaign_service.campaign_path(
        customer_id, campaign_id
    )
    campaign_criterion.proximity.address.street_address = "38 avenue de l'Opera"
    campaign_criterion.proximity.address.city_name = "Paris"
    campaign_criterion.proximity.address.postal_code = "75002"
    campaign_criterion.proximity.address.country_code = "FR"
    campaign_criterion.proximity.radius = 10
    # Default is kilometers.
    campaign_criterion.proximity.radius_units = (
        client.enums.ProximityRadiusUnitsEnum.MILES
    )

    return campaign_criterion_operation
add_campaign_targeting_criteria.py

Ruby

def create_proximity(client, customer_id, campaign_id)
  client.operation.create_resource.campaign_criterion do |criterion|
    criterion.campaign = client.path.campaign(customer_id, campaign_id)

    criterion.proximity = client.resource.proximity_info do |proximity|
      proximity.address = client.resource.address_info do |address|
        address.street_address = "38 avenue de l'Opéra"
        address.city_name = "Paris"
        address.postal_code = "75002"
        address.country_code = "FR"
      end

      proximity.radius = 10
      proximity.radius_units = :MILES
    end
  end
end
add_campaign_targeting_criteria.rb

Perl

sub create_proximity_campaign_criterion_operation {
  my ($campaign_resource_name) = @_;

  # Construct a campaign criterion as a proximity.
  my $campaign_criterion =
    Google::Ads::GoogleAds::V24::Resources::CampaignCriterion->new({
      proximity => Google::Ads::GoogleAds::V24::Common::ProximityInfo->new({
          address => Google::Ads::GoogleAds::V24::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::V24::Services::CampaignCriterionService::CampaignCriterionOperation
    ->new({
      create => $campaign_criterion
    });
}
add_campaign_targeting_criteria.pl

curl

Geografische Ziele abrufen

Sie können die geografischen Ziele für eine Kampagne mit den GoogleAdsService.SearchStream abrufen. Sie können die Ergebnisse in der WHERE-Klausel filtern.

SELECT
  campaign_criterion.campaign,
  campaign_criterion.location.geo_target_constant,
  campaign_criterion.proximity.geo_point.longitude_in_micro_degrees,
  campaign_criterion.proximity.geo_point.latitude_in_micro_degrees,
  campaign_criterion.proximity.radius,
  campaign_criterion.negative
FROM campaign_criterion
WHERE
  campaign_criterion.campaign = 'customers/{customer_id}/campaigns/{campaign_id}'
  AND campaign_criterion.type IN (LOCATION, PROXIMITY)

Geografische Ziele aktualisieren

Wenn Sie geografische Ziele für eine Kampagne aktualisieren möchten, müssen Sie die Liste der vorhandenen geografischen Ziele abrufen und mit der Liste der neuen Ziele vergleichen. Anschließend können Sie mit dem Vorgang remove die nicht benötigten Ziele entfernen und mit dem Vorgang create die neuen geografischen Ziele hinzufügen, die in der vorhandenen Kampagne fehlen.

Geografische Ziele ausschließen

Sie können auch LocationInfo, aber nicht ProximityInfo ausschließen. Diese Funktion ist besonders nützlich, wenn Sie eine Region ausrichten, aber eine Unterregion ausschließen möchten (z. B. die gesamten USA, außer 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. Eine Region ist auf die Standorte zentriert, die durch die Standorterweiterungen der Kampagne definiert werden.

Der in LocationGroupInfo definierte Radius beschreibt eine kreisförmige Region um jeden Standort und besteht aus einem radius-Objekt, einer Länge und radius_units, die mit LocationGroupRadiusUnitsEnum entweder Meter oder Meilen sein können.

Die Standorte in einem LocationGroupInfo können nach einer Liste von Kriteriums-IDs für die geografische Ausrichtung gefiltert werden, die im Feld geo_target_constant angegeben sind. Wenn definiert, werden keine Standorte ausgerichtet, die außerhalb der angegebenen Kriteriums-IDs liegen.

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 positives Targeting (positive_geo_target_type)

Sie können aus den folgenden Optionen für das positive Standort-Targeting auswählen, verwenden Sie dazu Werte aus PositiveGeoTargetTypeEnum:

  1. PRESENCE_OR_INTEREST (empfohlener Standard):

    • Erreicht Nutzer, die sich wahrscheinlich in Ihren Zielregionen befinden oder sich regelmäßig dort aufhalten, PLUS 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.

  2. PRESENCE:

    • Erreicht nur Nutzer, die sich wahrscheinlich physisch in Ihren Zielregionen befinden oder sich regelmäßig dort aufhalten.
    • 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 befinden.

Hinweis: Andere Werte wie SEARCH_INTEREST sind veraltet und können für die meisten Kampagnentypen nicht mehr festgelegt werden.

Einstellungen für ausschließendes Targeting (negative_geo_target_type)

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

  1. PRESENCE (empfohlener Standard) :
    • Schließt Nutzer aus, die sich wahrscheinlich physisch an den von Ihnen ausgeschlossenen Standorten befinden.
    • Nutzer außerhalb der ausgeschlossenen Regionen können Ihre Anzeigen weiterhin sehen, auch wenn sie Interesse an ihnen haben, sofern sie mit Ihrem positiven Targeting übereinstimmen.

Hinweis: Der Wert PRESENCE_OR_INTEREST wird für das negative geografische Targeting bei den meisten Kampagnentypen in der Regel nicht unterstützt.

Erweiterte Standortoptionen verwalten

Sie können diese Einstellungen verwalten, indem Sie das Objekt Campaign.geo_target_type_setting aktualisieren.

Beispiel: Kampagne so einstellen, dass nur nach PRESENCE ausgerichtet wird

Hier ein konzeptionelles Beispiel dafür, wie Sie einen API-Aufruf strukturieren können, um positive_geo_target_type zu ändern. Der genaue Code variiert je nach Sprache der Clientbibliothek.

// Conceptual structure for a Campaign update operation
operations {
  update {
    resource_name: "customers/{customer_id}/campaigns/{campaign_id}"
    geo_target_type_setting {
      positive_geo_target_type: PRESENCE
      // negative_geo_target_type remains at its default PRESENCE if not specified
    }
  }
  update_mask {
    paths: "geo_target_type_setting.positive_geo_target_type"
  }
}

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 Geschäftsziele besser erreichen.

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 befinden. Angenommen, Sie verlangen, dass Nutzer im Geschäft sind oder eine lokale Lieferung erforderlich ist.
  • Wählen Sie PRESENCE_OR_INTEREST aus, wenn Ihr Produkt oder Ihre Dienstleistung auch für Nutzer von Vorteil sein kann, die Interesse an einem Standort haben, auch wenn sie sich nicht physisch dort befinden. Ein Nutzer, der einen Urlaub plant, könnte sich beispielsweise für Hotels in der Zielstadt interessieren.
  • Verwenden Sie das Targeting auf auszuschließende Standorte, um die Reichweite zu optimieren. Wenn Sie die USA mit PRESENCE_OR_INTEREST 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 wird verhindert, dass Ihre Anzeigen Nutzern in diesem Bundesstaat angezeigt werden. Gleichzeitig erreichen Sie aber Nutzer außerhalb dieses Bundesstaats, die sich für Standorte in den USA interessieren könnten.

Nächste Schritte

Zurück
Gebotsanpassungen
Weiter
Ausrichtungseinst.