Estimativa de tráfego

O TrafficEstimatorService da AdWords API recupera estimativas de tráfego de campanhas, grupos de anúncios e palavras-chave propostos ou existentes, incluindo estatísticas estimadas como:

  • CPC médio
  • Posição média
  • Taxa de cliques
  • Cliques por dia
  • Impressões por dia
  • Custo total

Para simular campanhas propostas e grupo de anúncios, use diferentes critérios de campanha, configurações de rede, orçamentos diários e CPCs máximos.

Você também pode recuperar as estimativas de tráfego para uma campanha ou um grupo de anúncios existente. Para fazer isso, forneça o campaignId e o adGroupId correspondentes.

Caso de uso

Ao criar uma campanha e um grupo de anúncios novos, ou ao modificar campanhas existentes, você pode usar o TrafficEstimatorService para estimar o tráfego futuro e ajudar a determinar se as palavras-chave (e configurações) são ideais. Por exemplo, se as palavras-chave escolhidas resultarem em um CTR mais baixo, convém reconsiderar o uso delas.

Também é possível usar o TrafficEstimatorService para receber informações do mesmo modo que é feito com o recurso Receber previsões de desempenho de cliques e custos do Planejador de palavras-chave do Google AdWords.

Additionally, you can use the TargetingIdeaService to get additional keyword ideas for an ad group. Antes de implementar as novas ideias de palavras-chave, use o TrafficEstimatorService para ter uma estimativa sobre o desempenho dessas novas palavras-chave. Consulte o guia Como gerar ideias de segmentação para mais informações.

Como receber estimativas de tráfego

A principal entrada do TrafficEstimatorService é o TrafficEstimatorSelector.

Para recuperar as estimativas de tráfego, você precisa especificar as campanhas e os grupos de anúncios existentes ou configurar campanhas e grupos de anúncios propostos definindo CampaignEstimateRequest e AdGroupEstimateRequest.

No AdGroupEstimateRequest, também é necessário especificar um KeywordEstimateRequest para as palavras-chave cujas estatísticas de tráfego você deseja receber.

As seções a seguir detalham um exemplo de como receber estimativas de tráfego do TrafficEstimatorService.

Preparar a solicitação

Você precisa criar o TrafficEstimatorSelector de baixo para cima. Para gerar uma solicitação completa, você deve criar a solicitação na seguinte ordem:

  1. KeywordEstimateRequest
  2. AdGroupEstimateRequest
  3. CampaignEstimateRequest

Primeiro, você precisa criar o KeywordEstimateRequest. É comum recuperar estimativas de várias palavras-chave. Nesse caso, cada palavra-chave deverá ter um KeywordEstimateRequest correspondente.

Java

List<Keyword> keywords = new ArrayList<Keyword>();

Keyword marsCruiseKeyword = new Keyword();
marsCruiseKeyword.setText("mars cruise");
marsCruiseKeyword.setMatchType(KeywordMatchType.BROAD);
keywords.add(marsCruiseKeyword);

Keyword cheapCruiseKeyword = new Keyword();
cheapCruiseKeyword.setText("cheap cruise");
cheapCruiseKeyword.setMatchType(KeywordMatchType.PHRASE);
keywords.add(cheapCruiseKeyword);

Keyword cruiseKeyword = new Keyword();
cruiseKeyword.setText("cruise");
cruiseKeyword.setMatchType(KeywordMatchType.EXACT);
keywords.add(cruiseKeyword);

// Create a keyword estimate request for each keyword.
List<KeywordEstimateRequest> keywordEstimateRequests = new ArrayList<KeywordEstimateRequest>();
for (Keyword keyword : keywords) {
  KeywordEstimateRequest keywordEstimateRequest = new KeywordEstimateRequest();
  keywordEstimateRequest.setKeyword(keyword);
  keywordEstimateRequests.add(keywordEstimateRequest);
}

// Add a negative keyword to the traffic estimate.
KeywordEstimateRequest negativeKeywordEstimateRequest = new KeywordEstimateRequest();
negativeKeywordEstimateRequest.setKeyword(new Keyword(null, null, null, "hiking tour",
    KeywordMatchType.BROAD));
negativeKeywordEstimateRequest.setIsNegative(true);
keywordEstimateRequests.add(negativeKeywordEstimateRequest);
    

.NET

Keyword keyword1 = new Keyword();
keyword1.text = "mars cruise";
keyword1.matchType = KeywordMatchType.BROAD;

Keyword keyword2 = new Keyword();
keyword2.text = "cheap cruise";
keyword2.matchType = KeywordMatchType.PHRASE;

Keyword keyword3 = new Keyword();
keyword3.text = "cruise";
keyword3.matchType = KeywordMatchType.EXACT;

Keyword[] keywords = new Keyword[] { keyword1, keyword2, keyword3 };

// Create a keyword estimate request for each keyword.
List<KeywordEstimateRequest> keywordEstimateRequests = new List<KeywordEstimateRequest>();

foreach (Keyword keyword in keywords) {
  KeywordEstimateRequest keywordEstimateRequest = new KeywordEstimateRequest();
  keywordEstimateRequest.keyword = keyword;
  keywordEstimateRequests.Add(keywordEstimateRequest);
}

// Create negative keywords.
Keyword negativeKeyword1 = new Keyword();
negativeKeyword1.text = "moon walk";
negativeKeyword1.matchType = KeywordMatchType.BROAD;

KeywordEstimateRequest negativeKeywordEstimateRequest = new KeywordEstimateRequest();
negativeKeywordEstimateRequest.keyword = negativeKeyword1;
negativeKeywordEstimateRequest.isNegative = true;
keywordEstimateRequests.Add(negativeKeywordEstimateRequest);
    

Python

keywords = [
    {'text': 'mars cruise', 'matchType': 'BROAD'},
    {'text': 'cheap cruise', 'matchType': 'PHRASE'},
    {'text': 'cruise', 'matchType': 'EXACT'}
]
negative_keywords = [
    {'text': 'moon walk', 'matchType': 'BROAD'}
]
keyword_estimate_requests = []
for keyword in keywords:
  keyword_estimate_requests.append({
      'keyword': {
          'xsi_type': 'Keyword',
          'matchType': keyword['matchType'],
          'text': keyword['text']
      }
  })

for keyword in negative_keywords:
  keyword_estimate_requests.append({
      'keyword': {
          'xsi_type': 'Keyword',
          'matchType': keyword['matchType'],
          'text': keyword['text']
      },
      'isNegative': 'true'
  })
    

PHP

// Create keywords. Up to 2000 keywords can be passed in a single request.
$keywords = array();
$keywords[] = new Keyword('mars cruise', 'BROAD');
$keywords[] = new Keyword('cheap cruise', 'PHRASE');
$keywords[] = new Keyword('cruise', 'EXACT');

// Create a keyword estimate request for each keyword.
$keywordEstimateRequests = array();
foreach ($keywords as $keyword) {
  $keywordEstimateRequest = new KeywordEstimateRequest();
  $keywordEstimateRequest->keyword = $keyword;
  $keywordEstimateRequests[] = $keywordEstimateRequest;
}

// Negative keywords don't return estimates, but adjust the estimates of the
// other keywords in the hypothetical ad group.
$negativeKeywords = array();
$negativeKeywords[] = new Keyword('moon walk', 'BROAD');

// Create a keyword estimate request for each negative keyword.
foreach ($negativeKeywords as $negativeKeyword) {
  $keywordEstimateRequest = new KeywordEstimateRequest();
  $keywordEstimateRequest->keyword = $negativeKeyword;
  $keywordEstimateRequest->isNegative = true;
  $keywordEstimateRequests[] = $keywordEstimateRequest;
}
    

Perl

# Create keywords. Refer to the TrafficEstimatorService documentation for
# the maximum number of keywords that can be passed in a single request.
# https://developers.google.com/adwords/api/docs/reference/latest/TrafficEstimatorService
my @keywords = (
  Google::Ads::AdWords::v201609::Keyword->new({
      text      => "mars cruise",
      matchType => "BROAD"
    }
  ),
  Google::Ads::AdWords::v201609::Keyword->new({
      text      => "cheap cruise",
      matchType => "PHRASE"
    }
  ),
  Google::Ads::AdWords::v201609::Keyword->new({
      text      => "cruise",
      matchType => "EXACT"
    }));

my @negative_keywords = (
  Google::Ads::AdWords::v201609::Keyword->new({
      text      => "moon walk",
      matchType => "BROAD"
    }));

# Create a keyword estimate request for each keyword.
my @keyword_estimate_requests;
foreach my $keyword (@keywords) {
  push @keyword_estimate_requests,
    Google::Ads::AdWords::v201609::KeywordEstimateRequest->new(
    {keyword => $keyword,});
}
foreach my $keyword (@negative_keywords) {
  push @keyword_estimate_requests,
    Google::Ads::AdWords::v201609::KeywordEstimateRequest->new({
      keyword    => $keyword,
      isNegative => 1
    });
}
    

Ruby

# Create keywords. Up to 2000 keywords can be passed in a single request.
keywords = [
    # The 'xsi_type' field allows you to specify the xsi:type of the object
    # being created. It's only necessary when you must provide an explicit
    # type that the client library can't infer.
  {:xsi_type => 'Keyword', :text => 'mars cruise', :match_type => 'BROAD'},
  {:xsi_type => 'Keyword', :text => 'cheap cruise', :match_type => 'PHRASE'},
  {:xsi_type => 'Keyword', :text => 'cruise', :match_type => 'EXACT'},
  {:xsi_type => 'Keyword', :text => 'moon walk', :match_type => 'BROAD'}
]

# Create a keyword estimate request for each keyword.
keyword_requests = keywords.map {|keyword| {:keyword => keyword}}

# Negative keywords don't return estimates, but adjust the estimates of the
# other keywords in the hypothetical ad group. To specify a negative keyword
# set the is_negative field to true.
keyword_requests[3][:is_negative] = true
    

A lista de palavras-chave enviada para o TrafficEstimatorService pode ter um conteúdo que já existe na sua taxonomia de palavras-chave ou novas palavras-chave recuperadas do TargetingIdeaService.

Em seguida, crie o AdGroupEstimateRequest. Como ocorre na lista de palavras-chave, é possível ver estimativas de vários grupos de anúncios. Este exemplo calcula estimativas apenas para um único grupo de anúncios:

Java

// Create ad group estimate requests.
List<AdGroupEstimateRequest> adGroupEstimateRequests = new ArrayList<AdGroupEstimateRequest>();
AdGroupEstimateRequest adGroupEstimateRequest = new AdGroupEstimateRequest();
adGroupEstimateRequest.setKeywordEstimateRequests(keywordEstimateRequests
    .toArray(new KeywordEstimateRequest[] {}));
adGroupEstimateRequest.setMaxCpc(new Money(null, 1000000L));
adGroupEstimateRequests.add(adGroupEstimateRequest);
    

.NET

// Create ad group estimate requests.
AdGroupEstimateRequest adGroupEstimateRequest = new AdGroupEstimateRequest();
adGroupEstimateRequest.keywordEstimateRequests = keywordEstimateRequests.ToArray();
adGroupEstimateRequest.maxCpc = new Money();
adGroupEstimateRequest.maxCpc.microAmount = 1000000;
    

Python

# Create ad group estimate requests.
adgroup_estimate_requests = [{
    'keywordEstimateRequests': keyword_estimate_requests,
    'maxCpc': {
        'xsi_type': 'Money',
        'microAmount': '1000000'
    }
}]
    

PHP

// Create ad group estimate requests.
$adGroupEstimateRequest = new AdGroupEstimateRequest();
$adGroupEstimateRequest->keywordEstimateRequests = $keywordEstimateRequests;
$adGroupEstimateRequest->maxCpc = new Money(1000000);
    

Perl

# Create ad group estimate requests.
my $ad_group_estimate_request =
  Google::Ads::AdWords::v201609::AdGroupEstimateRequest->new({
    keywordEstimateRequests => \@keyword_estimate_requests,
    maxCpc =>
      Google::Ads::AdWords::v201609::Money->new({microAmount => 1000000})});
    

Ruby

# Create ad group estimate requests.
ad_group_request = {
    :keyword_estimate_requests => keyword_requests,
    :max_cpc => {
        :micro_amount => 1000000
    }
}
    

Em seguida, crie a CampaignEstimateRequest. Para resultados mais precisos, você também deve definir critérios de campanha adicionais ao criar o CampaignEstimateRequest, como local e idioma. Também é possível especificar IDs de campanhas e grupos de anúncios existentes no CampaignEstimateRequest e no AdGroupEstimateRequest, o que permite que o serviço carregue dados do histórico.

Java

// Create campaign estimate requests.
List<CampaignEstimateRequest> campaignEstimateRequests =
    new ArrayList<CampaignEstimateRequest>();
CampaignEstimateRequest campaignEstimateRequest = new CampaignEstimateRequest();
campaignEstimateRequest.setAdGroupEstimateRequests(adGroupEstimateRequests
    .toArray(new AdGroupEstimateRequest[] {}));

Location unitedStates = new Location();
unitedStates.setId(2840L);
Language english = new Language();
english.setId(1000L);
campaignEstimateRequest.setCriteria(new Criterion[] {unitedStates, english});
campaignEstimateRequests.add(campaignEstimateRequest);
    

.NET

// Create campaign estimate requests.
CampaignEstimateRequest campaignEstimateRequest = new CampaignEstimateRequest();
campaignEstimateRequest.adGroupEstimateRequests = new AdGroupEstimateRequest[] {
    adGroupEstimateRequest};

// Optional: Set additional criteria for filtering estimates.
// See http://code.google.com/apis/adwords/docs/appendix/countrycodes.html
// for a detailed list of country codes.
Location countryCriterion = new Location();
countryCriterion.id = 2840; //US

// See http://code.google.com/apis/adwords/docs/appendix/languagecodes.html
// for a detailed list of language codes.
Language languageCriterion = new Language();
languageCriterion.id = 1000; //en

campaignEstimateRequest.criteria = new Criterion[] { countryCriterion, languageCriterion };
    

Python

# Create campaign estimate requests.
campaign_estimate_requests = [{
    'adGroupEstimateRequests': adgroup_estimate_requests,
    'criteria': [
        {
            'xsi_type': 'Location',
            'id': '2840'  # United States.
        },
        {
            'xsi_type': 'Language',
            'id': '1000'  # English.
        }
    ],
}]
    

PHP

// Create campaign estimate requests.
$campaignEstimateRequest = new CampaignEstimateRequest();
$campaignEstimateRequest->adGroupEstimateRequests[] = $adGroupEstimateRequest;

// Optional: Set additional criteria for filtering estimates.
// See http://code.google.com/apis/adwords/docs/appendix/countrycodes.html
// for a detailed list of country codes.
// Set targeting criteria. Only locations and languages are supported.
$unitedStates = new Location();
$unitedStates->id = 2840;
$campaignEstimateRequest->criteria[] = $unitedStates;

// See http://code.google.com/apis/adwords/docs/appendix/languagecodes.html
// for a detailed list of language codes.
$english = new Language();
$english->id = 1000;
$campaignEstimateRequest->criteria[] = $english;
    

Perl

my $location = Google::Ads::AdWords::v201609::Location->new({
    id => "2840"    # US - see http://goo.gl/rlrFr
});
my $language = Google::Ads::AdWords::v201609::Language->new({
    id => "1000"    # en - see http://goo.gl/LvMmS
});

# Create campaign estimate requests.
my $campaign_estimate_request =
  Google::Ads::AdWords::v201609::CampaignEstimateRequest->new({
    adGroupEstimateRequests => [$ad_group_estimate_request],
    criteria                => [$location, $language]});
    

Ruby

# Create campaign estimate requests.
campaign_request = {
    :ad_group_estimate_requests => [ad_group_request],
    # Set targeting criteria. Only locations and languages are supported.
    :criteria => [
        {:xsi_type => 'Location', :id => 2840}, # United States
        {:xsi_type => 'Language', :id => 1000}  # English
    ]
}
    

Por fim, configure o TrafficEstimatorSelector. Depois, você poderá enviá-lo por meio da operação get() para recuperar as estimativas de tráfego encapsuladas no objeto TrafficEstimatorResult. A partir da v201605, você pode solicitar uma lista de estimativas no nível da campanha segmentadas por plataforma usando a propriedade platformEstimateRequested.

Java

// Create selector.
TrafficEstimatorSelector selector = new TrafficEstimatorSelector();
selector.setCampaignEstimateRequests(campaignEstimateRequests
    .toArray(new CampaignEstimateRequest[] {}));

// Optional: Request a list of campaign level estimates segmented by platform.
selector.setPlatformEstimateRequested(true);

// Get traffic estimates.
TrafficEstimatorResult result = trafficEstimatorService.get(selector);
    

.NET

// Create the selector.
TrafficEstimatorSelector selector = new TrafficEstimatorSelector() {
  campaignEstimateRequests = new CampaignEstimateRequest[] { campaignEstimateRequest },

  // Optional: Request a list of campaign level estimates segmented by platform.
  platformEstimateRequested = true
};

// Get traffic estimates.
TrafficEstimatorResult result = trafficEstimatorService.get(selector);
    

Python

# Create the selector.
selector = {
    'campaignEstimateRequests': campaign_estimate_requests,
}

# Optional: Request a list of campaign-level estimates segmented by
# platform.
selector['platformEstimateRequested'] = True

# Get traffic estimates.
estimates = traffic_estimator_service.get(selector)
    

PHP

// Create selector.
$selector = new TrafficEstimatorSelector();
$selector->campaignEstimateRequests[] = $campaignEstimateRequest;

// Optional: Request a list of campaign level estimates segmented by platform.
$selector->platformEstimateRequested = true;

// Make the get request.
$result = $trafficEstimatorService->get($selector);
    

Perl

# Optional: Request a list of campaign level estimates segmented by platform.
my $platform_estimate_request = "1";

# Create selector.
my $selector = Google::Ads::AdWords::v201609::TrafficEstimatorSelector->new({
    campaignEstimateRequests  => [$campaign_estimate_request],
    platformEstimateRequested => [$platform_estimate_request]});

# Get traffic estimates.
my $result = $client->TrafficEstimatorService()->get({selector => $selector});
    

Ruby

# Create a selector.
selector = {
  :campaign_estimate_requests => [campaign_request],
  # Optional: Request a list of campaign level estimates segmented by
  # platform.
  :platform_estimate_requested => true
}

# Execute the request.
response = traffic_estimator_srv.get(selector)
    

Processar a resposta

Todo objeto CampaignEstimateRequest no seletor gera um objeto CampaignEstimate correspondente no TrafficEstimatorResult. Da mesma forma, cada objeto AdGroupEstimateRequest tem um objeto AdGroupEstimate correspondente no resultado. Se você solicitou estimativas no nível da campanha segmentadas por plataforma, elas serão disponibilizadas pela propriedade platformEstimates do objeto CampaignEstimate.

Java

// Display traffic estimates.
if (result != null
    && result.getCampaignEstimates() != null
    && result.getCampaignEstimates().length > 0) {
  CampaignEstimate campaignEstimate = result.getCampaignEstimates()[0];

  // Display the campaign level estimates segmented by platform.
  if (campaignEstimate.getPlatformEstimates() != null) {
    for (PlatformCampaignEstimate platformEstimate : campaignEstimate.getPlatformEstimates()) {
      String platformMessage =
          String.format(
              "Results for the platform with ID %d and name '%s':%n",
              platformEstimate.getPlatform().getId(),
              platformEstimate.getPlatform().getPlatformName());
      displayMeanEstimates(
          platformMessage,
          platformEstimate.getMinEstimate(),
          platformEstimate.getMaxEstimate());
    }
  }

  // Display the keyword estimates.
  KeywordEstimate[] keywordEstimates =
      campaignEstimate.getAdGroupEstimates()[0].getKeywordEstimates();
  for (int i = 0; i < keywordEstimates.length; i++) {
    if (Boolean.TRUE.equals(keywordEstimateRequests.get(i).getIsNegative())) {
      continue;
    }

    Keyword keyword = keywordEstimateRequests.get(i).getKeyword();
    KeywordEstimate keywordEstimate = keywordEstimates[i];

    String keywordMessage =
        String.format(
            "Results for the keyword with text '%s' and match type '%s':%n",
            keyword.getText(), keyword.getMatchType());
    displayMeanEstimates(keywordMessage, keywordEstimate.getMin(), keywordEstimate.getMax());
  }
} else {
  System.out.println("No traffic estimates were returned.");
}
    

.NET

// Display traffic estimates.
if (result != null && result.campaignEstimates != null &&
    result.campaignEstimates.Length > 0) {
  CampaignEstimate campaignEstimate = result.campaignEstimates[0];

  // Display the campaign level estimates segmented by platform.
  if (campaignEstimate.platformEstimates != null) {
    foreach (PlatformCampaignEstimate platformEstimate in
        campaignEstimate.platformEstimates) {
      string platformMessage = string.Format("Results for the platform with ID: " +
          "{0} and name : {1}.", platformEstimate.platform.id,
          platformEstimate.platform.platformName);

      DisplayMeanEstimates(platformMessage, platformEstimate.minEstimate,
          platformEstimate.maxEstimate);
    }
  }

  // Display the keyword estimates.
  if (campaignEstimate.adGroupEstimates != null &&
      campaignEstimate.adGroupEstimates.Length > 0) {
    AdGroupEstimate adGroupEstimate = campaignEstimate.adGroupEstimates[0];

    if (adGroupEstimate.keywordEstimates != null) {
      for (int i = 0; i < adGroupEstimate.keywordEstimates.Length; i++) {
        Keyword keyword = keywordEstimateRequests[i].keyword;
        KeywordEstimate keywordEstimate = adGroupEstimate.keywordEstimates[i];

        if (keywordEstimateRequests[i].isNegative) {
          continue;
        }
        string kwdMessage = string.Format("Results for the keyword with text = '{0}' " +
            "and match type = '{1}':", keyword.text, keyword.matchType);
        DisplayMeanEstimates(kwdMessage, keywordEstimate.min, keywordEstimate.max);
      }
    }
  }
} else {
  Console.WriteLine("No traffic estimates were returned.");
}
    

Python

campaign_estimate = estimates['campaignEstimates'][0]

# Display the campaign level estimates segmented by platform.
if 'platformEstimates' in campaign_estimate:
  platform_template = ('Results for the platform with ID: "%d" and name: '
                       '"%s".')
  for platform_estimate in campaign_estimate['platformEstimates']:
    platform = platform_estimate['platform']
    DisplayEstimate(platform_template % (platform['id'],
                                         platform['platformName']),
                    platform_estimate['minEstimate'],
                    platform_estimate['maxEstimate'])

# Display the keyword estimates.
if 'adGroupEstimates' in campaign_estimate:
  ad_group_estimate = campaign_estimate['adGroupEstimates'][0]
  if 'keywordEstimates' in ad_group_estimate:
    keyword_estimates = ad_group_estimate['keywordEstimates']
    keyword_template = ('Results for the keyword with text "%s" and match '
                        'type "%s":')

    keyword_estimates_and_requests = zip(keyword_estimates,
                                         keyword_estimate_requests)

    for keyword_tuple in keyword_estimates_and_requests:
      if keyword_tuple[1].get('isNegative', False):
        continue
      keyword = keyword_tuple[1]['keyword']
      keyword_estimate = keyword_tuple[0]
      DisplayEstimate(keyword_template % (keyword['text'],
                                          keyword['matchType']),
                      keyword_estimate['min'], keyword_estimate['max'])
    

PHP

// Display results.
$platformEstimates = $result->campaignEstimates[0]->platformEstimates;
if ($platformEstimates !== null) {
  foreach ($platformEstimates as $platformEstimate) {
    if ($platformEstimate->minEstimate !== null
        && $platformEstimate->maxEstimate !== null) {
      printf(
          "Results for the platform with ID %d and name '%s':\n",
          $platformEstimate->platform->id,
          $platformEstimate->platform->platformName
      );
      printMeanEstimate($platformEstimate->minEstimate,
          $platformEstimate->maxEstimate);
    }
  }
}

$keywordEstimates =
    $result->campaignEstimates[0]->adGroupEstimates[0]->keywordEstimates;
for ($i = 0; $i < sizeof($keywordEstimates); $i++) {
  $keywordEstimateRequest = $keywordEstimateRequests[$i];
  // Skip negative keywords, since they don't return estimates.
  if (!$keywordEstimateRequest->isNegative) {
    $keyword = $keywordEstimateRequest->keyword;
    $keywordEstimate = $keywordEstimates[$i];

    if ($keywordEstimate->min !== null && $keywordEstimate->max !== null) {
      // Print the mean of the min and max values.
      printf("Results for the keyword with text '%s' and match type '%s':\n",
          $keyword->text, $keyword->matchType);
      printMeanEstimate($keywordEstimate->min, $keywordEstimate->max);
    }
  }
}
    

Perl

# Display traffic estimates.
if ($result) {
  my $campaign_estimates = $result->get_campaignEstimates();
  if ($campaign_estimates) {
    # Display the campaign level estimates segmented by platform.
    foreach my $campaign_estimate (@{$campaign_estimates}) {
      if ($campaign_estimate->get_platformEstimates()) {
        foreach
          my $platform_estimate (@{$campaign_estimate->get_platformEstimates()})
        {
          my $platform_message = sprintf(
            "Results for the platform with ID: %d and name : %s",
            $platform_estimate->get_platform()->get_id(),
            $platform_estimate->get_platform()->get_platformName());
          display_mean_estimates(
            $platform_message,
            $platform_estimate->get_minEstimate(),
            $platform_estimate->get_maxEstimate());
        }
      }

      if ($campaign_estimate->get_adGroupEstimates()) {
        my $keyword_estimates =
          $campaign_estimate->get_adGroupEstimates()->[0]
          ->get_keywordEstimates();
        for (my $i = 0 ; $i < scalar(@{$keyword_estimates}) ; $i++) {
          # Negative keywords don't generate estimates but instead affect
          # estimates of your other keywords, the following condition just
          # skips printing out estimates for a negative keyword.
          if ($keyword_estimate_requests[$i]->get_isNegative()) {
            next;
          }

          my $keyword = $keyword_estimate_requests[$i]->get_keyword();
          my $keyword_estimate = $keyword_estimates->[$i];
          my $keyword_message =
            sprintf
            "Results for the keyword with text '%s' and match type '%s':\n",
            $keyword->get_text(), $keyword->get_matchType();
          display_mean_estimates(
            $keyword_message,
            $keyword_estimate->get_min(),
            $keyword_estimate->get_max());
        }
      }
    }
  }
    

Ruby

# Display traffic estimates.
if response and response[:campaign_estimates] and
    response[:campaign_estimates].size > 0
  campaign_estimate = response[:campaign_estimates].first

  unless campaign_estimate[:platform_estimates].nil?
    # Display the campaign level estimates segmented by platform.
    campaign_estimate[:platform_estimates].each do |platform_estimate|
      platform_message = ('Results for the platform with ID %d and name ' +
          '"%s":') % [platform_estimate[:platform][:id],
          platform_estimate[:platform][:platform_name]]
      display_mean_estimates(
          platform_message,
          platform_estimate[:min_estimate],
          platform_estimate[:max_estimate]
      )
    end
  end

  # Display the keyword estimates.
  keyword_estimates =
      campaign_estimate[:ad_group_estimates].first[:keyword_estimates]
  keyword_estimates.each_with_index do |keyword_estimate, index|
    next if keyword_requests[index][:is_negative]
    keyword = keyword_requests[index][:keyword]

    keyword_message = ('Results for the keyword with text "%s" and match ' +
        'type "%s":') % [keyword[:text], keyword[:match_type]]
    display_mean_estimates(
        keyword_message,
        keyword_estimate[:min],
        keyword_estimate[:max]
    )
  end
else
  puts 'No traffic estimates were returned.'
end
    

O objeto de resultado mais importante e interessante é o KeywordEstimate correspondente no AdGroupEstimate. Ele contém o limite inferior (min) e o superior (max) da estimativa de tráfego (StatsEstimate) para cada palavra-chave.

Lembre-se de que os valores retornados são estimativas, não uma garantia de que o desempenho real estará dentro desses limites.

Como calcular o valor da estimativa do total de conversões

A API não fornece diretamente um valor da estimativa do total de conversões como o Planejador de palavras-chave faz, mas é possível calculá-lo com base nas estatísticas fornecidas:

Estimated total conversions = Estimated clicks * Historical conversion rate
Estimated total conversion value = Estimated total conversions * Conversion value

Mapeamento para o Planejador de palavras-chave

É possível usar o TrafficEstimatorService da mesma maneira que você usa o recurso Receber previsões de desempenho de cliques e custos do Planejador de palavras-chave do Google AdWords.

Para usar o TrafficEstimatorService com essa finalidade, você precisa especificar uma campanha pré-existente ou criar uma campanha simulada completa, com grupos de anúncios e palavras-chave:

Planejador de palavras-chave Google AdWords API
Inserir palavras-chave KeywordEstimateRequest
Segmentação – Local Use o critério de local em CampaignEstimateRequest.criteria
Segmentação – Idioma Use o critério de idioma em CampaignEstimateRequest.criteria
Segmentação – Rede CampaignEstimateRequest.networkSetting
Período Não suportado

No Planejador de palavras-chave, você pode especificar um orçamento diário e um valor de lance. Na AdWords API, um dailyBudget é parte do CampaignEstimateRequest e o valor do lance, chamado maxCpc, pode ser definido no AdGroupEstimateRequest ou no KeywordEstimateRequest. Esses valores precisam ser especificados no momento da solicitação. Assim, ainda que eles estejam na tela Resultados do Planejador de palavras-chave, ao usar a API, eles precisam ser incluídos como parte da solicitação.

Exemplos de códigos completos

Cada biblioteca cliente contém um exemplo de código completo na pasta Otimização:

Enviar comentários sobre…

Precisa de ajuda? Acesse nossa página de suporte.