Anahtar kelime fikirleri oluşturun

KeywordPlanIdeaService ile Google Arama kampanyanızla alakalı anahtar kelime önerileri bulabilir veya mevcut bir anahtar kelime listesi için geçmiş metrikleri alabilirsiniz.

Fikir üret

KeywordPlanIdeaService.GenerateKeywordIdeas ile bir kampanya için anahtar kelime fikirleri oluşturun.

Fikir üretmek için anahtar kelime ve URL başlangıçları sağlayabilirsiniz. Aramanızı daraltmak için konum, dil ve ağ ayarları gibi hedefleme parametrelerini belirleyin. Hizmet, kampanyanızda anahtar kelimeleri kullanıp kullanmayacağınıza karar vermenize yardımcı olmak için arama hacmi verileri gibi geçmiş istatistikleri döndürür. Google Ads kullanıcı arayüzüne aşina olan kullanıcılar için bu, Anahtar Kelime Planlayıcı'ya benzer.

Anahtar kelime fikirleri oluşturmak için birkaç farklı şekilde başlangıç noktası belirleyebilirsiniz:

  • Reklamını yaptığınız şeyi açıklayan kelimeler veya kelime öbekleri için KeywordSeed kullanın (en az 1, en fazla 20 anahtar kelime gerekir). Bu, hedeflediğiniz genel bir işletme türü (ör. tesisatçılar) veya sunduğunuz bir ürün ya da hizmet (ör. gider temizleme) olabilir.

  • İşletmenizle ilgili bir web sayfasının veya web sitesinin tamamının URL'si için UrlSeed kullanın. URL başlangıcı yalnızca belirli bir URL'yi hedefler. Hiç isabet yoksa arama otomatik olarak aynı alandaki sayfalara kadar genişletilir.

    URL başlangıçları için hizmet, anahtar kelime fikirleri oluşturmak üzere köprülerin içeriğini kullanmaz.

  • Hem anahtar kelime kaynakları hem de URL kaynakları için KeywordAndUrlSeed kullanın (bir URL ile birlikte 1 ila 20 anahtar kelime gerekir).

    KeywordAndUrlSeed kullanıldığında, yalnızca UrlSeed kullanılmasına kıyasla daha fazla anahtar kelime fikri sağlanabilir.

  • Bir sitenin tamamı için SiteSeed kullanın. www.example.com gibi bir üst düzey alan adı verildiğinde site kaynağı, herkese açık bilgilerden 250.000'e kadar anahtar kelime fikri oluşturur.

Hedeflemenizi daraltmak için language, konum (en fazla 10 geo_target_constants), keyword_plan_network, include_adult_keywords, keyword_annotation (anahtar kelimeleri daraltın) ve historical_metrics_options ayarlarını yapılandırabilirsiniz.

Yanıt,sayfalandırmayı destekler (sayfa başına en fazla 10.000 sonuç; ek sayfaların olup olmadığını belirlemek için her zaman next_page_token değerini kontrol edin. Bir sayfa, son sayfadan önce page_size sonuçtan daha az sonuç döndürebilir). Her GenerateKeywordIdeaResult, standart text (close_variants ile), tahmin metrikleri oluşturmadan önce filtreleme için geçmiş keyword_idea_metrics ve isteğe bağlı keyword_annotations döndürür.

İstek ve yanıt alanı referansı

Aşağıdaki uç noktada KeywordPlanIdeaService.GenerateKeywordIdeas numaralı telefonu arayın:

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

Aşağıdaki tabloda, GenerateKeywordIdeasRequest ile ilgili alanlar ve kısıtlamalar özetlenmiştir:

İstek alanı Gereksinim Biçim ve kısıtlamalar
customer_id Zorunlu Kısa çizgi içermeyen 10 haneli müşteri kimliği (string).
seed (oneof) Zorunlu Aşağıdakilerden birini belirtin:
• keyword_seed: keywords[] (1-20 dize).
• url_seed: url (belirli bir sayfanın URL'si).
• keyword_and_url_seed: url artı 1 ila 20 keywords[].
• site_seed: site (www.example.com gibi alan adı, 250.000'e kadar fikir döndürür).
language İsteğe bağlı Dil ölçütü kaynak adı (languageConstants/{criterion_id}, örneğin, İngilizce için languageConstants/1000). Dil Sabitleri'ne bakın. Atlanırsa tüm dillerdeki anahtar kelimeler dahil edilir.
geo_target_constants[] İsteğe bağlı En fazla 10 konum kaynağı adı (geoTargetConstants/{criterion_id}, örneğin ABD için geoTargetConstants/2840). Coğrafi hedefler konusunu inceleyin. Boş bir liste tüm coğrafyaları hedefler.
keyword_plan_network İsteğe bağlı KeywordPlanNetwork (GOOGLE_SEARCH veya GOOGLE_SEARCH_AND_PARTNERS). Varsayılan olarak GOOGLE_SEARCH_AND_PARTNERS değerine ayarlanır.
include_adult_keywords İsteğe bağlı bool, yetişkinlere uygun anahtar kelimelerin döndürülüp döndürülmeyeceğini kontrol eder. Varsayılan değer false'dir.
keyword_annotation[] İsteğe bağlı Her sonuçta keyword_annotations öğesini doldurmak için KeywordPlanKeywordAnnotation değerlerinin (ör. KEYWORD_CONCEPT) listesi.
aggregate_metrics İsteğe bağlı KeywordPlanAggregateMetrics ile aggregate_metric_types, DEVICE olarak ayarlanırsa aggregate_metric_results içinde cihaza göre segmentlere ayrılmış arama sayıları döndürülür.
historical_metrics_options İsteğe bağlı İsteğe bağlı bir year_month_range (son 4 yıl için kullanılabilir; varsayılan olarak son 12 ay kullanılır) ve include_average_cpc belirten HistoricalMetricsOptions.
page_size ve page_token İsteğe bağlı Sayfa başına maksimum sonuç (int32, en fazla 10,000) ve next_page_token'den devam jetonu. Diğer tüm istek alanlarını sayfalandırılmış isteklerde aynı tutun.

GenerateKeywordIdeaResponse mesajı aşağıdaki alanları döndürür:

Yanıt alanı Tür Açıklama
results[].text string Öneriyi ve birleştirilmiş close_variants[] değerini temsil eden kanonik anahtar kelime fikri metni.
results[].close_variants[] string[] Yakın varyasyonlar bu GenerateKeywordIdeaResult ile birleştirildi.
results[].keyword_idea_metrics KeywordPlanHistoricalMetrics Arama hacmi: avg_monthly_searches (12 aylık ortalama) ve monthly_search_volumes[] (year, month, monthly_searches).
Rekabet: competition (LOW, MEDIUM, HIGH) ve competition_index (0 - 100).
Teklifler ve TBM: low_top_of_page_bid_micros (20. yüzdelik dilim), high_top_of_page_bid_micros (80. yüzdelik dilim) ve average_cpc_micros (include_average_cpc = true olduğunda doldurulur).
results[].keyword_annotations KeywordAnnotations keyword_annotation içinde KEYWORD_CONCEPT istendiğinde doldurulur; concepts[] (name, concept_group.name ve concept_group.type) içerir.
aggregate_metric_results KeywordPlanAggregateMetricResults aggregate_metrics içinde DEVICE istendiğinde doldurulur; device_searches[] (MOBILE, TABLET, DESKTOP) içerir.
next_page_token ve total_size string, int64 Sonraki sayfa için devamlılık jetonu (son sayfada atlanır) ve kullanılabilir anahtar kelime fikirlerinin toplam sayısı.

Kod örneği

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

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;
    }
}

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
        );
    }
}

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"
        )

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

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;
}

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

REST isteği ve yanıt yapısı

Aşağıdaki örnekte, keywordAndUrlSeed, İngilizce (languageConstants/1000) ve ABD (geoTargetConstants/2840) kullanılarak KeywordPlanIdeaService.GenerateKeywordIdeas adresine bir POST isteği gönderilmektedir:

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

Başarılı bir yanıt, geçmiş arama hacmi ve teklif aralıklarıyla birlikte results[] içinde GenerateKeywordIdeaResult satır döndürür:

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

Kullanıcı arayüzüyle eşleme

Aşağıdaki tabloda, KeywordPlanIdeaService.GenerateKeywordIdeas parametreleri Google Ads kullanıcı arayüzündeki Anahtar Kelime Planlayıcı ile eşlenmektedir:

Kullanıcı arayüzündeki Anahtar Kelime Planlayıcı Google Ads API
Anahtar kelimeleri ve URL'leri girme
Konumlar GenerateKeywordIdeasRequest.geo_target_constants
Yetişkinlere Uygun Anahtar Kelimeler GenerateKeywordIdeasRequest.include_adult_keywords
Dil GenerateKeywordIdeasRequest.language
Arama Ağları GenerateKeywordIdeasRequest.keyword_plan_network
Anahtar Kelimeleri Hassaslaştırın GenerateKeywordIdeasRequest.keyword_annotation
Tarih Aralığı GenerateKeywordIdeasRequest.historical_metrics_options
Sonuçlar: Anahtar kelime GenerateKeywordIdeaResult.text
Sonuçlar: Metrikler GenerateKeywordIdeaResult.keyword_idea_metrics
Önceki
Genel bakış
Sonraki
Reklam grubu temaları oluşturma