Google utilise la technologie IA pour traduire le contenu dans votre langue préférée. Les traductions générées par IA peuvent contenir des erreurs.

Générer des idées de mots clés

Avec KeywordPlanIdeaService, vous pouvez découvrir des suggestions de mots clés pertinents pour votre campagne sur le Réseau de Recherche Google ou récupérer des métriques historiques pour une liste de mots clés existante.

Générer des idées

Générez des idées de mots clés pour une campagne avec KeywordPlanIdeaService.GenerateKeywordIdeas.

Vous pouvez fournir des mots clés et des URL de base pour générer des idées. Définissez des paramètres de ciblage tels que les zones géographiques, la langue et les paramètres réseau pour affiner votre recherche. Le service renvoie des statistiques historiques, telles que des données sur le volume de recherche, pour vous aider à décider d'utiliser ou non les mots clés dans votre campagne. Pour les utilisateurs qui connaissent l'UI Google Ads, cela s'apparente à l'Outil de planification des mots clés.

Vous pouvez créer des bases de plusieurs manières pour générer des idées de mots clés :

Pour les mots ou expressions qui décrivent ce que vous annoncez, utilisez KeywordSeed (nécessite au moins 1 mot clé et jusqu'à 20 mots clés). Il peut s'agir d'un type d'entreprise général que vous ciblez, comme les plombiers, ou d'un produit ou service que vous proposez, comme le débouchage de canalisations.
Pour l'URL d'une page Web ou d'un site Web entier associé à votre entreprise, utilisez UrlSeed. La base d'URL ne cible qu'une URL spécifique. Si aucun résultat n'est trouvé, la recherche s'étend automatiquement aux pages du même domaine.

Pour les bases d'URL, le service n'utilise pas le contenu des liens hypertexte pour générer des idées de mots clés.
Pour les bases de mots clés et les bases d'URL, utilisez KeywordAndUrlSeed (nécessite entre 1 et 20 mots clés, ainsi qu'une URL).

L'utilisation de KeywordAndUrlSeed peut générer un plus grand volume d'idées de mots clés que UrlSeed seul, comme.
Pour un site entier, utilisez SiteSeed. Étant donné un nom de domaine de premier niveau, tel que www.example.com, la base de site génère jusqu'à 250 000 idées de mots clés à partir d'informations publiques.

Pour affiner votre ciblage, vous pouvez configurer language, l'emplacement (jusqu'à 10 geo_target_constants), keyword_plan_network, include_adult_keywords, keyword_annotation (Améliorer la pertinence des mots clés), et historical_metrics_options.

La réponse est compatible avec la pagination (jusqu'à 10 000 résultats par page). Vérifiez toujours next_page_token pour déterminer si des pages supplémentaires sont disponibles, car une page peut renvoyer moins de résultats que page_size résultats avant la dernière page. Chaque GenerateKeywordIdeaResult renvoie le text canonique (avec close_variants), les keyword_idea_metrics historiques pour le filtrage avant la génération des métriques de prévision et les keyword_annotations facultatives.

Référence des champs de requête et de réponse

Appelez KeywordPlanIdeaService.GenerateKeywordIdeas au point de terminaison suivant :

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

Le tableau suivant récapitule les champs et les contraintes de GenerateKeywordIdeasRequest :

Champ de la requête	Exigence	Format et contraintes
`customer_id`	Obligatoire	Numéro client à 10 chiffres (`string`) sans trait d'union.
`seed` (`oneof`)	Obligatoire	Spécifiez l'une des options suivantes : • `keyword_seed` : `keywords[]` (1 à 20 chaînes). • `url_seed`: `url` (URL de page spécifique). • `keyword_and_url_seed` : `url` plus 1 à 20 `keywords[]`. • `site_seed` : `site` (nom de domaine tel que `www.example.com`, renvoyant jusqu'à 250 000 idées).
`language`	Facultatif	Nom de ressource de critère de langue (`languageConstants/{criterion_id}`, par exemple, `languageConstants/1000` pour l'anglais). Consultez les constantes de langue. Si cette option est omise, les mots clés de toutes les langues sont inclus.
`geo_target_constants[]`	Facultatif	Jusqu'à 10 noms de ressources d'emplacement (`geoTargetConstants/{criterion_id}`, par exemple, `geoTargetConstants/2840` pour les États-Unis). Consultez les cibles géographiques. Une liste vide cible toutes les zones géographiques.
`keyword_plan_network`	Facultatif	`KeywordPlanNetwork` (`GOOGLE_SEARCH` ou `GOOGLE_SEARCH_AND_PARTNERS`). La valeur par défaut est `GOOGLE_SEARCH_AND_PARTNERS`.
`include_adult_keywords`	Facultatif	`bool` qui détermine si les mots clés pour adultes sont renvoyés. La valeur par défaut est `false`.
`keyword_annotation[]`	Facultatif	Liste des `KeywordPlanKeywordAnnotation` valeurs (telles que `KEYWORD_CONCEPT`) à renseigner dans `keyword_annotations` pour chaque résultat.
`aggregate_metrics`	Facultatif	`KeywordPlanAggregateMetrics` avec `aggregate_metric_types` défini sur `DEVICE` pour renvoyer les nombres de recherches segmentés par appareil dans `aggregate_metric_results`.
`historical_metrics_options`	Facultatif	`HistoricalMetricsOptions` spécifiant une `year_month_range` facultative (disponible pour les quatre dernières années ; la valeur par défaut est les 12 derniers mois) et `include_average_cpc`.
`page_size` et `page_token`	Facultatif	Nombre maximal de résultats par page (`int32`, jusqu'à `10,000`) et jeton de continuation de `next_page_token`. Conservez tous les autres champs de requête identiques dans les requêtes paginées.

Le GenerateKeywordIdeaResponse message renvoie les champs suivants :

Champ de réponse	Type	Description
`results[].text`	`string`	Texte canonique de l'idée de mot clé représentant la suggestion et ses `close_variants[]` combinées.
`results[].close_variants[]`	`string[]`	Variantes proches combinées dans ce `GenerateKeywordIdeaResult`.
`results[].keyword_idea_metrics`	`KeywordPlanHistoricalMetrics`	Volume de recherche `avg_monthly_searches` (moyenne sur 12 mois) et `monthly_search_volumes[]` (`year`, `month`, `monthly_searches`). Concurrence `competition` (`LOW`, `MEDIUM`, `HIGH`) et `competition_index` (`0` à `100`). Enchères et CPC `low_top_of_page_bid_micros` (20e centile), `high_top_of_page_bid_micros` (80e centile) et `average_cpc_micros` (renseigné lorsque `include_average_cpc = true`).
`results[].keyword_annotations`	`KeywordAnnotations`	Renseigné lorsque `KEYWORD_CONCEPT` est demandé dans `keyword_annotation` ; contient `concepts[]` (`name`, `concept_group.name`, et `concept_group.type`).
`aggregate_metric_results`	`KeywordPlanAggregateMetricResults`	Renseigné lorsque `DEVICE` est demandé dans `aggregate_metrics` ; contient `device_searches[]` (`MOBILE`, `TABLET`, `DESKTOP`).
`next_page_token` et `total_size`	`string`, `int64`	Jeton de continuation pour la page suivante (omis sur la dernière page) et nombre total d'idées de mots clés disponibles.

Exemple de code

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

Structure des requêtes et des réponses REST

L'exemple suivant envoie une requête POST à KeywordPlanIdeaService.GenerateKeywordIdeas à l'aide de keywordAndUrlSeed, de l'anglais (languageConstants/1000) et des États-Unis (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"
    ]
  }
}

Une réponse réussie renvoie GenerateKeywordIdeaResult lignes dans results[], ainsi que l'historique du volume de recherche et les plages d'enchères :

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

Mapper sur l'UI

Le tableau suivant mappe KeywordPlanIdeaService.GenerateKeywordIdeas paramètres sur l'Outil de planification des mots clés dans l'UI Google Ads :

Outil de planification des mots clés dans l'UI	API Google Ads
Saisir des mots clés et des URL	`GenerateKeywordIdeasRequest.keyword_and_url_seed` `GenerateKeywordIdeasRequest.keyword_seed` `GenerateKeywordIdeasRequest.url_seed` `GenerateKeywordIdeasRequest.site_seed`
Zones	`GenerateKeywordIdeasRequest.geo_target_constants`
Mots clés pour adultes	`GenerateKeywordIdeasRequest.include_adult_keywords`
Langue	`GenerateKeywordIdeasRequest.language`
Réseaux de recherche	`GenerateKeywordIdeasRequest.keyword_plan_network`
Améliorer la pertinence des mots clés	`GenerateKeywordIdeasRequest.keyword_annotation`
Période	`GenerateKeywordIdeasRequest.historical_metrics_options`
Résultats : mot clé	`GenerateKeywordIdeaResult.text`
Résultats : métriques	`GenerateKeywordIdeaResult.keyword_idea_metrics`

Aperçu

Générer des thèmes de groupes d'annonces

Générer des idées de mots clés Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.