Google używa technologii AI do tłumaczenia treści na Twój preferowany język. Tłumaczenia wygenerowane przez AI mogą zawierać błędy.

Wygeneruj propozycje słów kluczowych

Za pomocą KeywordPlanIdeaService możesz odkrywać propozycje słów kluczowych, które są istotne dla Twojej kampanii w sieci wyszukiwania Google, lub pobierać historyczne dane o istniejącej liście słów kluczowych.

Wygeneruj pomysły

Generuj propozycje słów kluczowych dla kampanii za pomocą KeywordPlanIdeaService.GenerateKeywordIdeas.

Aby wygenerować propozycje, możesz podać słowa kluczowe i adresy URL. Aby zawęzić wyszukiwanie, ustaw parametry kierowania, takie jak lokalizacje, język i ustawienia sieci. Usługa zwraca statystyki historyczne, takie jak dane o liczbie wyszukiwań, które pomagają zdecydować, czy używać słów kluczowych w kampanii. Użytkownicy znający interfejs Google Ads mogą uznać, że jest to podobne do Planera słów kluczowych.

Istnieje kilka sposobów tworzenia danych początkowych do generowania propozycji słów kluczowych:

W przypadku słów lub fraz opisujących reklamowany produkt, użyj KeywordSeed (wymaga co najmniej 1 i maksymalnie 20 słów kluczowych). Może to być ogólny typ firmy, na którą kierujesz reklamy, np. hydraulicy, lub oferowany produkt bądź usługa, np. czyszczenie rur.
W przypadku adresu URL strony lub całej witryny związanej z Twoją firmą użyj UrlSeed. Dane początkowe URL są kierowane tylko na konkretny adres URL. Jeśli nie ma trafień, wyszukiwanie automatycznie rozszerza się na strony z tej samej domeny.

W przypadku danych początkowych URL usługa nie używa zawartości hiperlinków do generowania propozycji słów kluczowych.
W przypadku danych początkowych słów kluczowych i danych początkowych URL użyj KeywordAndUrlSeed (wymaga od 1 do 20 słów kluczowych oraz adresu URL).

Użycie KeywordAndUrlSeed może spowodować większą liczbę propozycji słów kluczowych w porównaniu z samym UrlSeed.
W przypadku całej witryny użyj SiteSeed. W przypadku nazwy domeny najwyższego poziomu, np. www.example.com, dane początkowe witryny generują do 250 tys. propozycji słów kluczowych na podstawie informacji dostępnych publicznie.

Aby zawęzić kierowanie, możesz skonfigurować language, lokalizację (maksymalnie 10 geo_target_constants), keyword_plan_network, include_adult_keywords, keyword_annotation (Sprecyzuj słowa kluczowe) i historical_metrics_options.

Odpowiedź obsługuje paginację (maksymalnie 10 tys. wyników na stronie). Zawsze sprawdzaj next_page_token, aby określić, czy dostępne są dodatkowe strony, ponieważ strona może zwracać mniej niż page_size wyników przed ostatnią stroną. Każda GenerateKeywordIdeaResult zwraca kanoniczny text (z close_variants), historyczne keyword_idea_metrics do filtrowania przed wygenerowaniem danych prognozowania metryk oraz opcjonalne keyword_annotations.

Informacje o polach żądania i odpowiedzi

Wywołaj KeywordPlanIdeaService.GenerateKeywordIdeas w tym punkcie końcowym:

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

W tabeli poniżej znajdziesz podsumowanie pól i ograniczeń dotyczących GenerateKeywordIdeasRequest:

Pole żądania	Wymaganie	Format i ograniczenia
`customer_id`	Wymagane	10-cyfrowy identyfikator klienta (`string`) bez łączników.
`seed` (`oneof`)	Wymagane	Określ jedną z tych opcji: • `keyword_seed`: `keywords[]` (od 1 do 20 ciągów znaków). • `url_seed`: `url` (konkretny adres URL strony). • `keyword_and_url_seed`: `url` oraz od 1 do 20 `keywords[]`. • `site_seed`: `site` (nazwa domeny, np. `www.example.com`,zwracająca do 250 tys. propozycji).
`language`	Opcjonalny	Nazwa zasobu kryterium języka (`languageConstants/{criterion_id}`, np. `languageConstants/1000` w przypadku języka angielskiego). Zobacz stałe języki. Jeśli pominiesz to pole, zostaną uwzględnione słowa kluczowe we wszystkich językach.
`geo_target_constants[]`	Opcjonalny	Maksymalnie 10 nazw zasobów lokalizacji (`geoTargetConstants/{criterion_id}`, np. `geoTargetConstants/2840` w przypadku Stanów Zjednoczonych). Zobacz docelowe regiony geograficzne. Pusta lista kieruje reklamy na wszystkie obszary geograficzne.
`keyword_plan_network`	Opcjonalny	`KeywordPlanNetwork` (`GOOGLE_SEARCH` lub `GOOGLE_SEARCH_AND_PARTNERS`). Domyślna wartość to `GOOGLE_SEARCH_AND_PARTNERS`.
`include_adult_keywords`	Opcjonalny	`bool` określający, czy mają być zwracane słowa kluczowe dla dorosłych. Domyślna wartość to `false`.
`keyword_annotation[]`	Opcjonalny	Lista wartości `KeywordPlanKeywordAnnotation` (np. `KEYWORD_CONCEPT`), które mają wypełniać `keyword_annotations` w każdym wyniku.
`aggregate_metrics`	Opcjonalny	`KeywordPlanAggregateMetrics` z `aggregate_metric_types` ustawionym na `DEVICE`, aby zwracać liczbę wyszukiwań podzieloną według urządzenia w `aggregate_metric_results`.
`historical_metrics_options`	Opcjonalny	`HistoricalMetricsOptions` określający opcjonalny `year_month_range` (dostępny za ostatnie 4 lata; domyślnie za ostatnie 12 miesięcy) i `include_average_cpc`.
`page_size` i `page_token`	Opcjonalny	Maksymalna liczba wyników na stronie (`int32`, maksymalnie `10,000`) i token kontynuacji z `next_page_token`. We wszystkich żądaniach podzielonych na strony zachowaj identyczne wszystkie inne pola żądania.

Komunikat GenerateKeywordIdeaResponse zwraca te pola:

Pole odpowiedzi	Typ	Opis
`results[].text`	`string`	Kanoniczny tekst propozycji słowa kluczowego reprezentujący sugestię i jej połączone `close_variants[]`.
`results[].close_variants[]`	`string[]`	Zbliżone odmiany połączone w tym `GenerateKeywordIdeaResult`.
`results[].keyword_idea_metrics`	`KeywordPlanHistoricalMetrics`	Liczba wyszukiwań: `avg_monthly_searches` (średnia z 12 miesięcy) i `monthly_search_volumes[]` (`year`, `month`, `monthly_searches`). Konkurencja: `competition` (`LOW`, `MEDIUM`, `HIGH`) i `competition_index` (`0` do `100`). Stawki i CPC: `low_top_of_page_bid_micros` (20. percentyl), `high_top_of_page_bid_micros` (80. percentyl) i `average_cpc_micros` (wypełniane, gdy `include_average_cpc = true`).
`results[].keyword_annotations`	`KeywordAnnotations`	Wypełniane, gdy w `keyword_annotation` jest wymagane `KEYWORD_CONCEPT`; zawiera `concepts[]` (`name`, `concept_group.name` i `concept_group.type`).
`aggregate_metric_results`	`KeywordPlanAggregateMetricResults`	Wypełniane, gdy w `aggregate_metrics` jest wymagane `DEVICE`; zawiera `device_searches[]` (`MOBILE`, `TABLET`, `DESKTOP`).
`next_page_token` i `total_size`	`string`, `int64`	Token kontynuacji na następną stronę (pomijany na ostatniej stronie) i łączna liczba dostępnych propozycji słów kluczowych.

Przykładowy kod

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
endgenerate_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}"
  }
}
EOFgenerate_keyword_ideas.sh

Struktura żądania i odpowiedzi REST

Ten przykład wysyła żądanie POST do KeywordPlanIdeaService.GenerateKeywordIdeas za pomocą keywordAndUrlSeed, języka angielskiego (languageConstants/1000) i Stanów Zjednoczonych (geoTargetConstants/2840):

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

Odpowiedź informująca o powodzeniu zwraca GenerateKeywordIdeaResult wiersze w results[] wraz z historyczną liczbą wyszukiwań i zakresami stawek:

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

Mapowanie na interfejs

W tabeli poniżej znajdziesz mapowanie KeywordPlanIdeaService.GenerateKeywordIdeas parametrów na Planer słów kluczowych w interfejsie Google Ads:

Planer słów kluczowych w interfejsie	Interfejs Google Ads API
Wpisz słowa kluczowe i adresy URL	`GenerateKeywordIdeasRequest.keyword_and_url_seed` `GenerateKeywordIdeasRequest.keyword_seed` `GenerateKeywordIdeasRequest.url_seed` `GenerateKeywordIdeasRequest.site_seed`
Lokalizacje	`GenerateKeywordIdeasRequest.geo_target_constants`
Słowa kluczowe dla dorosłych	`GenerateKeywordIdeasRequest.include_adult_keywords`
Język	`GenerateKeywordIdeasRequest.language`
Sieci wyszukiwania	`GenerateKeywordIdeasRequest.keyword_plan_network`
Sprecyzuj słowa kluczowe	`GenerateKeywordIdeasRequest.keyword_annotation`
Zakres dat	`GenerateKeywordIdeasRequest.historical_metrics_options`
Wyniki: słowo kluczowe	`GenerateKeywordIdeaResult.text`
Wyniki: dane	`GenerateKeywordIdeaResult.keyword_idea_metrics`

Wstecz

Przegląd

Dalej

Generowanie tematów dla grup reklam