Tạo chỉ số dự đoán

Chỉ số dự báo cung cấp các chỉ số hiệu suất ước tính (KeywordForecastMetrics) cho các chiến dịch được đề xuất hoặc hiện có. Các chỉ số dự báo có sẵn phụ thuộc vào phiên bản API và chiến lược đặt giá thầu mà bạn hỗ trợ:

• v24 trở lên:
  • clicks (lượt nhấp): Chỉ được trả về khi sử dụng ManualCpcBiddingStrategy hoặc MaximizeClicksBiddingStrategy.
  • cost_micros (chi phí): Tổng chi phí dự kiến tính theo đơn vị micro.
  • average_cpc_micros (chi phí trung bình cho mỗi lượt nhấp): Chỉ được trả về khi sử dụng ManualCpcBiddingStrategy hoặc MaximizeClicksBiddingStrategy và clicks > 0.
  • conversions (lượt chuyển đổi): Chỉ được trả về khi sử dụng MaximizeConversionsBiddingStrategy.
  • average_cpa_micros (chi phí trung bình cho mỗi lượt thu nạp khách hàng): Chỉ được trả về khi sử dụng MaximizeConversionsBiddingStrategy (được tính là cost_micros / conversions).
• Phiên bản 23 trở xuống:
  • KeywordForecastMetrics cũng trả về impressions (số lượt hiển thị), click_through_rate (tỷ lệ nhấp) và conversion_rate (tỷ lệ chuyển đổi), ngoài clicks, cost_micros, average_cpc_micros, conversions và average_cpa_micros (được trả về trên tất cả chiến lược đặt giá thầu).

Thử nghiệm các cấu hình chiến dịch khác nhau để tối ưu hoá từng chỉ số này. Thông tin dự đoán sử dụng dữ liệu như điểm chất lượng trước đây và tỷ lệ nhấp để mô phỏng hiệu suất dự kiến.

Chỉ số dự đoán thường được dùng sau khi bạn khám phá các từ khoá đề xuất bằng ý tưởng từ khoá hoặc lọc danh sách từ khoá hiện có bằng chỉ số trong quá khứ và bạn có thể nhóm các từ khoá đó bằng chủ đề nhóm quảng cáo. Mặc dù các chỉ số trong quá khứ thu hẹp một nhóm lớn các từ khoá đề xuất dựa trên lượng tìm kiếm trong quá khứ, nhưng các chỉ số dự báo mô phỏng hiệu suất trong tương lai để bạn có thể tối ưu hoá giá thầu, ngân sách hằng ngày và tiêu chí nhắm mục tiêu trước khi cập nhật một chiến dịch đang phân phát.

Tạo chỉ số

Để tạo các chỉ số dự báo, hãy hoàn tất các bước sau:

1. Tạo một đối tượng CampaignToForecast đại diện cho cấu hình chiến dịch, các đối tượng ForecastAdGroup và chiến lược đặt giá thầu mà bạn muốn đánh giá.
2. Gọi KeywordPlanIdeaService.GenerateKeywordForecastMetrics bằng CampaignToForecast đó và forecast_period không bắt buộc (ngày bắt đầu phải trong tương lai và ngày kết thúc trong vòng một năm kể từ hôm nay; nếu bạn bỏ qua, thì ngày bắt đầu sẽ mặc định là Chủ Nhật tiếp theo cho đến Thứ Bảy tiếp theo theo múi giờ của tài khoản khách hàng).
3. Đọc KeywordForecastMetrics ở cấp chiến dịch từ trường campaign_forecast_metrics của GenerateKeywordForecastMetricsResponse.

Tạo chiến dịch để dự báo

Sau đây là một số mẹo khi tạo chiến dịch để dự đoán:

• Tạo nhóm quảng cáo dựa trên các chủ đề như mức độ liên quan của mẫu quảng cáo, danh mục sản phẩm hoặc chi phí mỗi lượt nhấp (hoặc sử dụng các đề xuất của GenerateAdGroupThemes).
• Trong phiên bản 23 trở xuống, hãy thêm các từ khoá phủ định phổ biến bằng cách sử dụng CampaignToForecast.negative_keywords hoặc ForecastAdGroup.negative_keywords (ví dụ: nếu bạn không tham gia tuyển dụng, hãy loại trừ từ khoá 'jobs'). Trong phiên bản 24 trở lên, negative_keywords sẽ bị xoá.
• Sử dụng một tài khoản có liên quan đến chiến dịch. Đừng dự báo từ một tài khoản không liên quan. Google đưa điểm chất lượng và nội dung mẫu quảng cáo vào thông tin dự báo.
• Nếu một chiến dịch không liên quan đến phần còn lại của tài khoản, hãy sử dụng một tài khoản mới hoàn toàn để dự đoán.
• Lặp lại quy trình dự báo với các khoảng thời gian khác nhau để có được bức tranh toàn cảnh.

Sự khác biệt về phiên bản

Trong phiên bản 24 trở lên, CampaignToForecast, ForecastAdGroup và KeywordForecastMetrics sử dụng giản đồ đơn giản hơn so với phiên bản 23 trở xuống, như trong bảng sau:

Tính năng	v24 trở lên	v23 trở xuống
Từ khoá của nhóm quảng cáo	ForecastAdGroup.keywords (repeated KeywordInfo)	ForecastAdGroup.biddable_keywords (repeated BiddableKeyword)
Nhắm mục tiêu theo vị trí	CampaignToForecast.geo_target_constants (repeated string tên tài nguyên)	CampaignToForecast.geo_modifiers (repeated CriterionBidModifier có hệ số nhân giá thầu không bắt buộc)
Nhắm mục tiêu trên Mạng Tìm kiếm	Không được chỉ định trên CampaignToForecast (mặc định là Google Tìm kiếm)	Bắt buộc CampaignToForecast.keyword_plan_network
Từ khoá phủ định	Không được hỗ trợ trên CampaignToForecast hoặc ForecastAdGroup	Được hỗ trợ bằng cách sử dụng CampaignToForecast.negative_keywords và ForecastAdGroup.negative_keywords
Ghi đè giá thầu CPC của nhóm quảng cáo và từ khoá	Chỉ được định cấu hình ở cấp chiến lược đặt giá thầu của chiến dịch (ManualCpcBiddingStrategy.max_cpc_bid_micros hoặc MaximizeClicksBiddingStrategy.max_cpc_bid_ceiling_micros)	Bạn cũng có thể ghi đè cho mỗi nhóm quảng cáo (ForecastAdGroup.max_cpc_bid_micros) hoặc mỗi từ khoá (BiddableKeyword.max_cpc_bid_micros)
Tỷ lệ chuyển đổi dự kiến tuỳ chỉnh	Không được hỗ trợ trên CampaignToForecast	Không bắt buộc CampaignToForecast.conversion_rate
Chỉ số dự báo được trả về	clicks và average_cpc_micros (chỉ có CPC thủ công hoặc Tối đa hoá số lượt nhấp), cost_micros, conversions và average_cpa_micros (chỉ có chiến lược Tối đa hoá lượt chuyển đổi)	Trả về clicks, cost_micros, average_cpc_micros, conversions và average_cpa_micros trên tất cả chiến lược đặt giá thầu, cộng với impressions, click_through_rate và conversion_rate

Ví dụ về mã

Ví dụ về mã tiếp theo sẽ gửi yêu cầu đến KeywordPlanIdeaService.GenerateKeywordForecastMetrics. Tập lệnh này tạo một CampaignToForecast cùng dòng với các nhóm quảng cáo và từ khoá, sau đó hiển thị campaign_forecast_metrics được trả về.

Java

private void runExample(GoogleAdsClient googleAdsClient, Long customerId) {
  CampaignToForecast campaignToForecast = createCampaignToForecast(googleAdsClient);
  GenerateKeywordForecastMetricsRequest request =
      GenerateKeywordForecastMetricsRequest.newBuilder()
          .setCustomerId(String.valueOf(customerId))
          .setCampaign(campaignToForecast)
          .setForecastPeriod(
              DateRange.newBuilder()
                  // Sets the forecast start date to tomorrow.
                  .setStartDate(new DateTime().plusDays(1).toString("yyyy-MM-dd"))
                  // Sets the forecast end date to 30 days from today.
                  .setEndDate(new DateTime().plusDays(30).toString("yyyy-MM-dd")))
          .build();
  try (KeywordPlanIdeaServiceClient keywordPlanIdeaServiceClient =
      googleAdsClient.getLatestVersion().createKeywordPlanIdeaServiceClient()) {
    GenerateKeywordForecastMetricsResponse response =
        keywordPlanIdeaServiceClient.generateKeywordForecastMetrics(request);
    KeywordForecastMetrics metrics = response.getCampaignForecastMetrics();
    System.out.printf(
        "Estimated daily clicks: %s%n", metrics.hasClicks() ? metrics.getClicks() : null);
    System.out.printf(
        "Estimated average CPC (micros): %s%n",
        metrics.hasAverageCpcMicros() ? metrics.getAverageCpcMicros() : null);
  }
}

/**
 * Creates the campaign to forecast. A campaign to forecast lets you try out various
 * configurations and keywords to find the best optimization for your future campaigns. Once
 * you've found the best campaign configuration, create a serving campaign in your Google Ads
 * account with similar values and keywords. For more details, see:
 *
 * <p>https://support.google.com/google-ads/answer/3022575
 */
private CampaignToForecast createCampaignToForecast(GoogleAdsClient googleAdsClient) {
  CampaignToForecast.Builder campaignToForecastBuilder =
      CampaignToForecast.newBuilder()
          .setBiddingStrategy(
              CampaignBiddingStrategy.newBuilder()
                  .setManualCpcBiddingStrategy(
                      ManualCpcBiddingStrategy.newBuilder().setMaxCpcBidMicros(1_000_000L)));

  // See https://developers.google.com/google-ads/api/reference/data/geotargets for the list of
  // geo target IDs. Geo target constant 2840 is for USA.
  campaignToForecastBuilder.addGeoTargetConstants(ResourceNames.geoTargetConstant(2840));

  // See https://developers.google.com/google-ads/api/reference/data/codes-formats#languages for
  // the list of language criteria IDs. Language constant 1000 is for English.
  campaignToForecastBuilder.addLanguageConstants(ResourceNames.languageConstant(1000));

  // Create forecast ad group based on themes such as creative relevance, product category, or
  // cost per click.
  ForecastAdGroup.Builder forecastAdGroupBuilder = ForecastAdGroup.newBuilder();
  forecastAdGroupBuilder.addKeywords(
      KeywordInfo.newBuilder()
          .setText("mars cruise")
          .setMatchType(KeywordMatchType.BROAD));

  forecastAdGroupBuilder.addKeywords(
      KeywordInfo.newBuilder()
          .setText("cheap cruise")
          .setMatchType(KeywordMatchType.PHRASE));

  forecastAdGroupBuilder.addKeywords(
      KeywordInfo.newBuilder()
          .setText("jupiter cruise")
          .setMatchType(KeywordMatchType.BROAD));

  campaignToForecastBuilder.addAdGroups(forecastAdGroupBuilder.build());
  return campaignToForecastBuilder.build();
}
GenerateForecastMetrics.java
      

C#

public void Run(GoogleAdsClient client, long customerId)
{
    CampaignToForecast campaignToForecast = CreateCampaignToForecast();

    KeywordPlanIdeaServiceClient keywordPlanIdeaService =
            client.GetService(Services.V26.KeywordPlanIdeaService);

    GenerateKeywordForecastMetricsRequest request = new GenerateKeywordForecastMetricsRequest()
    {
        CustomerId = customerId.ToString(),
        Campaign = campaignToForecast,
        ForecastPeriod = new DateRange()
        {
            // Set the forecast start date to tomorrow.
            StartDate = DateTime.Now.AddDays(1).ToString("yyyy-MM-dd"),
            // Set the forecast end date to 30 days from today.
            EndDate = DateTime.Now.AddDays(30).ToString("yyyy-MM-dd"),
        }
    };

    try
    {
        GenerateKeywordForecastMetricsResponse response =
            keywordPlanIdeaService.GenerateKeywordForecastMetrics(request);

        KeywordForecastMetrics metrics = response.CampaignForecastMetrics;

        Console.WriteLine($"Estimated daily clicks: {metrics.Clicks}.");            
        Console.WriteLine($"Estimated average cpc (micros): {metrics.AverageCpcMicros}.");
    }
    catch (GoogleAdsException e)
    {
        Console.WriteLine("Failure:");
        Console.WriteLine($"Message: {e.Message}");
        Console.WriteLine($"Failure: {e.Failure}");
        Console.WriteLine($"Request ID: {e.RequestId}");
        throw;
    }
}

/// <summary>
/// Creates the campaign to forecast. A campaign to forecast lets you try out
/// various configuration and keywords to find the best optimization for your
/// future campaigns. Once you've found the best campaign configuration,
/// create a serving campaign in your Google Ads account with similar values
/// and keywords. For more details, see:
/// https://support.google.com/google-ads/answer/3022575
/// </summary>
private CampaignToForecast CreateCampaignToForecast()
{
    CampaignToForecast campaignToForecast = new CampaignToForecast()
    {            
        BiddingStrategy = new CampaignToForecast.Types.CampaignBiddingStrategy()
        {
            ManualCpcBiddingStrategy = new ManualCpcBiddingStrategy()
            {
                MaxCpcBidMicros = 1_000_000
            }
        }
    };

    // See https://developers.google.com/google-ads/api/reference/data/geotargets
    // for the list of geo target IDs.
    // Geo target constant 2840 is for USA.
    campaignToForecast.GeoTargetConstants.Add(
        ResourceNames.GeoTargetConstant(2840)
    );

    // See https://developers.google.com/google-ads/api/reference/data/codes-formats#languages
    // for the list of language criteria IDs.
    // Language constant 1000 is for English.
    campaignToForecast.LanguageConstants.Add(ResourceNames.LanguageConstant(1000));

    // Create forecast ad group based on themes such as creative relevance, product category,
    // or cost per click.
    ForecastAdGroup forecastAdGroup = new ForecastAdGroup();

    KeywordInfo keyword1 = new KeywordInfo()
    {
        Text = "mars cruise",
        MatchType = KeywordMatchType.Broad
    };
    forecastAdGroup.Keywords.Add(keyword1);

    KeywordInfo keyword2 = new KeywordInfo()
    {
        Text = "cheap cruise",
        MatchType = KeywordMatchType.Phrase
    };
    forecastAdGroup.Keywords.Add(keyword2);

    KeywordInfo keyword3 = new KeywordInfo()
    {
        Text = "jupiter cruise",
        MatchType = KeywordMatchType.Exact
    };
    forecastAdGroup.Keywords.Add(keyword3);

    campaignToForecast.AdGroups.Add(forecastAdGroup);

    return campaignToForecast;
}
GenerateForecastMetrics.cs
      

PHP

public static function runExample(
    GoogleAdsClient $googleAdsClient,
    int $customerId
): void {
    $campaignToForecast = self::createCampaignToForecast();
    $keywordPlanIdeaServiceClient = $googleAdsClient->getKeywordPlanIdeaServiceClient();
    // Generates keyword forecast metrics based on the specified parameters.
    $response = $keywordPlanIdeaServiceClient->generateKeywordForecastMetrics(
        new GenerateKeywordForecastMetricsRequest([
            'customer_id' => $customerId,
            'campaign' => $campaignToForecast,
            'forecast_period' => new DateRange([
                // Sets the forecast start date to tomorrow.
                'start_date' => date('Ymd', strtotime('+1 day')),
                // Sets the forecast end date to 30 days from today.
                'end_date' => date('Ymd', strtotime('+30 days'))
            ])
        ])
    );

    $metrics = $response->getCampaignForecastMetrics();
    printf(
        "Estimated daily clicks: %s%s",
        $metrics->hasClicks() ? sprintf("%.2f", $metrics->getClicks()) : "'none'",
        PHP_EOL
    );
    printf(
        "Estimated daily impressions: %s%s",
        $metrics->hasImpressions() ? sprintf("%.2f", $metrics->getImpressions()) : "'none'",
        PHP_EOL
    );
    printf(
        "Estimated average CPC (micros): %s%s",
        $metrics->hasAverageCpcMicros()
            ? sprintf("%d", $metrics->getAverageCpcMicros()) : "'none'",
        PHP_EOL
    );
}

/**
 * Creates the campaign to forecast. A campaign to forecast lets you try out various
 * configurations and keywords to find the best optimization for your future campaigns. Once
 * you've found the best campaign configuration, create a serving campaign in your Google Ads
 * account with similar values and keywords. For more details, see:
 *
 * https://support.google.com/google-ads/answer/3022575
 *
 * @return CampaignToForecast the created campaign to forecast
 */
private static function createCampaignToForecast(): CampaignToForecast
{
    // Creates a campaign to forecast.
    $campaignToForecast = new CampaignToForecast([
        'keyword_plan_network' => KeywordPlanNetwork::GOOGLE_SEARCH,
        'bidding_strategy' => new CampaignBiddingStrategy([
            'manual_cpc_bidding_strategy' => new ManualCpcBiddingStrategy([
                'max_cpc_bid_micros' => 1_000_000
            ])
        ]),
        // See https://developers.google.com/google-ads/api/reference/data/geotargets for the
        // list of geo target IDs.
        'geo_modifiers' => [
            new CriterionBidModifier([
                // Geo target constant 2840 is for USA.
                'geo_target_constant' => ResourceNames::forGeoTargetConstant(2840)
            ])
        ],
        // See
        // https://developers.google.com/google-ads/api/reference/data/codes-formats#languages
        // for the list of language criteria IDs. Language constant 1000 is for English.
        'language_constants' => [ResourceNames::forLanguageConstant(1000)],
    ]);

    // Creates forecast ad group based on themes such as creative relevance, product category,
    // or cost per click.
    $forecastAdGroup = new ForecastAdGroup([
        'biddable_keywords' => [
            new BiddableKeyword([
                'max_cpc_bid_micros' => 2_500_000,
                'keyword' => new KeywordInfo([
                    'text' => 'mars cruise',
                    'match_type' => KeywordMatchType::BROAD
                ])
            ]),
            new BiddableKeyword([
                'max_cpc_bid_micros' => 1_500_000,
                'keyword' => new KeywordInfo([
                    'text' => 'cheap cruise',
                    'match_type' => KeywordMatchType::PHRASE
                ])
            ]),
            new BiddableKeyword([
                'max_cpc_bid_micros' => 1_990_000,
                'keyword' => new KeywordInfo([
                    'text' => 'jupiter cruise',
                    'match_type' => KeywordMatchType::BROAD
                ])
            ])
        ],
        'negative_keywords' => [
            new KeywordInfo([
                'text' => 'moon walk',
                'match_type' => KeywordMatchType::BROAD
            ])
        ]
    ]);
    $campaignToForecast->setAdGroups([$forecastAdGroup]);

    return $campaignToForecast;
}
GenerateForecastMetrics.php
      

Python

def main(client: GoogleAdsClient, customer_id: str):
    """The main method that creates all necessary entities for the example.

    Args:
        client: an initialized GoogleAdsClient instance.
        customer_id: a client customer ID.
    """
    campaign_to_forecast: CampaignToForecast = create_campaign_to_forecast(
        client
    )
    generate_forecast_metrics(client, customer_id, campaign_to_forecast)


def create_campaign_to_forecast(client: GoogleAdsClient) -> CampaignToForecast:
    """Creates the campaign to forecast.

    A campaign to forecast lets you try out various configurations and keywords
    to find the best optimization for your future campaigns. Once you've found
    the best campaign configuration, create a serving campaign in your Google
    Ads account with similar values and keywords. For more details, see:
    https://support.google.com/google-ads/answer/3022575

    Args:
        client: an initialized GoogleAdsClient instance.

    Returns:
        An CampaignToForecast instance.
    """
    googleads_service: GoogleAdsServiceClient = client.get_service(
        "GoogleAdsService"
    )
    # Create a campaign to forecast.
    campaign_to_forecast: CampaignToForecast = client.get_type(
        "CampaignToForecast"
    )
    # Set the bidding strategy.
    campaign_to_forecast.bidding_strategy.manual_cpc_bidding_strategy.max_cpc_bid_micros = (
        1000000
    )

    # For the list of geo target IDs, see:
    # https://developers.google.com/google-ads/api/reference/data/geotargets
    # Geo target constant 2840 is for USA.
    campaign_to_forecast.geo_target_constants.append(
        googleads_service.geo_target_constant_path("2840")
    )

    # For the list of language criteria IDs, see:
    # https://developers.google.com/google-ads/api/reference/data/codes-formats#languages
    # Language criteria 1000 is for English.
    campaign_to_forecast.language_constants.append(
        googleads_service.language_constant_path("1000")
    )

    # Create forecast ad groups based on themes such as creative relevance,
    # product category, or cost per click.
    forecast_ad_group: ForecastAdGroup = client.get_type("ForecastAdGroup")

    # Create and configure three KeywordInfo instances.
    keyword_1: KeywordInfo = client.get_type("KeywordInfo")
    keyword_1.text = "mars cruise"
    keyword_1.match_type = client.enums.KeywordMatchTypeEnum.BROAD

    keyword_2: KeywordInfo = client.get_type("KeywordInfo")
    keyword_2.text = "cheap cruise"
    keyword_2.match_type = client.enums.KeywordMatchTypeEnum.PHRASE

    keyword_3: KeywordInfo = client.get_type("KeywordInfo")
    keyword_3.text = "cheap cruise"
    keyword_3.match_type = client.enums.KeywordMatchTypeEnum.EXACT

    # Add the keywords to the forecast ad group.
    forecast_ad_group.keywords.extend([keyword_1, keyword_2, keyword_3])

    campaign_to_forecast.ad_groups.append(forecast_ad_group)

    return campaign_to_forecast


def generate_forecast_metrics(
    client: GoogleAdsClient,
    customer_id: str,
    campaign_to_forecast: CampaignToForecast,
):
    """Generates forecast metrics and prints the results.

    Args:
        client: an initialized GoogleAdsClient instance.
        customer_id: a client customer ID.
        campaign_to_forecast: a CampaignToForecast to generate metrics for.
    """
    keyword_plan_idea_service: KeywordPlanIdeaServiceClient = (
        client.get_service("KeywordPlanIdeaService")
    )
    request: GenerateKeywordForecastMetricsRequest = client.get_type(
        "GenerateKeywordForecastMetricsRequest"
    )
    request.customer_id = customer_id
    request.campaign = campaign_to_forecast
    # Set the forecast range. Repeat forecasts with different horizons to get a
    # holistic picture.
    # Set the forecast start date to tomorrow.
    tomorrow = datetime.now() + timedelta(days=1)
    request.forecast_period.start_date = tomorrow.strftime("%Y-%m-%d")
    # Set the forecast end date to 30 days from today.
    thirty_days_from_now = datetime.now() + timedelta(days=30)
    request.forecast_period.end_date = thirty_days_from_now.strftime("%Y-%m-%d")

    response: GenerateKeywordForecastMetricsResponse = (
        keyword_plan_idea_service.generate_keyword_forecast_metrics(
            request=request
        )
    )

    metrics = response.campaign_forecast_metrics
    print(f"Estimated daily clicks: {metrics.clicks}")
    print(f"Estimated daily average CPC: {metrics.average_cpc_micros}")
generate_forecast_metrics.py
      

Ruby

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

  campaign_to_forecast = create_campaign_to_forecast(client)

  # Generates forecast metrics and prints the results.
  keyword_plan_idea_service = client.service.keyword_plan_idea

  # Set the forecast range. Repeat forecasts with different horizons to get a
  # holistic picture.

  forecast_period = client.resource.date_range do |p|
    tomorrow = Date.today + 1
    p.start_date = tomorrow.strftime("%Y-%m-%d")

    # Set the forecast end date to 30 days from today.
    thirty_days_from_now = Date.today + 30
    p.end_date = thirty_days_from_now.strftime("%Y-%m-%d")
  end

  response = keyword_plan_idea_service.generate_keyword_forecast_metrics(
    customer_id: customer_id,
    campaign: campaign_to_forecast,
    forecast_period: forecast_period,
  )

  metrics = response.campaign_forecast_metrics
  puts "Estimated daily clicks: #{metrics.clicks}"
  puts "Estimated daily impressions: #{metrics.impressions}"
  puts "Estimated daily average CPC: #{metrics.average_cpc_micros}"
end

def create_campaign_to_forecast(client)
    campaign_to_forecast = client.resource.campaign_to_forecast do |c|
        c.keyword_plan_network = :GOOGLE_SEARCH

        c.bidding_strategy = client.resource.campaign_bidding_strategy do |bs|
            bs.manual_cpc_bidding_strategy = client.resource.manual_cpc_bidding_strategy do |mbs|
                mbs.max_cpc_bid_micros = 1000000
            end
        end

        criterion_bid_modifier = client.resource.criterion_bid_modifier

        # For the list of geo target IDs, see:
        # https://developers.google.com/google-ads/api/reference/data/geotargets
        # Geo target constant 2840 is for USA.
        criterion_bid_modifier.geo_target_constant = client.path.geo_target_constant("2840")

        c.geo_modifiers << criterion_bid_modifier

        # For the list of language criteria IDs, see:
        # https://developers.google.com/google-ads/api/reference/data/codes-formats#languages
        # Language criteria 1000 is for English.
        language_constant = client.path.language_constant("1000")  # English
        c.language_constants << language_constant

        # Create forecast ad groups based on themes such as creative relevance,
        # product category, or cost per click.
        forecast_ad_group = client.resource.forecast_ad_group

        biddable_keyword_1 = client.resource.biddable_keyword do |bk|
            bk.max_cpc_bid_micros = 1500000
            bk.keyword = client.resource.keyword_info do |k|
                k.text = "mars cruise"
                k.match_type = :BROAD
              end
        end

        biddable_keyword_2 = client.resource.biddable_keyword do |bk|
            bk.max_cpc_bid_micros = 2500000
            bk.keyword = client.resource.keyword_info do |k|
                k.text = "cheap cruise"
                k.match_type = :PHRASE
              end
        end

        biddable_keyword_3 = client.resource.biddable_keyword do |bk|
            bk.max_cpc_bid_micros = 1990000
            bk.keyword = client.resource.keyword_info do |k|
                k.text = "cheap cruise"
                k.match_type = :EXACT
              end
        end

        forecast_ad_group.biddable_keywords << biddable_keyword_1
        forecast_ad_group.biddable_keywords << biddable_keyword_2
        forecast_ad_group.biddable_keywords << biddable_keyword_3

        # Create and configure a negative keyword, then add it to the forecast ad
        # group.
        negative_keyword = client.resource.keyword_info do |k|
            k.text = "moon walk"
            k.match_type = :BROAD
          end
        forecast_ad_group.negative_keywords << negative_keyword

        c.ad_groups << forecast_ad_group
    end

    return campaign_to_forecast
end
generate_forecast_metrics.rb
      

Perl

sub generate_forecast_metrics {
  my ($api_client, $customer_id) = @_;

  my $campaign_to_forecast = create_campaign_to_forecast();

  my $keyword_forecast_metrics_response =
    $api_client->KeywordPlanIdeaService()->generate_keyword_forecast_metrics({
      customerId => $customer_id,
      campaign   => $campaign_to_forecast,
      # Set the forecast range. Repeat forecasts with different horizons
      # to get a holistic picture.
      forecastPeriod => Google::Ads::GoogleAds::V26::Common::DateRange->new({
          # Set the forecast start date to tomorrow.
          startDate => strftime("%Y-%m-%d", localtime(time + 60 * 60 * 24)),
          # Set the forecast end date to 30 days from today.
          endDate => strftime("%Y-%m-%d", localtime(time + 60 * 60 * 24 * 30))})
    });

  my $metrics = $keyword_forecast_metrics_response->{campaignForecastMetrics};

  printf "Estimated daily clicks: %s.\n",
    defined $metrics->{clicks} ? $metrics->{clicks} : "undef";
  printf "Estimated average cpc (micros): %s.\n\n",
    defined $metrics->{averageCpcMicros}
    ? $metrics->{averageCpcMicros}
    : "undef";

  return 1;
}

# Creates the campaign to forecast. A campaign to forecast lets you try out
# various configuration and keywords to find the best optimization for your
# future campaigns. Once you've found the best campaign configuration,
# create a serving campaign in your Google Ads account with similar values
# and keywords. For more details, see:
# https://support.google.com/google-ads/answer/3022575
sub create_campaign_to_forecast {
  my ($api_client) = @_;

  # Create a campaign to forecast.
  my $campaign_to_forecast =
    Google::Ads::GoogleAds::V26::Services::KeywordPlanIdeaService::CampaignToForecast
    ->new();

  # Set the bidding strategy.
  $campaign_to_forecast->{biddingStrategy}->{manualCpcBiddingStrategy} =
    Google::Ads::GoogleAds::V26::Services::KeywordPlanIdeaService::ManualCpcBiddingStrategy
    ->new({maxCpcBidMicros => 1000000});

  # See https://developers.google.com/google-ads/api/reference/data/geotargets
  # for the list of geo target IDs.
  # Geo target constant 2840 is for USA.
  $campaign_to_forecast->{geoTargetConstants} = [
    Google::Ads::GoogleAds::V26::Utils::ResourceNames::geo_target_constant(
      2840)];

  # See https://developers.google.com/google-ads/api/reference/data/codes-formats#languages
  # for the list of language criteria IDs.
  $campaign_to_forecast->{languageConstants} = [
    # Language criteria 1000 is for English.
    Google::Ads::GoogleAds::V26::Utils::ResourceNames::language_constant(1000)];

  # Create forecast ad groups based on themes such as creative relevance,
  # product category, or cost per click.
  $campaign_to_forecast->{adGroups} = [
    Google::Ads::GoogleAds::V26::Services::KeywordPlanIdeaService::ForecastAdGroup
      ->new({
        keywords => [
          Google::Ads::GoogleAds::V26::Common::KeywordInfo->new({
              text      => "mars cruise",
              matchType => 'BROAD'
            }
          ),
          Google::Ads::GoogleAds::V26::Common::KeywordInfo->new({
              text      => "cheap cruise",
              matchType => 'PHRASE'
            }
          ),
          Google::Ads::GoogleAds::V26::Common::KeywordInfo->new({
              text      => "jupiter cruise",
              matchType => 'EXACT'
            })]})];

  return $campaign_to_forecast;
}
generate_forecast_metrics.pl
      

curl

Lưu ý: Mặc dù không có mã mẫu REST trực tiếp cho bước này, nhưng bạn có thể thực hiện việc này bằng cách sử dụng yêu cầu REST thủ công.

Tham khảo tài liệu về giao diện REST của Google Ads API và các trang tham chiếu dành riêng cho phương thức. Bạn sẽ cần tạo tải trọng JSON dựa trên các định nghĩa proto.

Các tài nguyên chính:

• Sử dụng REST
• Cấu trúc giao diện REST
• JSON Field Mappings (Ánh xạ trường JSON)
• Tham khảo Tài liệu tham khảo API REST để biết dịch vụ và phương thức cụ thể.

Ánh xạ tới giao diện người dùng

Bảng sau đây ánh xạ các tham số KeywordPlanIdeaService.GenerateKeywordForecastMetrics đến Công cụ lập kế hoạch từ khoá trong giao diện người dùng Google Ads:

Công cụ lập kế hoạch từ khoá trong giao diện người dùng	API Google Ads
Nhập từ khoá	v24 trở lên: ForecastAdGroup.keywords Phiên bản 23 trở xuống: ForecastAdGroup.biddable_keywords
Vị trí	v24 trở lên: CampaignToForecast.geo_target_constants Phiên bản 23 trở xuống: CampaignToForecast.geo_modifiers
Ngôn ngữ	CampaignToForecast.language_constants
Ngân sách hằng ngày	ManualCpcBiddingStrategy.daily_budget_micros MaximizeClicksBiddingStrategy.daily_target_spend_micros MaximizeConversionsBiddingStrategy.daily_target_spend_micros
Giá thầu CPC	CampaignToForecast.bidding_strategy ManualCpcBiddingStrategy.max_cpc_bid_micros MaximizeClicksBiddingStrategy.max_cpc_bid_ceiling_micros Phiên bản 23 trở xuống: ForecastAdGroup.max_cpc_bid_micros, BiddableKeyword.max_cpc_bid_micros
Phạm vi ngày	GenerateKeywordForecastMetricsRequest.forecast_period