Gebotsübersichten

Mit Gebotsübersichten lassen sich Daten zur geschätzten Leistung Ihrer Anzeigengruppen, Kriterien und Kampagnen ermitteln. Diese Informationen ermöglichen es Ihnen, Ihre Gebotsstrategie anzupassen und zu optimieren.

Mit den Gebotsübersichten der API wird simuliert, wie sich eine Änderung von Geboten auf Kosten, Impressionen und Klicks auswirkt. Dies erfolgt analog zu Gebotssimulatoren in der AdWords-Benutzeroberfläche.

Anwendungsfall

Angenommen, eine Ihrer Anzeigen wird bereits seit einigen Wochen ausgeliefert und hat eine Menge Geld gekostet – viel mehr, als Sie erwartet hatten oder ausgeben wollten.

Nun wollen Sie testen, was passieren würde, wenn Sie Ihre Gebote ein wenig senken. Wie viel weniger Aufrufe und Klicks würden Sie erzielen? Wie viel weniger würde das kosten? Vielleicht erzielt Ihre Anzeige aber auch nicht die erwarteten Impressionen und Klicks und Sie wollen die Gebote entsprechend optimieren?

In solchen Fällen sind Gebotsübersichten hilfreich. Eine Gebotsübersicht enthält die erwarteten Aufrufe, Klicks und Kosten für einen Zeitraum, in dem Ihre Anzeige bereits präsentiert wurde.

Mit Gebotsübersichten können Sie Leistungsstatistiken zur vergangenen Woche mit dem aktuellen Gebotsniveau abrufen. Gleichzeitig sehen Sie, welche Ergebnisse Sie wahrscheinlich im selben Zeitraum mit anderen Geboten erreicht hätten.

Indem Sie analysieren, welche Leistung Ihre Anzeigen in der Vergangenheit hätten erzielen können, lässt sich eine fundierte Entscheidung darüber treffen, wie Ihre Gebote und Gebotsanpassungen auf Kampagnenebene künftig angepasst werden sollten.

Anforderungen

Zur Nutzung von Gebotsübersichten muss die Kampagne die folgenden Anforderungen erfüllen:

  • Sie benötigen ein festes Kriterium sowie eine vorhandene Anzeigengruppe oder eine Kampagne, damit grundlegende Informationen für die Schätzung vorhanden sind.
  • Das Conversion-Tracking muss aktiviert sein.
  • Ihr Konto darf kein Testkonto sein. Gebotsübersichten basieren auf einer zurückliegenden Leistung, da über Testkonten keine Anzeigen ausgeliefert werden.

Gebotsübersichten sind zudem für Kampagnen vom Typ "Nur Suchnetzwerk" und "Nur Displaynetzwerk" sowie für Shopping-Kampagnen verfügbar. Bei Kampagnen vom Typ "Suchnetzwerk mit Displaynetzwerk-Auswahl" werden nur Daten zurückgegeben, die sich auf den Suchnetzwerk-Anteil der relevanten Kampagne beziehen.

Anfragen senden

Bei der Abfrage von Gebotsübersichtsdaten gibt der API-Dienst ein BidLandscape-Objekt mit Informationen zum Zeitraum, zur Kampagne, zur Anzeigengruppe oder zum Kriterium zurück. Die Informationen richten sich danach, welche Daten angefordert werden. Der Zeitraum liegt immer in der Vergangenheit, weil berechnet wird, welche Leistung Ihre Anzeigen im selben Zeitraum unter denselben Bedingungen mit einem anderen Gebot oder einer anderen Gebotsanpassung auf Kampagnenebene erzielt hätten.

Die BidLandscape enthält auch eine Folge von Übersichtspunkten, die zusammen ein Histogramm der prognostizierten Leistung mit unterschiedlichen Geboten oder mobilspezifischen Gebotsanpassungen auf Kampagnenebene in diesem Zeitraum ergeben.

Mithilfe von DataService können Sie drei Arten von Übersichten für Gebote oder mobilspezifische Gebotsanpassungen anfordern. Welche Sie auswählen, hängt von der Ebene ab, auf der Sie Gebote anpassen möchten: Kriterium, Anzeigengruppe oder Kampagne. Die Methoden get() und query() sind entsprechend benannt.

Gebotsübersichten für Kriterien und Anzeigengruppen abrufen

Im Beispiel unten wird angenommen, dass Gebote auf Kriteriumsebene festgelegt werden. Die Vorgehensweise zum Abrufen von Gebotsübersichten für Anzeigengruppen ist sehr ähnlich.

Das Abrufen von Gebotsübersichten funktioniert ähnlich wie eine normale Anfrage: Sie wählen die gewünschten Felder aus, legen die Prädikate fest, mit denen die Anzeigengruppen, Kriterien usw. eingeschränkt werden sollen, und führen dann einen get()- oder query()-Aufruf durch, um die Daten abzurufen.

In der Referenzdokumentation zu BidLandscape und LandscapePoint werden alle gültigen filterbaren und auswählbaren Felder aufgeführt.

Es spielt keine Rolle, ob sich das Feld in BidLandscape oder LandscapePoint befindet. Sie nehmen es in denselben Selektor oder in dasselbe Prädikat auf. Die Felder BidModifier, TotalLocalClicks, TotalLocalCost, TotalLocalImpressions und RequiredBudget werden nur für Anfragen von Gebotsübersichten für mobilspezifische Gebotsanpassungen auf Kampagnenebene unterstützt, während BiddableConversions und BiddableConversionsValue nur für Anzeigengruppen- und Kriterienübersicht-Anfragen unterstützt werden. Liegen die Daten vor, werden die Felder automatisch an der entsprechenden Stelle in den SOAP- und Clientbibliotheken platziert. Felder an den LandscapePoints werden für jeden in BidLandscape zurückgegebenen LandscapePoint ausgefüllt.

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

C#

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)

Gebotsübersichten zu mobilspezifischen Gebotsanpassungen für Kampagnen abrufen

Gebotsübersichten zu mobilspezifischen Gebotsanpassungen auf Kampagnenebene können ähnlich wie Gebote auf Anzeigengruppen- oder Kriteriumsebene abgerufen werden. Felder an den LandscapePoints werden für jeden in BidLandscape zurückgegebenen LandscapePoint ausgefüllt. In der Referenzdokumentation zu BidLandscape und LandscapePoint werden alle filterbaren und auswählbaren Felder aufgeführt. Es spielt keine Rolle, ob sich das Feld in BidLandscape oder LandscapePoint befindet. Sie nehmen es in denselben Selektor oder in dasselbe Prädikat auf.

Im folgenden Beispiel wird gezeigt, wie Sie Gebotsübersichten für mobilspezifische Gebotsanpassungen auf Kampagnenebene abrufen:

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

C#

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

Ergebnisse ansehen

CriterionBidLandscapePage (von [get|query]CriterionBidLandscape und [get|query]CampaignCriterionBidLandscape zurückgegeben) und AdGroupBidLandscapePage (von [get|query]AdGroupBidLandscape zurückgegeben) verhalten sich anders als andere Seitentypen. Statt paging.startIndex zu erhöhen und Anforderungen zu senden, bis sich paging.startIndex >= page.totalNumEntries ergibt, müssen Sie bei der Anfrage einer Gebotsübersicht Folgendes tun:

  • paging.startIndex um die Anzahl der in jeder Antwort gefundenen inneren Übersichtspunkte erhöhen
  • Anfragen senden, bis die Anzahl der in der letzten Antwort gefundenen inneren Übersichtspunkte kleiner als der im Selektor angegebene Wert für paging.numberResults (Seitengröße) ist

Das folgende Beispiel zeigt, wie Sie diese Logik implementieren könnten:

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

C#

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)

Ergebnisse auswerten

In den Ergebnissen sind verschiedene Gebote und die jeweils erwartete Leistung enthalten. Hier sehen Sie das Beispiel einer XML-Antwort auf eine Anfrage:

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

Alle Elemente, die von LandscapePoints zurückgegeben werden können, sind oben aufgeführt. Der Wert promotedImpressions gibt an, wie oft es zu einer Impression an einer exponierten Position (also oben) auf der Suchseite kam.

Das XML-Snippet von oben stellt einen LandscapePoint dar, allerdings enthält BidLandscape eine Folge dieser Punkte. Jeder von diesen weist einen anderen Gebotsbetrag oder eine andere mobilspezifische Gebotsanpassung mit entsprechenden Statistiken auf, in der das geänderte Gebot oder die geänderte Gebotsanpassung berücksichtigt wird. Die Interpretation der Ergebnisse ist Ihnen überlassen. Mit den bereitgestellten Daten sollten Sie jedoch bestimmen können, wie sich eine Optimierung von Geboten und mobilspezifischen Gebotsanpassungen auf die Leistung auswirken könnte.

Ressourcen

Codebeispiele

Jede Clientbibliothek enthält im Ordner Optimierung vollständige Codebeispiele zum Abrufen von Simulationen für Gebotsanpassungen für Keywords und Kampagnen:

Feedback geben zu...