متریک های پیش بینی را ایجاد کنید

معیارهای پیش‌بینی، معیارهایی را برای کمپین‌های پیشنهادی یا موجود ارائه می‌دهند، از جمله:

• برداشت‌ها
• نرخ کلیک
• میانگین هزینه به ازای هر کلیک
• کلیک‌ها
• هزینه

برای بهینه‌سازی هر یک از این معیارها، پیکربندی‌های مختلف کمپین را آزمایش کنید. داده‌هایی مانند امتیاز کیفیت تاریخی و نرخ کلیک ممکن است در پیش‌بینی برای شبیه‌سازی عملکرد مورد انتظار، مانند نرخ تبدیل، استفاده شوند.

معیارهای پیش‌بینی معمولاً پس از معیارهای تاریخی استفاده می‌شوند. معیارهای تاریخی، فهرست کلمات کلیدی بزرگ را به اندازه‌ای قابل مدیریت‌تر کاهش می‌دهند. معیارهای پیش‌بینی، تخمین دقیق‌تری از عملکرد کمپین‌های آینده ارائه می‌دهند. با معیارهای تاریخی برای کلمات کلیدی شروع کنید. هنگامی که فهرست قابل مدیریت شد، از معیارهای پیش‌بینی برای بهینه‌سازی عملکرد کمپین خود استفاده کنید.

ایجاد معیارها

برای تولید معیارهای پیش‌بینی، این مراحل را انجام دهید:

1. یک کمپین بسازید که می‌خواهید در آن پیش‌بینی‌های CampaignToForecast انجام دهید.
2. با استفاده از آن CampaignToForecast و هر پارامتر دیگری مانند forecast_period ، KeywordPlanIdeaService.GenerateKeywordForecastMetrics را فراخوانی کنید.

ایجاد کمپین برای پیش‌بینی

در اینجا چند نکته هنگام ایجاد کمپین خود برای پیش‌بینی آورده شده است:

• گروه‌های تبلیغاتی را بر اساس موضوعاتی مانند ارتباط خلاقانه، دسته‌بندی محصول یا هزینه به ازای هر کلیک ایجاد کنید.
• کلمات کلیدی منفی رایج را نیز لحاظ کنید. برای مثال، اگر در بخش استخدام نیستید، کلمه کلیدی «شغل» را حذف کنید.
• از حسابی استفاده کنید که با کمپین مرتبط باشد. از یک حساب کاربری غیرمرتبط پیش‌بینی نکنید. گوگل عواملی مانند امتیاز کیفیت و محتوای خلاقانه را در پیش‌بینی لحاظ می‌کند.
• اگر یک کمپین به بقیه حساب شما ربطی ندارد، از یک حساب کاربری جدید و بدون اطلاعات اضافی برای پیش‌بینی استفاده کنید.
• پیش‌بینی‌ها را با افق‌های مختلف تکرار کنید تا به یک تصویر جامع برسید.

ایجاد معیارهای پیش‌بینی

مثال کد بعدی درخواستی را به KeywordPlanIdeaService.GenerateKeywordForecastMetrics ارسال می‌کند. سپس روی هر یک از نتایج تکرار می‌شود و هر یک از معیارهای پیش‌بینی را نمایش می‌دهد.

این پاسخ همچنین می‌تواند شناسه‌های موقت را در منبع برگرداند - برای مثال، customers/CUSTOMER_ID/keywordPlanCampaigns/-1 .

جاوا

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 daily impressions: %s%n",
        metrics.hasImpressions() ? metrics.getImpressions() : 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
 *
 * @param googleAdsClient
 * @return
 */
private CampaignToForecast createCampaignToForecast(GoogleAdsClient googleAdsClient) {
  CampaignToForecast.Builder campaignToForecastBuilder =
      CampaignToForecast.newBuilder()
          .setKeywordPlanNetwork(KeywordPlanNetwork.GOOGLE_SEARCH)
          .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.
  campaignToForecastBuilder.addGeoModifiers(
      CriterionBidModifier.newBuilder()
          // Geo target constant 2840 is for USA.
          .setGeoTargetConstant(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.addBiddableKeywords(
      BiddableKeyword.newBuilder()
          .setMaxCpcBidMicros(2_500_000)
          .setKeyword(
              KeywordInfo.newBuilder()
                  .setText("mars cruise")
                  .setMatchType(KeywordMatchType.BROAD)));

  forecastAdGroupBuilder.addBiddableKeywords(
      BiddableKeyword.newBuilder()
          .setMaxCpcBidMicros(1_500_000)
          .setKeyword(
              KeywordInfo.newBuilder()
                  .setText("cheap cruise")
                  .setMatchType(KeywordMatchType.PHRASE)));

  forecastAdGroupBuilder.addBiddableKeywords(
      BiddableKeyword.newBuilder()
          .setMaxCpcBidMicros(1_990_000)
          .setKeyword(
              KeywordInfo.newBuilder()
                  .setText("jupiter cruise")
                  .setMatchType(KeywordMatchType.BROAD)));

  forecastAdGroupBuilder.addNegativeKeywords(
      KeywordInfo.newBuilder().setText("moon walk").setMatchType(KeywordMatchType.BROAD));

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

سی شارپ

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

    KeywordPlanIdeaServiceClient keywordPlanIdeaService =
            client.GetService(Services.V22.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 daily impressions: {metrics.Impressions}.");
        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()
    {
        KeywordPlanNetwork = KeywordPlanNetwork.GoogleSearch,
        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.
    campaignToForecast.GeoModifiers.Add(new CriterionBidModifier()
    {
        // Geo target constant 2840 is for USA.
        GeoTargetConstant = 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();

    forecastAdGroup.BiddableKeywords.Add(new BiddableKeyword()
    {
        MaxCpcBidMicros = 2_500_000,
        Keyword = new KeywordInfo()
        {
            Text = "mars cruise",
            MatchType = KeywordMatchType.Broad
        }
    });

    forecastAdGroup.BiddableKeywords.Add(new BiddableKeyword()
    {
        MaxCpcBidMicros = 1_500_000,
        Keyword = new KeywordInfo()
        {
            Text = "cheap cruise",
            MatchType = KeywordMatchType.Phrase
        }
    });

    forecastAdGroup.BiddableKeywords.Add(new BiddableKeyword()
    {
        MaxCpcBidMicros = 1_990_000,
        Keyword = new KeywordInfo()
        {
            Text = "jupiter cruise",
            MatchType = KeywordMatchType.Broad
        }
    });

    forecastAdGroup.NegativeKeywords.Add(new KeywordInfo()
    {
        Text = "moon walk",
        MatchType = KeywordMatchType.Broad
    });

    campaignToForecast.AdGroups.Add(forecastAdGroup);

    return campaignToForecast;
}
GenerateForecastMetrics.cs
      

پی اچ پی

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
      

پایتون

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"
    )
    campaign_to_forecast.keyword_plan_network = (
        client.enums.KeywordPlanNetworkEnum.GOOGLE_SEARCH
    )

    # 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
    criterion_bid_modifier: CriterionBidModifier = client.get_type(
        "CriterionBidModifier"
    )
    # Geo target constant 2840 is for USA.
    criterion_bid_modifier.geo_target_constant = (
        googleads_service.geo_target_constant_path("2840")
    )
    campaign_to_forecast.geo_modifiers.append(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.
    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 BiddableKeyword instances.
    biddable_keyword_1: BiddableKeyword = client.get_type("BiddableKeyword")
    biddable_keyword_1.max_cpc_bid_micros = 2500000
    biddable_keyword_1.keyword.text = "mars cruise"
    biddable_keyword_1.keyword.match_type = (
        client.enums.KeywordMatchTypeEnum.BROAD
    )

    biddable_keyword_2: BiddableKeyword = client.get_type("BiddableKeyword")
    biddable_keyword_2.max_cpc_bid_micros = 1500000
    biddable_keyword_2.keyword.text = "cheap cruise"
    biddable_keyword_2.keyword.match_type = (
        client.enums.KeywordMatchTypeEnum.PHRASE
    )

    biddable_keyword_3: BiddableKeyword = client.get_type("BiddableKeyword")
    biddable_keyword_3.max_cpc_bid_micros = 1990000
    biddable_keyword_3.keyword.text = "cheap cruise"
    biddable_keyword_3.keyword.match_type = (
        client.enums.KeywordMatchTypeEnum.EXACT
    )

    # Add the biddable keywords to the forecast ad group.
    forecast_ad_group.biddable_keywords.extend(
        [biddable_keyword_1, biddable_keyword_2, biddable_keyword_3]
    )

    # Create and configure a negative keyword, then add it to the forecast ad
    # group.
    negative_keyword: KeywordInfo = client.get_type("KeywordInfo")
    negative_keyword.text = "moon walk"
    negative_keyword.match_type = client.enums.KeywordMatchTypeEnum.BROAD
    forecast_ad_group.negative_keywords.append(negative_keyword)

    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 impressions: {metrics.impressions}")
    print(f"Estimated daily average CPC: {metrics.average_cpc_micros}")
generate_forecast_metrics.py
      

روبی

This example is not yet available in Ruby; you can take a look at the other languages.
    

پرل

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::V22::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 daily impressions: %s.\n",
    defined $metrics->{impressions} ? $metrics->{impressions} : "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::V22::Services::KeywordPlanIdeaService::CampaignToForecast
    ->new({keywordPlanNetwork => 'GOOGLE_SEARCH'});

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

  # See https://developers.google.com/google-ads/api/reference/data/geotargets
  # for the list of geo target IDs.
  $campaign_to_forecast->{geoModifiers} = [
    Google::Ads::GoogleAds::V22::Services::KeywordPlanIdeaService::CriterionBidModifier
      ->new({
        # Geo target constant 2840 is for USA.
        geoTargetConstant =>
          Google::Ads::GoogleAds::V22::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::V22::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::V22::Services::KeywordPlanIdeaService::ForecastAdGroup
      ->new({
        biddableKeywords => [
          Google::Ads::GoogleAds::V22::Services::KeywordPlanIdeaService::BiddableKeyword
            ->new({
              maxCpcBidMicros => 2500000,
              keyword => Google::Ads::GoogleAds::V22::Common::KeywordInfo->new({
                  text      => "mars cruise",
                  matchType => 'BROAD'
                })}
            ),
          Google::Ads::GoogleAds::V22::Services::KeywordPlanIdeaService::BiddableKeyword
            ->new({
              maxCpcBidMicros => 1500000,
              keyword => Google::Ads::GoogleAds::V22::Common::KeywordInfo->new({
                  text      => "cheap cruise",
                  matchType => 'PHRASE'
                })}
            ),
          Google::Ads::GoogleAds::V22::Services::KeywordPlanIdeaService::BiddableKeyword
            ->new({
              maxCpcBidMicros => 1990000,
              keyword => Google::Ads::GoogleAds::V22::Common::KeywordInfo->new({
                  text      => "jupiter cruise",
                  matchType => 'EXACT'
                })})
        ],
        negativeKeywords => [
          Google::Ads::GoogleAds::V22::Common::KeywordInfo->new({
              text      => "moon walk",
              matchType => 'BROAD'
            })]})];

  return $campaign_to_forecast;
}
generate_forecast_metrics.pl
      

نقشه به رابط کاربری

KeywordPlanIdeaService.GenerateKeywordForecastMetrics عملکرد مشابهی در Keyword Planner رابط کاربری گوگل ادز دارد.

رابط کاربری برنامه‌ریز کلمات کلیدی	رابط برنامه‌نویسی کاربردی گوگل ادز
کلمات کلیدی را وارد کنید	CampaignToForecast.negative_keywords یا ForecastAdGroup.biddable_keywords یا ForecastAdGroup.negative_keywords
مکان‌ها	CampaignToForecast.geo_targets
زبان‌ها	CampaignToForecast.language_constants
شبکه‌های جستجو	CampaignToForecast.keyword_plan_network
پیشنهاد قیمت CPC	CampaignToForecast.bidding_strategy ForecastAdGroup.max_cpc_bid_micros BiddableKeyword.max_cpc_bid_micros
محدوده تاریخ	forecastGenerateKeywordForecastMetricsRequest.forecast_period_period