Generowanie danych prognozy

Dane prognozowane to szacunkowe wskaźniki skuteczności (KeywordForecastMetrics) proponowanych lub istniejących kampanii. Dostępne dane prognozowane zależą od obsługiwanej wersji interfejsu API i strategii ustalania stawek:

• Wersja 24 i nowsze:
  • clicks (kliknięcia): zwracane tylko w przypadku używania ManualCpcBiddingStrategy lub MaximizeClicksBiddingStrategy.
  • cost_micros (koszt): łączny prognozowany koszt w mikrach.
  • average_cpc_micros (średni koszt kliknięcia): zwracane tylko w przypadku używania ManualCpcBiddingStrategy lub MaximizeClicksBiddingStrategy oraz clicks > 0.
  • conversions (konwersje): zwracane tylko w przypadku używania MaximizeConversionsBiddingStrategy.
  • average_cpa_micros (średni koszt pozyskania): zwracane tylko w przypadku używania MaximizeConversionsBiddingStrategy(obliczane jako cost_micros / conversions).
• Wersja 23 i starsze:
  • Oprócz clicks, cost_micros, average_cpc_micros, conversions i average_cpa_micros (zwracanych we wszystkich strategiach ustalania stawek) KeywordForecastMetrics zwraca też impressions (wyświetlenia), click_through_rate (współczynnik klikalności) i conversion_rate (współczynnik konwersji).

Eksperymentuj z różnymi konfiguracjami kampanii, aby zoptymalizować każdy z tych danych. Prognoza wykorzystuje dane takie jak historyczny wynik jakości i współczynnik klikalności, aby symulować oczekiwaną skuteczność.

Dane prognozowane są zwykle używane po znalezieniu słów kluczowych za pomocą pomysłów na słowa kluczowe lub po odfiltrowaniu istniejącej listy słów kluczowych za pomocą danych historycznych i opcjonalnym pogrupowaniu tych słów kluczowych według tematów grup reklam. Dane historyczne zawężają duży zbiór słów kluczowych na podstawie historycznej liczby wyszukiwań, a dane prognozowane symulują przyszłą skuteczność, dzięki czemu możesz zoptymalizować stawki, budżet dzienny i kierowanie przed zaktualizowaniem kampanii.

Generowanie danych

Aby wygenerować dane prognozowane, wykonaj te czynności:

1. Utwórz obiekt CampaignToForecast, który reprezentuje konfigurację kampanii, obiekty ForecastAdGroup i strategię ustalania stawek, które chcesz ocenić.
2. Wywołaj KeywordPlanIdeaService.GenerateKeywordForecastMetrics z tym obiektem CampaignToForecast i opcjonalnym forecast_period (którego data rozpoczęcia musi przypadać w przyszłości a data zakończenia w ciągu roku od dzisiaj; jeśli ten parametr zostanie pominięty, domyślnie zostanie ustawiony okres od najbliższej niedzieli do następnej soboty w strefie czasowej konta klienta).
3. Odczytaj dane na poziomie kampanii KeywordForecastMetrics z pola campaign_forecast_metrics w GenerateKeywordForecastMetricsResponse.

Tworzenie kampanii do prognozowania

Oto kilka wskazówek dotyczących tworzenia kampanii do prognozowania:

• Utwórz grupy reklam na podstawie tematów takich jak trafność kreacji, kategoria produktu lub koszt kliknięcia (albo skorzystaj z sugestii z GenerateAdGroupThemes).
• W wersji 23 i starszych uwzględnij typowe wykluczające słowa kluczowe, używając CampaignToForecast.negative_keywords lub ForecastAdGroup.negative_keywords (na przykład jeśli nie prowadzisz rekrutacji, wyklucz słowo kluczowe 'jobs'). W wersji 24 i nowszych, negative_keywords został usunięty.
• Użyj konta powiązanego z kampanią. Nie prognozuj na podstawie niezwiązanego konta. Google uwzględnia w prognozie wynik jakości i treść kreacji.
• Jeśli kampania nie jest powiązana z resztą konta, użyj do prognozowania nowego, czystego konta.
• Powtarzaj prognozy z różnymi horyzontami czasowymi, aby uzyskać pełny obraz.

Różnice między wersjami

W wersji 24 i nowszych obiekty CampaignToForecast, ForecastAdGroup i KeywordForecastMetrics używają uproszczonego schematu w porównaniu z wersją 23 i starszymi, jak pokazano w tabeli poniżej:

Funkcja	Wersja 24 i nowsze	Wersja 23 i starsze
Słowa kluczowe grupy reklam	ForecastAdGroup.keywords (repeated KeywordInfo)	ForecastAdGroup.biddable_keywords (repeated BiddableKeyword)
Kierowanie na lokalizację	CampaignToForecast.geo_target_constants (repeated string nazwy zasobów)	CampaignToForecast.geo_modifiers (repeated CriterionBidModifier z opcjonalnymi mnożnikami stawek)
Kierowanie na sieć wyszukiwania	Nie określono w CampaignToForecast (domyślnie wyszukiwarka Google)	Wymagany parametr CampaignToForecast.keyword_plan_network
Wykluczające słowa kluczowe	Nie są obsługiwane w CampaignToForecast ani ForecastAdGroup	Obsługiwane za pomocą CampaignToForecast.negative_keywords i ForecastAdGroup.negative_keywords
Zastąpienia stawek CPC na poziomie grupy reklam i słowa kluczowego	Konfigurowane tylko na poziomie strategii ustalania stawek w kampanii (ManualCpcBiddingStrategy.max_cpc_bid_micros lub MaximizeClicksBiddingStrategy.max_cpc_bid_ceiling_micros)	Można je też zastąpić na poziomie grupy reklam (ForecastAdGroup.max_cpc_bid_micros) lub słowa kluczowego (BiddableKeyword.max_cpc_bid_micros)
Niestandardowy oczekiwany współczynnik konwersji	Nie jest obsługiwany w CampaignToForecast	Opcjonalny parametr CampaignToForecast.conversion_rate
Zwrócone dane prognozowane	clicks i average_cpc_micros (tylko CPC ustawiany samodzielnie lub Maksymalizacja liczby kliknięć), cost_micros, conversions i average_cpa_micros (tylko Maksymalizacja liczby konwersji)	Zwraca clicks, cost_micros, average_cpc_micros, conversions i average_cpa_micros we wszystkich strategiach ustalania stawek oraz impressions, click_through_rate i conversion_rate

Przykładowy kod

Poniższy przykładowy kod wysyła żądanie do KeywordPlanIdeaService.GenerateKeywordForecastMetrics. Tworzy wbudowany obiekt CampaignToForecast z grupami reklam i słowami kluczowymi, a następnie wyświetla zwrócone dane campaign_forecast_metrics.

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

Uwaga: w tym kroku nie podajemy bezpośredniego przykładu kodu REST, ale możesz to zrobić za pomocą ręcznego żądania REST.

Zapoznaj się z dokumentacją interfejsu Google Ads API REST i stronami referencyjnymi dotyczącymi poszczególnych metod. Będziesz musiał(-a) utworzyć ładunek JSON na podstawie definicji proto.

Key Resources:

• Korzystanie z REST
• Struktura interfejsu REST
• Mapowania pól JSON
• Zapoznaj się z dokumentacją interfejsu REST API, aby uzyskać informacje o konkretnej usłudze i metodzie.

Mapowanie na interfejs

W tabeli poniżej znajdziesz mapowanie KeywordPlanIdeaService.GenerateKeywordForecastMetrics parametrów na Planer słów kluczowych w interfejsie Google Ads:

Planer słów kluczowych w interfejsie	Interfejs Google Ads API
Wpisz słowa kluczowe	Wersja 24 i nowsze: ForecastAdGroup.keywords Wersja 23 i starsze: ForecastAdGroup.biddable_keywords
Lokalizacje	Wersja 24 i nowsze: CampaignToForecast.geo_target_constants Wersja 23 i starsze: CampaignToForecast.geo_modifiers
Języki	CampaignToForecast.language_constants
Budżet dzienny	ManualCpcBiddingStrategy.daily_budget_micros MaximizeClicksBiddingStrategy.daily_target_spend_micros MaximizeConversionsBiddingStrategy.daily_target_spend_micros
Stawka CPC	CampaignToForecast.bidding_strategy ManualCpcBiddingStrategy.max_cpc_bid_micros MaximizeClicksBiddingStrategy.max_cpc_bid_ceiling_micros Wersja 23 i starsze: ForecastAdGroup.max_cpc_bid_micros, BiddableKeyword.max_cpc_bid_micros
Zakres dat	GenerateKeywordForecastMetricsRequest.forecast_period