Keyword-Ideen generieren

Mit dem KeywordPlanIdeaService können Sie Keyword-Vorschläge finden, die für Ihre Google Suche Kampagne relevant sind, oder bisherige Messwerte für eine vorhandene Keyword-Liste abrufen.

Ideen generieren

Mit KeywordPlanIdeaService.GenerateKeywordIdeas können Sie Keyword-Ideen für eine Kampagne generieren.

Sie können Keyword- und URL-Seeds angeben, um Ideen zu generieren. Legen Sie Targeting-Parameter wie Standorte, Sprache und Netzwerkeinstellungen fest, um die Suche einzugrenzen. Der Dienst gibt bisherige Statistiken wie Daten zum Suchvolumen zurück, damit Sie entscheiden können, ob Sie die Keywords in Ihrer Kampagne verwenden möchten. Für Nutzer , die mit der Google Ads-Benutzeroberfläche vertraut sind, ist dies ähnlich wie der Keyword-Planer.

Hinweis: Für den Aufruf dieser Methode ist keine KeywordPlan-Ressource erforderlich. Sie können die zurückgegebenen Keyword-Ideen direkt an GenerateAdGroupThemes übergeben, um sie in Anzeigengruppen themen zu organisieren, an GenerateKeywordForecastMetrics (mit einem Inline CampaignToForecast) übergeben, um die zukünftige Leistung zu schätzen, oder sie verwenden, um eine Kampagne für die Auslieferung zu erstellen.

Es gibt mehrere Möglichkeiten, Seeds zum Generieren von Keyword-Ideen zu erstellen:

• Für Wörter oder Wortgruppen, die beschreiben, was Sie bewerben, verwenden Sie KeywordSeed (mindestens 1 und bis zu 20 Keywords erforderlich). Dabei kann es sich um eine allgemeine Art von Unternehmen handeln, auf die Sie abzielen, z. B. Klempner, oder um ein Produkt oder eine Dienstleistung, die Sie anbieten, z. B. Rohrreinigung.

• Für die URL einer Webseite oder einer gesamten Website, die sich auf Ihr Unternehmen bezieht, verwenden Sie UrlSeed. Der URL-Seed zielt nur auf eine bestimmte URL ab. Wenn keine Treffer vorhanden sind, wird die Suche automatisch auf die Seiten derselben Domain ausgeweitet.

  Bei URL-Seeds verwendet der Dienst nicht den Inhalt von Hyperlinks, um Keyword-Ideen zu generieren.

• Für Keyword-Seeds und URL-Seeds verwenden Sie KeywordAndUrlSeed (1 bis 20 Keywords zusammen mit einer URL erforderlich).

  Die Verwendung von KeywordAndUrlSeed kann zu einer größeren Anzahl von Keyword-Ideen führen als die Verwendung von UrlSeed allein.

• Für eine gesamte Website verwenden Sie SiteSeed. Bei einem Top-Level-Domainnamen wie www.example.com generiert der Site-Seed bis zu 250.000 Keyword-Ideen aus öffentlich verfügbaren Informationen.

Um das Targeting einzugrenzen, können Sie language, Standort (bis zu 10 geo_target_constants), keyword_plan_network, include_adult_keywords, keyword_annotation (Keywords optimieren) und historical_metrics_options konfigurieren.

Die Antwort unterstützt die Paginierung (bis zu 10.000 Ergebnisse pro Seite). Prüfen Sie immer next_page_token, um festzustellen, ob weitere Seiten verfügbar sind, da auf einer Seite möglicherweise weniger als page_size Ergebnisse zurückgegeben werden, bevor die letzte Seite erreicht ist. Jedes GenerateKeywordIdeaResult gibt den kanonischen text (mit close_variants), bisherige keyword_idea_metrics zum Filtern vor dem Generieren von Prognose messwerten und optionale keyword_annotations zurück.

Referenz zu Anfrage- und Antwortfeldern

Rufen Sie KeywordPlanIdeaService.GenerateKeywordIdeas am folgenden Endpunkt auf:

POST https://googleads.googleapis.com/v26/customers/{customer_id}:generateKeywordIdeas

In der folgenden Tabelle sind die Felder und Einschränkungen für GenerateKeywordIdeasRequest zusammengefasst:

Anfragefeld	Anforderung	Format und Einschränkungen
customer_id	Erforderlich	10-stellige Kundennummer (string) ohne Bindestriche.
seed (oneof)	Erforderlich	Geben Sie eine der folgenden Optionen an: • keyword_seed: keywords[] (1 bis 20 Strings). • url_seed: url (bestimmte Seiten-URL). • keyword_and_url_seed: url plus 1 bis 20 keywords[]. • site_seed: site (Domainname wie www.example.com, gibt bis zu 250.000 Ideen zurück).
language	Optional	Ressourcenname des Sprachkriteriums (languageConstants/{criterion_id}, z. B. languageConstants/1000 für Englisch). Weitere Informationen finden Sie unter Sprachkonstanten. Wenn diese Option nicht angegeben wird, werden Keywords in allen Sprachen berücksichtigt.
geo_target_constants[]	Optional	Bis zu 10 Ressourcenname für Standorte (geoTargetConstants/{criterion_id}, z. B. geoTargetConstants/2840 für die USA). Weitere Informationen finden Sie unter Ziel für das geografische Targeting. Eine leere Liste zielt auf alle geografischen Einheiten ab.
keyword_plan_network	Optional	KeywordPlanNetwork (GOOGLE_SEARCH oder GOOGLE_SEARCH_AND_PARTNERS). Die Standardeinstellung ist GOOGLE_SEARCH_AND_PARTNERS.
include_adult_keywords	Optional	bool, mit dem gesteuert wird, ob Keywords für Inhalte für Erwachsene zurückgegeben werden. Die Standardeinstellung ist false.
keyword_annotation[]	Optional	Liste der KeywordPlanKeywordAnnotation-Werte (z. B. KEYWORD_CONCEPT), um keyword_annotations für jedes Ergebnis zu füllen.
aggregate_metrics	Optional	KeywordPlanAggregateMetrics mit aggregate_metric_types auf DEVICE gesetzt, um nach Geräten segmentierte Suchanfragen in aggregate_metric_results zurückzugeben.
historical_metrics_options	Optional	HistoricalMetricsOptions mit optionalem year_month_range (verfügbar für die letzten 4 Jahre, Standardeinstellung sind die letzten 12 Monate) und include_average_cpc.
page_size und page_token	Optional	Maximale Anzahl der Ergebnisse pro Seite (int32, bis zu 10,000) und Fortsetzungstoken aus next_page_token. Alle anderen Anfragefelder müssen bei paginierten Anfragen identisch sein.

Die GenerateKeywordIdeaResponse Nachricht gibt die folgenden Felder zurück:

Antwortfeld	Typ	Beschreibung
results[].text	string	Kanonischer Keyword-Ideen-Text, der den Vorschlag und die kombinierten close_variants[] darstellt.
results[].close_variants[]	string[]	Ähnliche Varianten, die in diesem GenerateKeywordIdeaResult kombiniert wurden.
results[].keyword_idea_metrics	KeywordPlanHistoricalMetrics	Suchvolumen: avg_monthly_searches (12-Monats-Durchschnitt) und monthly_search_volumes[] (year, month, monthly_searches). Wettbewerb: competition (LOW, MEDIUM, HIGH) und competition_index (0 bis 100). Gebote und CPC: low_top_of_page_bid_micros (20. Perzentil), high_top_of_page_bid_micros (80. Perzentil) und average_cpc_micros (wird ausgefüllt, wenn include_average_cpc = true).
results[].keyword_annotations	KeywordAnnotations	Wird ausgefüllt, wenn KEYWORD_CONCEPT in keyword_annotation angefordert wird. Enthält concepts[] (name, concept_group.name und concept_group.type).
aggregate_metric_results	KeywordPlanAggregateMetricResults	Wird ausgefüllt, wenn DEVICE in aggregate_metrics angefordert wird. Enthält device_searches[] (MOBILE, TABLET, DESKTOP).
next_page_token und total_size	string, int64	Fortsetzungstoken für die nächste Seite (wird auf der letzten Seite weggelassen) und Gesamtzahl der verfügbaren Keyword-Ideen.

Codebeispiel

Java

private void runExample(
    GoogleAdsClient googleAdsClient,
    long customerId,
    long languageId,
    List<Long> locationIds,
    List<String> keywords,
    @Nullable String pageUrl) {
  try (KeywordPlanIdeaServiceClient keywordPlanServiceClient =
      googleAdsClient.getLatestVersion().createKeywordPlanIdeaServiceClient()) {
    GenerateKeywordIdeasRequest.Builder requestBuilder =
        GenerateKeywordIdeasRequest.newBuilder()
            .setCustomerId(Long.toString(customerId))
            // Sets the language resource using the provided language ID.
            .setLanguage(ResourceNames.languageConstant(languageId))
            // Sets the network. To restrict to only Google Search, change the parameter below to
            // KeywordPlanNetwork.GOOGLE_SEARCH.
            .setKeywordPlanNetwork(KeywordPlanNetwork.GOOGLE_SEARCH_AND_PARTNERS);

    // Adds the resource name of each location ID to the request.
    for (Long locationId : locationIds) {
      requestBuilder.addGeoTargetConstants(ResourceNames.geoTargetConstant(locationId));
    }

    // Makes sure that keywords and/or page URL were specified. The request must have exactly one
    // of urlSeed, keywordSeed, or keywordAndUrlSeed set.
    if (keywords.isEmpty() && pageUrl == null) {
      throw new IllegalArgumentException(
          "At least one of keywords or page URL is required, but neither was specified.");
    }

    if (keywords.isEmpty()) {
      // Only page URL was specified, so use a UrlSeed.
      requestBuilder.getUrlSeedBuilder().setUrl(pageUrl);
    } else if (pageUrl == null) {
      // Only keywords were specified, so use a KeywordSeed.
      requestBuilder.getKeywordSeedBuilder().addAllKeywords(keywords);
    } else {
      // Both page URL and keywords were specified, so use a KeywordAndUrlSeed.
      requestBuilder.getKeywordAndUrlSeedBuilder().setUrl(pageUrl).addAllKeywords(keywords);
    }

    // Sends the keyword ideas request.
    GenerateKeywordIdeasPagedResponse response =
        keywordPlanServiceClient.generateKeywordIdeas(requestBuilder.build());
    // Prints each result in the response.
    for (GenerateKeywordIdeaResult result : response.iterateAll()) {
      System.out.printf(
          "Keyword idea text '%s' has %d average monthly searches and '%s' competition.%n",
          result.getText(),
          result.getKeywordIdeaMetrics().getAvgMonthlySearches(),
          result.getKeywordIdeaMetrics().getCompetition());
    }
  }
}
GenerateKeywordIdeas.java
      

C#

public void Run(GoogleAdsClient client, long customerId, long[] locationIds,
    long languageId, string[] keywordTexts, string pageUrl)
{
    KeywordPlanIdeaServiceClient keywordPlanIdeaService =
        client.GetService(Services.V26.KeywordPlanIdeaService);

    // Make sure that keywords and/or page URL were specified. The request must have
    // exactly one of urlSeed, keywordSeed, or keywordAndUrlSeed set.
    if (keywordTexts.Length == 0 && string.IsNullOrEmpty(pageUrl))
    {
        throw new ArgumentException("At least one of keywords or page URL is required, " +
            "but neither was specified.");
    }

    // Specify the optional arguments of the request as a keywordSeed, UrlSeed,
    // or KeywordAndUrlSeed.
    GenerateKeywordIdeasRequest request = new GenerateKeywordIdeasRequest()
    {
        CustomerId = customerId.ToString(),
    };

    if (keywordTexts.Length == 0)
    {
        // Only page URL was specified, so use a UrlSeed.
        request.UrlSeed = new UrlSeed()
        {
            Url = pageUrl
        };
    }
    else if (string.IsNullOrEmpty(pageUrl))
    {
        // Only keywords were specified, so use a KeywordSeed.
        request.KeywordSeed = new KeywordSeed();
        request.KeywordSeed.Keywords.AddRange(keywordTexts);
    }
    else
    {
        // Both page URL and keywords were specified, so use a KeywordAndUrlSeed.
        request.KeywordAndUrlSeed = new KeywordAndUrlSeed();
        request.KeywordAndUrlSeed.Url = pageUrl;
        request.KeywordAndUrlSeed.Keywords.AddRange(keywordTexts);
    }

    // Create a list of geo target constants based on the resource name of specified
    // location IDs.
    foreach (long locationId in locationIds)
    {
        request.GeoTargetConstants.Add(ResourceNames.GeoTargetConstant(locationId));
    }

    request.Language = ResourceNames.LanguageConstant(languageId);
    // Set the network. To restrict to only Google Search, change the parameter below to
    // KeywordPlanNetwork.GoogleSearch.
    request.KeywordPlanNetwork = KeywordPlanNetwork.GoogleSearchAndPartners;

    try
    {
        // Generate keyword ideas based on the specified parameters.
        var response =
            keywordPlanIdeaService.GenerateKeywordIdeas(request);

        // Iterate over the results and print its detail.
        foreach (GenerateKeywordIdeaResult result in response)
        {
            KeywordPlanHistoricalMetrics metrics = result.KeywordIdeaMetrics;
            Console.WriteLine($"Keyword idea text '{result.Text}' has " +
                $"{metrics.AvgMonthlySearches} average monthly searches and competition " +
                $"is {metrics.Competition}.");
        }
    }
    catch (GoogleAdsException e)
    {
        Console.WriteLine("Failure:");
        Console.WriteLine($"Message: {e.Message}");
        Console.WriteLine($"Failure: {e.Failure}");
        Console.WriteLine($"Request ID: {e.RequestId}");
        throw;
    }
}
GenerateKeywordIdeas.cs
      

PHP

public static function runExample(
    GoogleAdsClient $googleAdsClient,
    int $customerId,
    array $locationIds,
    int $languageId,
    array $keywords,
    ?string $pageUrl
) {
    $keywordPlanIdeaServiceClient = $googleAdsClient->getKeywordPlanIdeaServiceClient();

    // Make sure that keywords and/or page URL were specified. The request must have exactly one
    // of urlSeed, keywordSeed, or keywordAndUrlSeed set.
    if (empty($keywords) && is_null($pageUrl)) {
        throw new \InvalidArgumentException(
            'At least one of keywords or page URL is required, but neither was specified.'
        );
    }

    // Specify the optional arguments of the request as a keywordSeed, urlSeed,
    // or keywordAndUrlSeed.
    $requestOptionalArgs = [];
    if (empty($keywords)) {
        // Only page URL was specified, so use a UrlSeed.
        $requestOptionalArgs['url_seed'] = new UrlSeed(['url' => $pageUrl]);
    } elseif (is_null($pageUrl)) {
        // Only keywords were specified, so use a KeywordSeed.
        $requestOptionalArgs['keyword_seed'] = new KeywordSeed(['keywords' => $keywords]);
    } else {
        // Both page URL and keywords were specified, so use a KeywordAndUrlSeed.
        $requestOptionalArgs['keyword_and_url_seed'] =
            new KeywordAndUrlSeed(['url' => $pageUrl, 'keywords' => $keywords]);
    }

    // Create a list of geo target constants based on the resource name of specified location
    // IDs.
    $geoTargetConstants =  array_map(function ($locationId) {
        return ResourceNames::forGeoTargetConstant($locationId);
    }, $locationIds);

    // Generate keyword ideas based on the specified parameters.
    $response = $keywordPlanIdeaServiceClient->generateKeywordIdeas(
        new GenerateKeywordIdeasRequest([
            // Set the language resource using the provided language ID.
            'language' => ResourceNames::forLanguageConstant($languageId),
            'customer_id' => $customerId,
            // Add the resource name of each location ID to the request.
            'geo_target_constants' => $geoTargetConstants,
            // Set the network. To restrict to only Google Search, change the parameter below to
            // KeywordPlanNetwork::GOOGLE_SEARCH.
            'keyword_plan_network' => KeywordPlanNetwork::GOOGLE_SEARCH_AND_PARTNERS
        ] + $requestOptionalArgs)
    );

    // Iterate over the results and print its detail.
    foreach ($response->iterateAllElements() as $result) {
        /** @var GenerateKeywordIdeaResult $result */
        // Note that the competition printed below is enum value.
        // For example, a value of 2 will be returned when the competition is 'LOW'.
        // A mapping of enum names to values can be found at KeywordPlanCompetitionLevel.php.
        printf(
            "Keyword idea text '%s' has %d average monthly searches and competition as %d.%s",
            $result->getText(),
            is_null($result->getKeywordIdeaMetrics()) ?
                0 : $result->getKeywordIdeaMetrics()->getAvgMonthlySearches(),
            is_null($result->getKeywordIdeaMetrics()) ?
                0 : $result->getKeywordIdeaMetrics()->getCompetition(),
            PHP_EOL
        );
    }
}
GenerateKeywordIdeas.php
      

Python

def main(
    client: GoogleAdsClient,
    customer_id: str,
    location_ids: list[str],
    language_id: str,
    keyword_texts: list[str],
    page_url: str,
):
    keyword_plan_idea_service: KeywordPlanIdeaServiceClient = (
        client.get_service("KeywordPlanIdeaService")
    )
    keyword_competition_level_enum: KeywordPlanCompetitionLevelEnum = (
        client.enums.KeywordPlanCompetitionLevelEnum
    )
    keyword_plan_network: KeywordPlanNetworkEnum = (
        client.enums.KeywordPlanNetworkEnum.GOOGLE_SEARCH_AND_PARTNERS
    )
    location_rns: list[str] = map_locations_ids_to_resource_names(
        client, location_ids
    )
    google_ads_service: GoogleAdsServiceClient = client.get_service(
        "GoogleAdsService"
    )
    language_rn: str = google_ads_service.language_constant_path(language_id)

    # Either keywords or a page_url are required to generate keyword ideas
    # so this raises an error if neither are provided.
    if not (keyword_texts or page_url):
        raise ValueError(
            "At least one of keywords or page URL is required, "
            "but neither was specified."
        )

    # Only one of the fields "url_seed", "keyword_seed", or
    # "keyword_and_url_seed" can be set on the request, depending on whether
    # keywords, a page_url or both were passed to this function.
    request: GenerateKeywordIdeasRequest = client.get_type(
        "GenerateKeywordIdeasRequest"
    )
    request.customer_id = customer_id
    request.language = language_rn
    request.geo_target_constants = location_rns
    request.include_adult_keywords = False
    request.keyword_plan_network = keyword_plan_network

    # To generate keyword ideas with only a page_url and no keywords we need
    # to initialize a UrlSeed object with the page_url as the "url" field.
    if not keyword_texts and page_url:
        request.url_seed.url = page_url

    # To generate keyword ideas with only a list of keywords and no page_url
    # we need to initialize a KeywordSeed object and set the "keywords" field
    # to be a list of StringValue objects.
    if keyword_texts and not page_url:
        request.keyword_seed.keywords.extend(keyword_texts)

    # To generate keyword ideas using both a list of keywords and a page_url we
    # need to initialize a KeywordAndUrlSeed object, setting both the "url" and
    # "keywords" fields.
    if keyword_texts and page_url:
        request.keyword_and_url_seed.url = page_url
        request.keyword_and_url_seed.keywords.extend(keyword_texts)

    keyword_ideas = keyword_plan_idea_service.generate_keyword_ideas(
        request=request
    )

    idea: GenerateKeywordIdeaResult
    for idea in keyword_ideas:
        competition_value = idea.keyword_idea_metrics.competition.name
        print(
            f'Keyword idea text "{idea.text}" has '
            f'"{idea.keyword_idea_metrics.avg_monthly_searches}" '
            f'average monthly searches and "{competition_value}" '
            "competition.\n"
        )
generate_keyword_ideas.py
      

Ruby

def generate_keyword_ideas(customer_id, location_ids, language_id, keywords,
    page_url)
  # GoogleAdsClient will read a config file from
  # ENV['HOME']/google_ads_config.rb when called without parameters
  client = Google::Ads::GoogleAds::GoogleAdsClient.new

  # Make sure that keywords and/or page URL were specified. The request must
  # have exactly one of urlSeed, keywordSeed, or keywordAndUrlSeed set.
  if keywords.reject {|k| k.nil?}.empty? && page_url.nil?
    raise "At least one of keywords or page URL is required."
  end

  kp_idea_service = client.service.keyword_plan_idea

  options_hash = if keywords.empty?
                   seed = client.resource.url_seed do |seed|
                     seed.url = page_url
                   end
                   {url_seed: seed}
                 elsif page_url.nil?
                   seed = client.resource.keyword_seed do |seed|
                     keywords.each do |keyword|
                       seed.keywords << keyword
                     end
                   end
                   {keyword_seed: seed}
                 else
                   seed = client.resource.keyword_and_url_seed do |seed|
                     seed.url = page_url
                     keywords.each do |keyword|
                       seed.keywords << keyword
                     end
                   end
                   {keyword_and_url_seed: seed}
                 end

  geo_target_constants = location_ids.map do |location_id|
    client.path.geo_target_constant(location_id)
  end

  include_adult_keywords = true

  response = kp_idea_service.generate_keyword_ideas(
    customer_id: customer_id,
    language: client.path.language_constant(language_id),
    geo_target_constants: geo_target_constants,
    include_adult_keywords: include_adult_keywords,
    # To restrict to only Google Search, change the parameter below to
    # :GOOGLE_SEARCH
    keyword_plan_network: :GOOGLE_SEARCH_AND_PARTNERS,
    **options_hash
  )

  response.each do |result|
    monthly_searches = if result.keyword_idea_metrics.nil?
                         0
                       else
                         result.keyword_idea_metrics.avg_monthly_searches
                       end
    competition = if result.keyword_idea_metrics.nil?
                    :UNSPECIFIED
                  else
                    result.keyword_idea_metrics.competition
                  end
    puts "Keyword idea text #{result.text} has #{monthly_searches} average " +
        "monthly searches and competition as #{competition}."
  end
end
generate_keyword_ideas.rb
      

Perl

sub generate_keyword_ideas {
  my (
    $api_client,  $customer_id,   $location_ids,
    $language_id, $keyword_texts, $page_url
  ) = @_;

  # Make sure that keywords and/or page URL were specified. The request must have
  # exactly one of urlSeed, keywordSeed, or keywordAndUrlSeed set.
  if (not scalar @$keyword_texts and not $page_url) {
    die "At least one of keywords or page URL is required, " .
      "but neither was specified.";
  }

  # Specify the optional arguments of the request as a keywordSeed, urlSeed,
  # or keywordAndUrlSeed.
  my $request_option_args = {};
  if (!scalar @$keyword_texts) {
    # Only page URL was specified, so use a UrlSeed.
    $request_option_args->{urlSeed} =
      Google::Ads::GoogleAds::V26::Services::KeywordPlanIdeaService::UrlSeed->
      new({
        url => $page_url
      });
  } elsif (not $page_url) {
    # Only keywords were specified, so use a KeywordSeed.
    $request_option_args->{keywordSeed} =
      Google::Ads::GoogleAds::V26::Services::KeywordPlanIdeaService::KeywordSeed
      ->new({
        keywords => $keyword_texts
      });
  } else {
    # Both page URL and keywords were specified, so use a KeywordAndUrlSeed.
    $request_option_args->{keywordAndUrlSeed} =
      Google::Ads::GoogleAds::V26::Services::KeywordPlanIdeaService::KeywordAndUrlSeed
      ->new({
        url      => $page_url,
        keywords => $keyword_texts
      });
  }

  # Create a list of geo target constants based on the resource name of specified
  # location IDs.
  my $geo_target_constants = [
    map (
      Google::Ads::GoogleAds::V26::Utils::ResourceNames::geo_target_constant(
        $_),
      @$location_ids)];

  # Generate keyword ideas based on the specified parameters.
  my $keyword_ideas_response =
    $api_client->KeywordPlanIdeaService()->generate_keyword_ideas({
      customerId => $customer_id,
      # Set the language resource using the provided language ID.
      language =>
        Google::Ads::GoogleAds::V26::Utils::ResourceNames::language_constant(
        $language_id),
      # Add the resource name of each location ID to the request.
      geoTargetConstants => $geo_target_constants,
      # Set the network. To restrict to only Google Search, change the parameter below
      # to GOOGLE_SEARCH.
      keywordPlanNetwork => GOOGLE_SEARCH_AND_PARTNERS,
      %$request_option_args
    });

  # Iterate over the results and print its detail.
  foreach my $result (@{$keyword_ideas_response->{results}}) {
    printf "Keyword idea text '%s' has %d average monthly searches " .
      "and '%s' competition.\n", $result->{text},
      $result->{keywordIdeaMetrics}{avgMonthlySearches}
      ? $result->{keywordIdeaMetrics}{avgMonthlySearches}
      : 0,
      $result->{keywordIdeaMetrics}{competition}
      ? $result->{keywordIdeaMetrics}{competition}
      : "undef";
  }

  return 1;
}
generate_keyword_ideas.pl
      

curl

# This code example generates keyword ideas.
#
# Variables:
#   API_VERSION,
#   CUSTOMER_ID,
#   MANAGER_CUSTOMER_ID,
#   OAUTH2_ACCESS_TOKEN:
#     See https://developers.google.com/google-ads/api/rest/auth#request_headers
#     for details.
#
#   LANGUAGE: The resource name of the language to target. This is in the format
#     of "languageConstants/{criterion_id}". See
#     https://developers.google.com/google-ads/api/data/codes-formats#languages
#     for the available criterion_id values.
#   GEO_TARGET_CONSTANT: The resource name of the geo target constant to
#     generate keyword ideas for. This is in the format of
#     "geoTargetConstants/{criterion_id}". See
#     https://developers.google.com/google-ads/api/data/geotargets for the
#     available criterion_id values.
#   KEYWORD: The keyword to generate keyword ideas for.
#   URL: The URL of the website to generate keyword ideas for.
curl -f --request POST \
"https://googleads.googleapis.com/v${API_VERSION}/customers/${CUSTOMER_ID}:generateKeywordIdeas" \
--header "Content-Type: application/json" \
--header "login-customer-id: ${MANAGER_CUSTOMER_ID}" \
--header "Authorization: Bearer ${OAUTH2_ACCESS_TOKEN}" \
--data @- <<EOF
{
  "language": "${LANGUAGE}",
  "geoTargetConstants": [
    "${GEO_TARGET_CONSTANT}"
  ],
  "includeAdultKeywords": false,
  "keywordPlanNetwork": "GOOGLE_SEARCH",
  "keywordAndUrlSeed": {
    "keywords": [
      "${KEYWORD}"
    ],
    "url": "${URL}"
  }
}
EOF
generate_keyword_ideas.sh
      

Struktur von REST-Anfragen und -Antworten

Im folgenden Beispiel wird eine POST Anfrage an KeywordPlanIdeaService.GenerateKeywordIdeas mit keywordAndUrlSeed, Englisch (languageConstants/1000) und den USA (geoTargetConstants/2840) gesendet:

POST https://googleads.googleapis.com/v26/customers/{customer_id}:generateKeywordIdeas

{
  "language": "languageConstants/1000",
  "geoTargetConstants": [
    "geoTargetConstants/2840"
  ],
  "includeAdultKeywords": false,
  "keywordPlanNetwork": "GOOGLE_SEARCH",
  "keywordAnnotation": [
    "KEYWORD_CONCEPT"
  ],
  "keywordAndUrlSeed": {
    "url": "https://www.example.com/mars-cruises",
    "keywords": [
      "mars cruise",
      "space vacation"
    ]
  }
}

Eine erfolgreiche Antwort gibt GenerateKeywordIdeaResult Zeilen in results[] zusammen mit dem bisherigen Suchvolumen und Gebotsbereichen zurück:

{
  "results": [
    {
      "text": "mars cruise",
      "keywordIdeaMetrics": {
        "avgMonthlySearches": "12100",
        "competition": "MEDIUM",
        "competitionIndex": "54",
        "lowTopOfPageBidMicros": "1450000",
        "highTopOfPageBidMicros": "4800000",
        "monthlySearchVolumes": [
          {
            "year": "2026",
            "month": "MAY",
            "monthlySearches": "14800"
          }
        ]
      },
      "keywordAnnotations": {
        "concepts": [
          {
            "name": "Space Travel",
            "conceptGroup": {
              "name": "Travel",
              "type": "OTHERS"
            }
          }
        ]
      }
    }
  ],
  "totalSize": "1"
}

Zuordnung zur Benutzeroberfläche

In der folgenden Tabelle werden KeywordPlanIdeaService.GenerateKeywordIdeas Parameter dem Keyword-Planer in der Google Ads-Benutzeroberfläche zugeordnet:

Keyword-Planer in der Benutzeroberfläche	Google Ads API
Suchbegriffe und URLs eingeben	GenerateKeywordIdeasRequest.keyword_and_url_seed GenerateKeywordIdeasRequest.keyword_seed GenerateKeywordIdeasRequest.url_seed GenerateKeywordIdeasRequest.site_seed
Standorte	GenerateKeywordIdeasRequest.geo_target_constants
Keywords für Inhalte für Erwachsene	GenerateKeywordIdeasRequest.include_adult_keywords
Sprache	GenerateKeywordIdeasRequest.language
Suchnetzwerke	GenerateKeywordIdeasRequest.keyword_plan_network
Keywords optimieren	GenerateKeywordIdeasRequest.keyword_annotation
Datumsbereich	GenerateKeywordIdeasRequest.historical_metrics_options
Ergebnisse: Keyword	GenerateKeywordIdeaResult.text
Ergebnisse: Messwerte	GenerateKeywordIdeaResult.keyword_idea_metrics