Google utilizza la tecnologia AI per tradurre i contenuti nella tua lingua preferita. Le traduzioni generate dall'AI potrebbero contenere errori.

Generare idee per le parole chiave

Utilizzando KeywordPlanIdeaService, puoi scoprire i suggerimenti per le parole chiave pertinenti alla tua campagna sulla rete di ricerca di Google o recuperare le metriche storiche per un elenco di parole chiave esistente.

Genera idee

Genera idee per le parole chiave per una campagna con KeywordPlanIdeaService.GenerateKeywordIdeas.

Puoi fornire parole chiave e URL di base per generare idee. Imposta i parametri di targeting, come località, lingua e impostazioni della rete, per restringere la ricerca. Il servizio restituisce statistiche storiche, come i dati sul volume di ricerca, per aiutarti a decidere se utilizzare le parole chiave nella tua campagna. Per gli utenti che conoscono la UI di Google Ads, questo servizio è simile a Strumento di pianificazione delle parole chiave.

Esistono diversi modi per creare parole chiave di base per generare idee per le parole chiave:

Per le parole o le frasi che descrivono ciò che pubblicizzi, utilizza KeywordSeed (richiede almeno 1 e fino a 20 parole chiave). Può trattarsi di un tipo generale di attività che stai prendendo di mira, ad esempio idraulici, o di un prodotto o servizio che offri, ad esempio pulizia di scarichi.
Per l'URL di una pagina web o di un intero sito web correlato alla tua attività, utilizza UrlSeed. La parola chiave di base URL prende di mira solo un URL specifico. Se non ci sono corrispondenze, la ricerca si espande automaticamente fino alle pagine dello stesso dominio.

Per le parole chiave di base URL, il servizio non utilizza i contenuti dei link ipertestuali per generare idee per le parole chiave.
Per le parole chiave di base e le parole chiave di base URL, utilizza KeywordAndUrlSeed (richiede da 1 a 20 parole chiave insieme a un URL).

L'utilizzo di KeywordAndUrlSeed può generare un volume maggiore di idee per le parole chiave rispetto al semplice UrlSeed.
Per un intero sito, utilizza SiteSeed. Dato un nome di dominio di primo livello, ad esempio www.example.com, la parola chiave di base sito genera fino a 250.000 idee per le parole chiave da informazioni disponibili pubblicamente.

Per restringere il targeting, puoi configurare language, la località (fino a 10 geo_target_constants), keyword_plan_network, include_adult_keywords, keyword_annotation (Perfeziona le parole chiave) e historical_metrics_options.

La risposta supporta la paginazione (fino a 10.000 risultati per pagina; controlla sempre next_page_token per determinare se sono disponibili altre pagine, poiché una pagina potrebbe restituire meno risultati di page_size prima della pagina finale). Ogni GenerateKeywordIdeaResult restituisce il text canonico (con close_variants), le keyword_idea_metrics storiche per il filtro prima di generare le metricazione di previsione e le keyword_annotations facoltative.

Riferimento ai campi di richiesta e risposta

Chiama KeywordPlanIdeaService.GenerateKeywordIdeas al seguente endpoint:

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

La tabella seguente riassume i campi e i vincoli di GenerateKeywordIdeasRequest:

Campo di richiesta	Requisito	Formato e vincoli
`customer_id`	Obbligatorio	ID cliente di 10 cifre (`string`) senza trattini.
`seed` (`oneof`)	Obbligatorio	Specifica una delle seguenti opzioni: • `keyword_seed`: `keywords[]` (da 1 a 20 stringhe). • `url_seed`: `url` (URL di una pagina specifica). • `keyword_and_url_seed`: `url` più da 1 a 20 `keywords[]`. • `site_seed`: `site` (nome di dominio come `www.example.com`, che restituisce fino a 250.000 idee).
`language`	Facoltativo	Nome risorsa del criterio lingua (`languageConstants/{criterion_id}`, ad esempio `languageConstants/1000` per l'inglese). Vedi Costanti lingua. Se omesso, vengono incluse le parole chiave in tutte le lingue.
`geo_target_constants[]`	Facoltativo	Fino a 10 nomi di risorse di località (`geoTargetConstants/{criterion_id}`, ad esempio `geoTargetConstants/2840` per gli Stati Uniti). Vedi Target geografici. Un elenco vuoto prende di mira tutte le aree geografiche.
`keyword_plan_network`	Facoltativo	`KeywordPlanNetwork` (`GOOGLE_SEARCH` o `GOOGLE_SEARCH_AND_PARTNERS`). Il valore predefinito è `GOOGLE_SEARCH_AND_PARTNERS`.
`include_adult_keywords`	Facoltativo	`bool` che controlla se vengono restituite le parole chiave per adulti. Il valore predefinito è `false`.
`keyword_annotation[]`	Facoltativo	Elenco di `KeywordPlanKeywordAnnotation` valori (ad esempio `KEYWORD_CONCEPT`) per popolare `keyword_annotations` in ogni risultato.
`aggregate_metrics`	Facoltativo	`KeywordPlanAggregateMetrics` con `aggregate_metric_types` impostato su `DEVICE` per restituire i conteggi delle ricerche segmentati per dispositivo in `aggregate_metric_results`.
`historical_metrics_options`	Facoltativo	`HistoricalMetricsOptions` che specifica un `year_month_range` facoltativo (disponibile per gli ultimi 4 anni; il valore predefinito è gli ultimi 12 mesi) e `include_average_cpc`.
`page_size` e `page_token`	Facoltativo	Numero massimo di risultati per pagina (`int32`, fino a `10,000`) e token di continuazione da `next_page_token`. Mantieni tutti gli altri campi di richiesta identici nelle richieste paginate.

Il messaggio GenerateKeywordIdeaResponse restituisce i seguenti campi:

Campo di risposta	Tipo	Descrizione
`results[].text`	`string`	Testo canonico dell'idea per la parola chiave che rappresenta il suggerimento e le relative `close_variants[]` combinate.
`results[].close_variants[]`	`string[]`	Varianti simili combinate in questo `GenerateKeywordIdeaResult`.
`results[].keyword_idea_metrics`	`KeywordPlanHistoricalMetrics`	Volume di ricerca: `avg_monthly_searches` (media di 12 mesi) e `monthly_search_volumes[]` (`year`, `month`, `monthly_searches`). Concorrenza: `competition` (`LOW`, `MEDIUM`, `HIGH`) e `competition_index` (`0` to `100`). Offerte e CPC: `low_top_of_page_bid_micros` (20° percentile), `high_top_of_page_bid_micros` (80° percentile) e `average_cpc_micros` (popolato quando `include_average_cpc = true`).
`results[].keyword_annotations`	`KeywordAnnotations`	Popolato quando `KEYWORD_CONCEPT` viene richiesto in `keyword_annotation`; contiene `concepts[]` (`name`, `concept_group.name` e `concept_group.type`).
`aggregate_metric_results`	`KeywordPlanAggregateMetricResults`	Popolato quando `DEVICE` viene richiesto in `aggregate_metrics`; contiene `device_searches[]` (`MOBILE`, `TABLET`, `DESKTOP`).
`next_page_token` e `total_size`	`string`, `int64`	Token di continuazione per la pagina successiva (omesso nell'ultima pagina) e conteggio totale delle idee per le parole chiave disponibili.

Codice di esempio

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

Struttura della richiesta e della risposta REST

L'esempio seguente invia una richiesta POST a KeywordPlanIdeaService.GenerateKeywordIdeas utilizzando keywordAndUrlSeed, l'inglese (languageConstants/1000) e gli Stati Uniti (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"
    ]
  }
}

Una risposta positiva restituisce GenerateKeywordIdeaResult righe in results[] insieme al volume di ricerca storico e agli intervalli di offerta:

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

Mappa alla UI

La tabella seguente mappa KeywordPlanIdeaService.GenerateKeywordIdeas parametri allo Strumento di pianificazione delle parole chiave nella UI di Google Ads:

Strumento di pianificazione delle parole chiave nella UI	API Google Ads
Inserisci parole chiave e URL	`GenerateKeywordIdeasRequest.keyword_and_url_seed` `GenerateKeywordIdeasRequest.keyword_seed` `GenerateKeywordIdeasRequest.url_seed` `GenerateKeywordIdeasRequest.site_seed`
Località	`GenerateKeywordIdeasRequest.geo_target_constants`
Parole chiave per adulti	`GenerateKeywordIdeasRequest.include_adult_keywords`
Lingua	`GenerateKeywordIdeasRequest.language`
Reti di ricerca	`GenerateKeywordIdeasRequest.keyword_plan_network`
Perfeziona le parole chiave	`GenerateKeywordIdeasRequest.keyword_annotation`
Intervallo di date	`GenerateKeywordIdeasRequest.historical_metrics_options`
Risultati: parola chiave	`GenerateKeywordIdeaResult.text`
Risultati: metriche	`GenerateKeywordIdeaResult.keyword_idea_metrics`

Indietro

Panoramica

Avanti

Generare temi per i gruppi di annunci