Cenários do lance

Com os cenários do lance, é possível estimar o desempenho dos seus grupos de anúncios, critérios e campanhas usando diferentes situações de lances. Você pode utilizar essas informações para ajustar e otimizar sua estratégia de lance.

Os serviços de cenário do lance da API estimam como a alteração do seu lance de diversas maneiras afeta o custo, as impressões e os cliques. Isso é análogo aos Simuladores de lances na interface do usuário do Google AdWords.

Caso de uso

Digamos que você tenha um anúncio em exibição há algumas semanas, e ele esteja custando muito mais do que o esperado ou desejado.

Você deseja testar o que aconteceria se reduzisse seus lances. Quantas visualizações e cliques a menos seu anúncio receberia? Qual seria a diferença de preço? Por outro lado, e se seu anúncio não estivesse gerando o número esperado de impressões e cliques, e você quisesse saber como definir seus lances para corrigir isso?

Os cenários do lance ajudarão você a pesquisar essas situações. Quando você busca um cenário do lance, são exibidas estimativas de visualizações, cliques e custo para o mesmo período em que seu anúncio estava em exibição.

Com os cenários do lance, é possível examinar as estatísticas de desempenho da semana anterior no nível atual de lance, além do desempenho simulado para o mesmo período usando diferentes valores de lance.

Ao analisar as possíveis diferenças no desempenho dos seus anúncios no passado, você pode tomar decisões mais fundamentadas sobre como ajustar seus lances e modificadores de lance no nível da campanha futuramente.

Requisitos

Para usar os cenários do lance, a campanha precisa atender aos seguintes requisitos:

  • Você precisa ter um grupo de anúncios, uma campanha ou um critério estabelecido para fornecer informações de base ao sistema, a partir das quais as previsões serão geradas.
  • O acompanhamento de conversões precisa estar ativado.
  • A conta não pode ser de teste. Os cenários do lance têm como base o desempenho anterior. Como as contas de teste não veiculam anúncios, elas não possuem histórico de desempenho.

Além disso, os cenários do lance funcionam com campanhas apenas na rede de pesquisa, apenas na Rede de Display e do Shopping. Para a Rede de pesquisa com exibição em Display, somente as informações pertencentes à parte da rede de pesquisa de uma campanha são retornadas.

Como fazer uma solicitação

Ao recuperar dados do cenário do lance, o serviço da API retorna um objeto BidLandscape com informações sobre o período, a campanha, o grupo de anúncios ou o critério em que os dados se baseiam. O período sempre terá como base uma data anterior, já que os cenários do lance estimam o desempenho dos seus anúncios nesse período e sob as mesmas condições. Porém, são utilizados diferentes modificadores de lance no nível da campanha ou do lance.

O objeto BidLandscape também inclui uma sequência de pontos de cenário que, combinados, oferecem um histograma do desempenho previsto com diferentes lances ou modificadores de lance para celular no nível da campanha durante esse período.

Você pode solicitar três tipos de cenário de lances e modificadores de lance para celular pelo DataService. O cenário escolhido dependerá do nível em que você deseja ajustar os lances: do critério, do grupo de anúncios ou da campanha. Os métodos get() ou query() são nomeados conforme o nível:

Como buscar critérios e grupos de anúncios nos cenários do lance

No exemplo abaixo, suponha que os lances estejam definidos no nível de um critério. O processo de busca por cenários do lance para grupos de anúncios é semelhante.

A busca por cenários do lance é semelhante a qualquer outra consulta: selecione os campos desejados, configure os predicados para restringir a consulta somente aos grupos de anúncios ou critérios convenientes e faça a chamada get() ou query() para buscar os dados.

A documentação de referência de BidLandscape e LandscapePoint lista todos os campos válidos que podem ser filtrados e selecionados.

Independentemente de o campo do seu interesse estar em BidLandscape ou LandscapePoint, inclua-o no mesmo seletor ou predicado. Os campos BidModifier, TotalLocalClicks, TotalLocalCost, TotalLocalImpressions e RequiredBudget são aceitos apenas para solicitação de cenário de modificador de lance para celular nas campanhas, em que BiddableConversions e BiddableConversionsValue são aceitos apenas para solicitação de cenário de critério e grupo de anúncios. Quando os dados são retornados, os campos são inseridos automaticamente no local adequado no SOAP e nas implementações da biblioteca cliente. Os campos de LandscapePoints serão preenchidos para cada LandscapePoint que for retornado em BidLandscape.

Java

// Get the DataService.
DataServiceInterface dataService = adWordsServices.get(session, DataServiceInterface.class);

// Create selector.
Selector selector =
    new SelectorBuilder()
        .fields(
            DataField.AdGroupId,
            DataField.CriterionId,
            DataField.StartDate,
            DataField.EndDate,
            DataField.Bid,
            DataField.BiddableConversions,
            DataField.BiddableConversionsValue,
            DataField.LocalClicks,
            DataField.LocalCost,
            DataField.LocalImpressions)
        .equals(DataField.AdGroupId, adGroupId.toString())
        .equals(DataField.CriterionId, criterionId.toString())
        .limit(PAGE_SIZE)
        .build();

CriterionBidLandscapePage page = dataService.getCriterionBidLandscape(selector);

CSharp

using (DataService dataService = (DataService) user.GetService(
    AdWordsService.v201802.DataService)) {

  // Create the selector.
  Selector selector = new Selector() {
    fields = new string[] {
      CriterionBidLandscape.Fields.AdGroupId, CriterionBidLandscape.Fields.CriterionId,
      CriterionBidLandscape.Fields.StartDate, CriterionBidLandscape.Fields.EndDate,
      BidLandscapeLandscapePoint.Fields.Bid, BidLandscapeLandscapePoint.Fields.LocalClicks,
      BidLandscapeLandscapePoint.Fields.LocalCost,
      BidLandscapeLandscapePoint.Fields.LocalImpressions,
      BidLandscapeLandscapePoint.Fields.BiddableConversions,
      BidLandscapeLandscapePoint.Fields.BiddableConversionsValue
    },
    predicates = new Predicate[] {
      Predicate.Equals(CriterionBidLandscape.Fields.AdGroupId, adGroupId),
      Predicate.Equals(CriterionBidLandscape.Fields.CriterionId, keywordId)
    },
    paging = Paging.Default
  };

page = dataService.getCriterionBidLandscape(selector);

Python

data_service = client.GetService('DataService', version='v201802')

# Construct bid landscape selector object and retrieve bid landscape.
selector = {
    'fields': ['AdGroupId', 'CriterionId', 'StartDate', 'EndDate', 'Bid',
               'BiddableConversions', 'BiddableConversionsValue',
               'LocalClicks', 'LocalCost', 'LocalImpressions'],
    'predicates': [
        {
            'field': 'AdGroupId',
            'operator': 'EQUALS',
            'values': [ad_group_id]
        },
        {
            'field': 'CriterionId',
            'operator': 'EQUALS',
            'values': [criterion_id]
        }
    ],
    'paging': {
        'startIndex': 0,
        'numberResults': PAGE_SIZE
    }
}

page = data_service.getCriterionBidLandscape(selector)

PHP

$dataService = $adWordsServices->get($session, DataService::class);

// Create a selector to select all keyword bid simulations for the
// specified ad group.
$selector = new Selector();
$selector->setFields(
    [
        'AdGroupId',
        'CriterionId',
        'StartDate',
        'EndDate',
        'Bid',
        'BiddableConversions',
        'BiddableConversionsValue',
        'LocalClicks',
        'LocalCost',
        'LocalImpressions'
    ]
);
$selector->setPredicates(
    [
        new Predicate('AdGroupId', PredicateOperator::IN, [$adGroupId])
    ]
);
$selector->setPaging(new Paging(0, self::PAGE_SIZE));

$page = $dataService->getCriterionBidLandscape($selector);

Perl

# Create predicates.
my $adgroup_predicate = Google::Ads::AdWords::v201802::Predicate->new({
    field    => "AdGroupId",
    operator => "IN",
    values   => [$ad_group_id]});
my $criterion_predicate = Google::Ads::AdWords::v201802::Predicate->new({
    field    => "CriterionId",
    operator => "IN",
    values   => [$keyword_id]});

# Create selector.
my $paging = Google::Ads::AdWords::v201802::Paging->new({
  startIndex    => 0,
  numberResults => PAGE_SIZE
});
my $selector = Google::Ads::AdWords::v201802::Selector->new({
    fields => [
      "AdGroupId",                "CriterionId",
      "StartDate",                "EndDate",
      "Bid",                      "BiddableConversions",
      "BiddableConversionsValue", "LocalClicks",
      "LocalCost",                "LocalImpressions"
    ],
    paging     => $paging,
    predicates => [$adgroup_predicate, $criterion_predicate]});

my $page =
  $client->DataService()
  ->getCampaignCriterionBidLandscape({serviceSelector => $selector});

Ruby

data_srv = adwords.service(:DataService, API_VERSION)

# Get keyword bid landscape.
selector = {
  :fields => ['AdGroupId', 'CriterionId', 'StartDate', 'EndDate', 'Bid',
      'BiddableConversions', 'BiddableConversionsValue', 'LocalClicks',
      'LocalCost', 'LocalImpressions'],
  :predicates => [
    {:field => 'AdGroupId', :operator => 'IN', :values => [ad_group_id]},
    {:field => 'CriterionId', :operator => 'IN', :values => [keyword_id]},
  ],
  :paging => {
    :start_index => 0,
    :number_results => PAGE_SIZE
  }
}

page = data_srv.get_criterion_bid_landscape(selector)

VB.NET

Using dataService As DataService = CType(user.GetService(
    AdWordsService.v201802.DataService), DataService)

  ' Create the selector.
  Dim selector As New Selector
  selector.fields = New String() {
    CriterionBidLandscape.Fields.AdGroupId, CriterionBidLandscape.Fields.CriterionId,
    CriterionBidLandscape.Fields.StartDate, CriterionBidLandscape.Fields.EndDate,
    BidLandscapeLandscapePoint.Fields.Bid, BidLandscapeLandscapePoint.Fields.LocalClicks,
    BidLandscapeLandscapePoint.Fields.LocalCost,
    BidLandscapeLandscapePoint.Fields.LocalImpressions,
    BidLandscapeLandscapePoint.Fields.BiddableConversions,
    BidLandscapeLandscapePoint.Fields.BiddableConversionsValue
  }

  selector.predicates = New Predicate() {
    Predicate.Equals(CriterionBidLandscape.Fields.AdGroupId, adGroupId),
    Predicate.Equals(CriterionBidLandscape.Fields.CriterionId, keywordId)
  }

  ' Select selector paging.
  selector.paging = Paging.Default

page = dataService.getCriterionBidLandscape(selector)

Como buscar cenários do modificador de lance para celular nas campanhas

A busca por cenários do modificador de lance para celular no nível da campanha é semelhante à busca por lances no nível do grupo de anúncios ou do critério. Os campos de LandscapePoints serão preenchidos para cada LandscapePoint que for retornado em BidLandscape. Consulte a documentação de referência de BidLandscape e LandscapePoint para ver quais campos podem ser selecionados e filtrados. Independentemente de o campo estar em BidLandscape ou LandscapePoint, você deve inclui-lo no mesmo seletor ou predicado.

Este exemplo mostra como buscar cenários do modificador de lance para celular no nível da campanha:

Java

// Get the DataService.
DataServiceInterface dataService = adWordsServices.get(session, DataServiceInterface.class);

// Create selector.
Selector selector =
    new SelectorBuilder()
        .fields(
            DataField.BidModifier,
            DataField.CampaignId,
            DataField.CriterionId,
            DataField.StartDate,
            DataField.EndDate,
            DataField.LocalClicks,
            DataField.LocalCost,
            DataField.LocalImpressions,
            DataField.TotalLocalClicks,
            DataField.TotalLocalCost,
            DataField.TotalLocalImpressions,
            DataField.RequiredBudget)
        .equals(DataField.CampaignId, campaignId.toString())
        .limit(PAGE_SIZE)
        .build();

CriterionBidLandscapePage page = dataService.getCampaignCriterionBidLandscape(selector);

CSharp

using (DataService dataService = (DataService) user.GetService(
    AdWordsService.v201802.DataService)) {

  // Create selector.
  Selector selector = new Selector() {
    fields = new string[] {
      CriterionBidLandscape.Fields.CampaignId,
      CriterionBidLandscape.Fields.CriterionId,
      CriterionBidLandscape.Fields.StartDate,
      CriterionBidLandscape.Fields.EndDate,
      BidLandscapeLandscapePoint.Fields.LocalClicks,
      BidLandscapeLandscapePoint.Fields.LocalCost,
      BidLandscapeLandscapePoint.Fields.LocalImpressions,
      BidLandscapeLandscapePoint.Fields.TotalLocalClicks,
      BidLandscapeLandscapePoint.Fields.TotalLocalCost,
      BidLandscapeLandscapePoint.Fields.TotalLocalImpressions,
      BidLandscapeLandscapePoint.Fields.RequiredBudget,
      BidLandscapeLandscapePoint.Fields.BidModifier,
    },
    predicates = new Predicate[] {
      Predicate.Equals(CriterionBidLandscape.Fields.CampaignId, campaignId)
    },
    paging = Paging.Default
  };

Python

data_service = client.GetService('DataService', version='v201802')

# Get all the campaigns for this account.
selector = {
    'fields': ['CampaignId', 'CriterionId', 'StartDate', 'EndDate',
               'BidModifier', 'LocalClicks', 'LocalCost', 'LocalImpressions',
               'TotalLocalClicks', 'TotalLocalCost', 'TotalLocalImpressions',
               'RequiredBudget'],
    'paging': {
        'startIndex': 0,
        'numberResults': PAGE_SIZE
    },
    'predicates': [{
        'field': 'CampaignId', 'operator': 'IN', 'values': [campaign_id]
    }]
}

PHP

$dataService = $adWordsServices->get($session, DataService::class);

// Create a selector to select all campaign criterion bid modifiers for the
// specified campaign.
$selector = new Selector();
$selector->setFields(
    [
        'BidModifier',
        'CampaignId',
        'CriterionId',
        'StartDate',
        'EndDate',
        'LocalClicks',
        'LocalCost',
        'LocalImpressions',
        'TotalLocalClicks',
        'TotalLocalCost',
        'TotalLocalImpressions',
        'RequiredBudget'
    ]
);
$selector->setPredicates(
    [new Predicate('CampaignId', PredicateOperator::IN, [$campaignId])]
);
$selector->setPaging(new Paging(0, self::PAGE_SIZE));

Perl

# Create predicates.
my $campaign_predicate = Google::Ads::AdWords::v201802::Predicate->new({
    field    => "CampaignId",
    operator => "IN",
    values   => [$campaign_id]});
# Create selector.
my $paging = Google::Ads::AdWords::v201802::Paging->new({
  startIndex    => 0,
  numberResults => PAGE_SIZE
});
my $selector = Google::Ads::AdWords::v201802::Selector->new({
    fields => [
      "BidModifier",           "CampaignId",
      "CriterionId",           "StartDate",
      "EndDate",               "LocalClicks",
      "LocalCost",             "LocalImpressions",
      "TotalLocalClicks",      "TotalLocalCost",
      "TotalLocalImpressions", "RequiredBudget"
    ],
    paging     => $paging,
    predicates => [$campaign_predicate]});

Ruby

data_srv = adwords.service(:DataService, API_VERSION)

selector = {
  :fields => [
    'CampaignId',
    'CriterionId',
    'StartDate',
    'EndDate',
    'BidModifier',
    'LocalClicks',
    'LocalCost',
    'LocalImpressions',
    'TotalLocalImpressions',
    'TotalLocalClicks',
    'TotalLocalCost',
    'RequiredBudget'
  ],
  :predicates => [
    {:field => 'CampaignId', :operator => 'IN', :values => [campaign_id]}
  ],
  :paging => {
    :start_index => 0,
    :number_results => PAGE_SIZE
  }
}

VB.NET

Using dataService As DataService = CType(user.GetService(AdWordsService.v201802.DataService),
    DataService)

  ' Create selector.
  Dim selector As New Selector()
  selector.fields = New String() {
    CriterionBidLandscape.Fields.CampaignId,
    CriterionBidLandscape.Fields.CriterionId,
    CriterionBidLandscape.Fields.StartDate,
    CriterionBidLandscape.Fields.EndDate,
    BidLandscapeLandscapePoint.Fields.LocalClicks,
    BidLandscapeLandscapePoint.Fields.LocalCost,
    BidLandscapeLandscapePoint.Fields.LocalImpressions,
    BidLandscapeLandscapePoint.Fields.TotalLocalClicks,
    BidLandscapeLandscapePoint.Fields.TotalLocalCost,
    BidLandscapeLandscapePoint.Fields.TotalLocalImpressions,
    BidLandscapeLandscapePoint.Fields.RequiredBudget,
    BidLandscapeLandscapePoint.Fields.BidModifier
  }
  selector.predicates = New Predicate() {
    Predicate.Equals(CriterionBidLandscape.Fields.CampaignId, campaignId)
  }
  selector.paging = Paging.Default

Paginação de resultados

O comportamento de CriterionBidLandscapePage (retornado por [get|query]CriterionBidLandscape e [get|query]CampaignCriterionBidLandscape) e AdGroupBidLandscapePage (retornado por [get|query]AdGroupBidLandscape) é diferente de outros tipos de página. Em vez de incrementar paging.startIndex e fazer solicitações até paging.startIndex >= page.totalNumEntries, no caso de uma solicitação de cenário do lance, é necessário:

  • incrementar paging.startIndex pelo número de pontos de cenário internos encontrados em cada resposta;
  • continuar fazendo solicitações até que o número de pontos de cenário internos encontrados na última resposta seja menor que o paging.numberResults (tamanho da página) especificado no seu seletor.

O exemplo abaixo demonstra como você pode implementar essa lógica.

Java

// Display bid landscapes.
int landscapePointsInPreviousPage = 0;
int startIndex = 0;
do {
  // Offset the start index by the number of landscape points in the last retrieved page,
  // NOT the number of entries (bid landscapes) in the page.
  startIndex += landscapePointsInPreviousPage;
  selector.getPaging().setStartIndex(startIndex);

  // Reset the count of landscape points in preparation for processing the next page.
  landscapePointsInPreviousPage = 0;

  // Request the next page of bid landscapes.
  CriterionBidLandscapePage page = dataService.getCriterionBidLandscape(selector);

  if (page.getEntries() != null) {
    for (CriterionBidLandscape criterionBidLandscape : page.getEntries()) {
      System.out.printf(
          "Criterion bid landscape with ad group ID %d, criterion ID %d, "
              + "start date %s, end date %s, with landscape points:%n",
          criterionBidLandscape.getAdGroupId(),
          criterionBidLandscape.getCriterionId(),
          criterionBidLandscape.getStartDate(),
          criterionBidLandscape.getEndDate());

      for (BidLandscapeLandscapePoint bidLanscapePoint :
          criterionBidLandscape.getLandscapePoints()) {
        landscapePointsInPreviousPage++;
        System.out.printf(
            "\t{bid: %d clicks: %d cost: %d impressions: %d, biddable conversions: %.2f, "
                + "biddable conversions value: %.2f}%n",
            bidLanscapePoint.getBid().getMicroAmount(),
            bidLanscapePoint.getClicks(),
            bidLanscapePoint.getCost().getMicroAmount(),
            bidLanscapePoint.getImpressions(),
            bidLanscapePoint.getBiddableConversions(),
            bidLanscapePoint.getBiddableConversionsValue());
      }
      System.out.println(" was found.");
    }
  }
} while (landscapePointsInPreviousPage >= PAGE_SIZE);

CSharp

CriterionBidLandscapePage page = new CriterionBidLandscapePage();
int landscapePointsFound = 0;
int landscapePointsInLastResponse = 0;

try {
  do {
    // Get bid landscape for keywords.
    page = dataService.getCriterionBidLandscape(selector);
    landscapePointsInLastResponse = 0;

    // Display bid landscapes.
    if (page != null && page.entries != null) {
      foreach (CriterionBidLandscape bidLandscape in page.entries) {
        Console.WriteLine("Found criterion bid landscape with ad group id '{0}', " +
            "keyword id '{1}', start date '{2}', end date '{3}', and landscape points:",
            bidLandscape.adGroupId, bidLandscape.criterionId,
            bidLandscape.startDate, bidLandscape.endDate);
        foreach (BidLandscapeLandscapePoint bidLandscapePoint in
            bidLandscape.landscapePoints) {
          Console.WriteLine("- bid: {0} => clicks: {1}, cost: {2}, impressions: {3}, " +
              "biddable conversions: {4:0.00}, biddable conversions value:{5:0.00}",
              bidLandscapePoint.bid.microAmount, bidLandscapePoint.clicks,
              bidLandscapePoint.cost.microAmount, bidLandscapePoint.impressions,
              bidLandscapePoint.biddableConversions,
              bidLandscapePoint.biddableConversionsValue);
          landscapePointsInLastResponse++;
          landscapePointsFound++;
        }
      }
    }
    // Offset by the number of landscape points, NOT the number
    // of entries (bid landscapes) in the last response.
    selector.paging.IncreaseOffsetBy(landscapePointsInLastResponse);
  } while (landscapePointsInLastResponse > 0);

Python

while more_pages:
  num_landscape_points = 0
  page = data_service.getCriterionBidLandscape(selector)

  if page and 'entries' in page:
    entries = page['entries']
    print 'Bid landscape(s) retrieved: %d.' % len(entries)

    for bid_landscape in entries:
      print ('Retrieved keyword bid landscape with ad group ID "%d", '
             'keyword ID "%d", start date "%s", end date "%s", '
             'with landscape points:' % (
                 bid_landscape['adGroupId'], bid_landscape['criterionId'],
                 bid_landscape['startDate'], bid_landscape['endDate']))
      for bid_landscape_point in bid_landscape['landscapePoints']:
        num_landscape_points += 1
        print ('  bid: %s => clicks: %s, cost: %s, impressions: %s, '
               'biddable conversions: %.2f, '
               'biddable conversions value: %.2f'
               % (bid_landscape_point['bid']['microAmount'],
                  bid_landscape_point['clicks'],
                  bid_landscape_point['cost']['microAmount'],
                  bid_landscape_point['impressions'],
                  bid_landscape_point['biddableConversions'],
                  bid_landscape_point['biddableConversionsValue']))

  # Need to increment by the total # of landscape points within the page,
  # NOT the number of entries (bid landscapes) in the page.
  offset += num_landscape_points
  selector['paging']['startIndex'] = str(offset)
  more_pages = num_landscape_points >= PAGE_SIZE

PHP

// Display bid landscapes.
$landscapePointsInPreviousPage = 0;
$startIndex = 0;
do {
    // Offset the start index by the number of landscape points in the last
    // retrieved page, NOT the number of entries (bid landscapes) in the page.
    $startIndex += $landscapePointsInPreviousPage;
    $selector->getPaging()->setStartIndex($startIndex);

    // Reset the count of landscape points in preparation for processing the
    // next page.
    $landscapePointsInPreviousPage = 0;

    // Retrieve keyword bid simulations one page at a time, continuing to
    // request pages until all of them have been retrieved.
    $page = $dataService->getCriterionBidLandscape($selector);

    // Print out some information for each bid landscape.
    if ($page->getEntries() !== null) {
        foreach ($page->getEntries() as $bidLandscape) {
            printf(
                "Found criterion bid landscape with ad group ID %d, criterion ID"
                . " %d, start date '%s', end date '%s', and landscape points:\n",
                $bidLandscape->getAdGroupId(),
                $bidLandscape->getCriterionId(),
                $bidLandscape->getStartDate(),
                $bidLandscape->getEndDate()
            );
            $landscapePointsInPreviousPage = count($bidLandscape->getLandscapePoints());
            foreach ($bidLandscape->getLandscapePoints() as $bidLandscapePoint) {
                printf(
                    "  bid: %d => clicks: %d, cost: %d, impressions: %d"
                    . ", biddable conversions: %.2f, biddable "
                    . "conversions value: %.2f\n",
                    $bidLandscapePoint->getBid()->getMicroAmount(),
                    $bidLandscapePoint->getClicks(),
                    $bidLandscapePoint->getCost()->getMicroAmount(),
                    $bidLandscapePoint->getImpressions(),
                    $bidLandscapePoint->getBiddableConversions(),
                    $bidLandscapePoint->getBiddableConversionsValue()
                );
            }
            print "\n";
        }
    }
} while ($landscapePointsInPreviousPage >= self::PAGE_SIZE);

Perl

# Display bid landscapes.
my $landscape_points_in_previous_page = 0;
my $start_index                       = 0;
do {
  # Offset the start index by the number of landscape points in the last
  # retrieved page, NOT the number of entries (bid landscapes) in the page.
  $start_index += $landscape_points_in_previous_page;
  $selector->get_paging()->set_startIndex($start_index);

  # Reset the count of landscape points in preparation for processing the
  # next page.
  $landscape_points_in_previous_page = 0;

  # Request the next page of bid landscapes.
  my $page =
    $client->DataService()
    ->getCampaignCriterionBidLandscape({serviceSelector => $selector});

  if ($page->get_entries()) {
    foreach my $criterion_bid_landscape (@{$page->get_entries()}) {
      printf "Criterion bid landscape with ad group ID %d, criterion ID " .
        " %d, start date %s, end date %s, with landscape points:\n",
        $criterion_bid_landscape->get_criterionId(),
        $criterion_bid_landscape->get_startDate(),
        $criterion_bid_landscape->get_endDate();
      foreach my $bid_landscape_point (
        @{$criterion_bid_landscape->get_landscapePoints()})
      {
        $landscape_points_in_previous_page++;
        printf "  bid: %d => clicks: %d, cost: %d, impressions: %d" .
          ", biddable conversions: %.2f, biddable " .
          "conversions value: %.2f\n",
          $bid_landscape_point->get_bid()->get_microAmount(),
          $bid_landscape_point->get_clicks(),
          $bid_landscape_point->get_cost()->get_microAmount(),
          $bid_landscape_point->get_impressions(),
          $bid_landscape_point->get_biddableConversions(),
          $bid_landscape_point->get_biddableConversionsValue();
      }
      printf(" was found.");
    }
  }
} while ($landscape_points_in_previous_page >= PAGE_SIZE);

Ruby

start_index = 0
landscape_points_in_previous_page = 0
begin
  # Offset the start index by the number of landscape points in the last
  # retrieved page, NOT the number of entries (bid landscapes) in the page.
  start_index += landscape_points_in_previous_page
  selector[:paging][:start_index] = start_index

  # Reset the count of landscape points in preparation for processing the
  # next page.
  landscape_points_in_previous_page = 0

  # Request the next page of bid landscapes.
  page = data_srv.get_criterion_bid_landscape(selector)

  if page and page[:entries]
    puts "Bid landscape(s) retrieved: %d." % [page[:entries].length]
    page[:entries].each do |bid_landscape|
      puts ("Retrieved keyword bid landscape with ad group ID %d" +
          ", keyword ID %d, start date '%s', end date '%s'" +
          ", with landscape points:") %
          [bid_landscape[:ad_group_id], bid_landscape[:criterion_id],
          bid_landscape[:start_date], bid_landscape[:end_date]]
      bid_landscape[:landscape_points].each do |point|
        landscape_points_in_previous_page += 1
        puts ("\t%d => clicks: %d, cost: %d, impressions: %d, biddable " +
            "conversions: %.2f, biddable conversions value: %.2f") %
            [point[:bid][:micro_amount], point[:clicks],
            point[:cost][:micro_amount], point[:impressions],
            point[:biddable_conversions], point[:biddable_conversions_value]]
      end
    end
  end
end while landscape_points_in_previous_page >= PAGE_SIZE

VB.NET

Dim page As New CriterionBidLandscapePage

Dim landscapePointsFound As Integer = 0
Dim landscapePointsInLastResponse As Integer = 0

Try
  Do
    ' Get bid landscape for keywords.
    page = dataService.getCriterionBidLandscape(selector)
    landscapePointsInLastResponse = 0

    ' Display bid landscapes.
    If ((Not page Is Nothing) AndAlso (Not page.entries Is Nothing)) Then
      Dim i As Integer = selector.paging.startIndex

      For Each bidLandscape As CriterionBidLandscape In page.entries
        Console.WriteLine("Found keyword bid landscape with ad group id ""{0}"", " &
            "keyword id ""{1}"", start date ""{2}"", end date ""{3}"", and " &
            "landscape points:", bidLandscape.adGroupId,
            bidLandscape.criterionId, bidLandscape.startDate, bidLandscape.endDate)
        For Each bidLandscapePoint As BidLandscapeLandscapePoint _
            In bidLandscape.landscapePoints
          Console.WriteLine("- bid: {0} => clicks: {1}, cost: {2}, impressions: {3}, " &
              "biddable conversions: {4:0.00}, biddable conversions value:{5:0.00}",
              bidLandscapePoint.bid.microAmount, bidLandscapePoint.clicks,
              bidLandscapePoint.cost.microAmount, bidLandscapePoint.impressions,
              bidLandscapePoint.biddableConversions,
              bidLandscapePoint.biddableConversionsValue)
          landscapePointsInLastResponse += 1
          landscapePointsFound += 1
        Next
      Next
    End If

    ' Offset by the number of landscape points, NOT the number
    ' of entries (bid landscapes) in the last response.
    selector.paging.IncreaseOffsetBy(landscapePointsInLastResponse)
  Loop While (landscapePointsInLastResponse > 0)

Como entender os resultados

Os resultados retornam vários lances e o desempenho esperado em cada nível. Veja um exemplo de uma possível resposta em XML para uma dessas solicitações.

<landscapePoints>
  <bid>
    <ComparableValue.Type>Money</ComparableValue.Type>
    <microAmount>990000</microAmount>
  </bid>
  <clicks>278000</clicks>
  <cost>
    <ComparableValue.Type>Money</ComparableValue.Type>
    <microAmount>14500000000</microAmount>
  </cost>
  <impressions>648000</impressions>
  <promotedImpressions>0</promotedImpressions>
</landscapePoints>

Todos os elementos que você pode receber dos LandscapePoints estão representados acima. O valor promotedImpressions indica quantas vezes a impressão estava em uma posição "promovida" na página de pesquisa, isto é, na parte superior dela.

O snippet em XML acima mostra um LandscapePoint. No entanto, cada BidLandscape terá uma sequência desses pontos com um valor diferente de lance ou modificador de lance para celular, além de estatísticas correspondentes ajustadas à conta para o lance ou modificador de lance alterado. Cabe a você interpretar os resultados. Porém, os dados fornecidos oferecerão informações úteis para determinar como os ajustes de lances e modificadores de lance para celular poderão afetar o desempenho.

Recursos

Exemplos de código

Cada biblioteca cliente contém exemplos de código completos para recuperar simulações de modificadores de lances de palavras-chave e campanhas na pasta Otimização:

Enviar comentários sobre…

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