Générer des métriques de prévision

Les métriques de prévision fournissent des métriques pour les campagnes proposées ou existantes, y compris les suivantes:

  • Impressions
  • Taux de clics
  • Coût par clic moyen
  • Clics
  • Coût

Testez différentes configurations de campagne pour optimiser chacune de ces métriques. Des données telles que l'historique du score de qualité et le taux de clics peuvent être utilisées dans les prévisions pour simuler les performances attendues, comme le taux de conversion.

Les métriques de prévision sont généralement utilisées après l'historique des métriques. Les métriques historiques réduisent la taille d'une longue liste de mots clés pour la rendre plus facile à gérer. Les métriques de prévision fournissent une estimation plus exacte des performances futures de la campagne. Commencez par les métriques historiques des mots clés. Une fois la liste gérable, utilisez les métriques de prévision pour optimiser les performances de votre campagne.

Générer des métriques

Pour générer des métriques de prévision, procédez comme suit:

  1. Créez une campagne pour laquelle vous souhaitez effectuer des prévisions : CampaignToForecast.
  2. Appelez KeywordPlanIdeaService.GenerateKeywordForecastMetrics avec ce CampaignToForecast et tous les autres paramètres, tels que forecast_period.

Créer une campagne pour effectuer des prévisions

Voici quelques conseils à suivre lorsque vous créez votre campagne pour effectuer des prévisions:

  • Créez les groupes d'annonces en fonction de thèmes tels que la pertinence des créations, la catégorie de produit ou le coût par clic.
  • Incluez des mots clés à exclure courants. Par exemple, si vous ne vous occupez pas du recrutement, excluez le mot clé "emplois".
  • Utilisez un compte associé à la campagne. Ne faites pas de prévisions à partir d'un compte sans rapport. Google tient compte de facteurs tels que le score de qualité et le contenu de la création dans les prévisions.
  • Si une campagne n'a aucun lien avec le reste de votre compte, utilisez un nouveau compte propre pour la prévision.
  • Répétez les prévisions avec différents horizons afin d'obtenir une vue d'ensemble.

Générer des métriques de prévision

L'exemple de code suivant envoie une requête à KeywordPlanIdeaService.GenerateKeywordForecastMetrics. Il itère ensuite sur chacun des résultats et affiche chacune des métriques de prévision.

La réponse peut également renvoyer des ID temporaires dans la ressource (par exemple, customers/CUSTOMER_ID/keywordPlanCampaigns/-1).

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

C#

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

    KeywordPlanIdeaServiceClient keywordPlanIdeaService =
            client.GetService(Services.V18.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

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, customer_id):
    """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 = create_campaign_to_forecast(client)
    generate_forecast_metrics(client, customer_id, campaign_to_forecast)


def create_campaign_to_forecast(client):
    """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 = client.get_service("GoogleAdsService")
    # Create a campaign to forecast.
    campaign_to_forecast = 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 = 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 = client.get_type("ForecastAdGroup")

    # Create and configure three BiddableKeyword instances.
    biddable_keyword_1 = 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 = 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 = 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 = 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, customer_id, campaign_to_forecast):
    """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 = client.get_service("KeywordPlanIdeaService")
    request = 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 = 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

Ruby

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

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::V18::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::V18::Services::KeywordPlanIdeaService::CampaignToForecast
    ->new({keywordPlanNetwork => 'GOOGLE_SEARCH'});

  # Set the bidding strategy.
  $campaign_to_forecast->{biddingStrategy}->{manualCpcBiddingStrategy} =
    Google::Ads::GoogleAds::V18::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::V18::Services::KeywordPlanIdeaService::CriterionBidModifier
      ->new({
        # Geo target constant 2840 is for USA.
        geoTargetConstant =>
          Google::Ads::GoogleAds::V18::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::V18::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::V18::Services::KeywordPlanIdeaService::ForecastAdGroup
      ->new({
        biddableKeywords => [
          Google::Ads::GoogleAds::V18::Services::KeywordPlanIdeaService::BiddableKeyword
            ->new({
              maxCpcBidMicros => 2500000,
              keyword => Google::Ads::GoogleAds::V18::Common::KeywordInfo->new({
                  text      => "mars cruise",
                  matchType => 'BROAD'
                })}
            ),
          Google::Ads::GoogleAds::V18::Services::KeywordPlanIdeaService::BiddableKeyword
            ->new({
              maxCpcBidMicros => 1500000,
              keyword => Google::Ads::GoogleAds::V18::Common::KeywordInfo->new({
                  text      => "cheap cruise",
                  matchType => 'PHRASE'
                })}
            ),
          Google::Ads::GoogleAds::V18::Services::KeywordPlanIdeaService::BiddableKeyword
            ->new({
              maxCpcBidMicros => 1990000,
              keyword => Google::Ads::GoogleAds::V18::Common::KeywordInfo->new({
                  text      => "jupiter cruise",
                  matchType => 'EXACT'
                })})
        ],
        negativeKeywords => [
          Google::Ads::GoogleAds::V18::Common::KeywordInfo->new({
              text      => "moon walk",
              matchType => 'BROAD'
            })]})];

  return $campaign_to_forecast;
}

generate_forecast_metrics.pl

Mapper avec l'UI

KeywordPlanIdeaService.GenerateKeywordForecastMetrics offre une fonctionnalité similaire dans l'outil de planification des mots clés de l'interface utilisateur de Google Ads.

Interface utilisateur de l'Outil de planification des mots clés API Google Ads
Saisissez des mots clés CampaignToForecast.negative_keywords ou ForecastAdGroup.biddable_keywords ou ForecastAdGroup.negative_keywords
Zones CampaignToForecast.geo_targets
Langues CampaignToForecast.language_constants
Réseaux de recherche CampaignToForecast.keyword_plan_network
Enchère au CPC
Plage de dates forecastGenerateKeywordForecastMetricsRequest.forecast_period_period
Précédent
Générer des métriques historiques