Zugriffe schätzen

Vom Dienst TrafficEstimatorService der AdWords API werden Zugriffsschätzungen für vorgeschlagene oder bestehende Kampagnen, Anzeigengruppen und Keywords abgerufen. Beispiele:

  • Durchschnittlicher CPC
  • Durchschnittliche Position
  • Klickrate
  • Klicks pro Tag
  • Impressionen pro Tag
  • Gesamtkosten

Sie können vorgeschlagene Kampagnen und Anzeigengruppen simulieren, indem Sie unterschiedliche Kampagnenkriterien, Werbenetzwerkeinstellungen, Tagesbudgets und max. CPCs ändern.

Außerdem können Sie Zugriffsschätzungen für eine bestehende Kampagne oder Anzeigengruppe abrufen, indem Sie die entsprechende campaignId bzw. adGroupId angeben.

Anwendungsfall

Wenn Sie eine neue Kampagne oder Anzeigengruppe erstellen oder bestehende Kampagnen ändern, können Sie mit TrafficEstimatorService die künftigen Zugriffe schätzen. So können Sie besser entscheiden, ob die vorgeschlagenen Keywords (und Einstellungen) optimal sind. Wenn eines der ausgewählten Keywords beispielsweise zu einer geringeren Klickrate führt, sollten Sie es nicht verwenden.

Mit dem TrafficEstimatorService erhalten Sie ähnliche Informationen wie mit der Funktion Leistungsprognosen zu Klicks und Kosten abrufen des AdWords Keyword-Planers.

Additionally, you can use the TargetingIdeaService to get additional keyword ideas for an ad group. Rufen Sie jedoch mit dem TrafficEstimatorService eine Schätzung der Leistung dieser neuen Keywords ab, bevor Sie diese Keyword-Ideen übernehmen. Weitere Informationen finden Sie im Leitfaden Ausrichtungsideen generieren.

Zugriffsschätzungen abrufen

TrafficEstimatorSelector ist der wichtigste Parameter für den TrafficEstimatorService.

Um Zugriffsschätzungen abzurufen, müssen Sie entweder vorhandene Kampagnen und Anzeigengruppen angeben oder vorgeschlagene Kampagnen und Anzeigengruppen konfigurieren, indem Sie CampaignEstimateRequest und AdGroupEstimateRequest festlegen.

In einer AdGroupEstimateRequest müssen Sie außerdem für die Keywords, für die Zugriffe geschätzt werden sollen, eine KeywordEstimateRequest angeben.

In den folgenden Abschnitten wird gezeigt, wie Sie Zugriffsschätzungen mit dem TrafficEstimatorService abrufen.

Anfrage vorbereiten

Sie müssen den TrafficEstimatorSelector von unten nach oben aufbauen. Um also eine vollständige Anfrage zu erstellen, muss die folgende Reihenfolge eingehalten werden:

  1. KeywordEstimateRequest
  2. AdGroupEstimateRequest
  3. CampaignEstimateRequest

Zuerst müssen Sie KeywordEstimateRequest erstellen. Häufig werden Schätzungen für mehrere Keywords abgerufen. Jedes Keyword erfordert eine entsprechende KeywordEstimateRequest.

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
    

Die Liste der Keywords, die Sie an TrafficEstimatorService senden, kann mit den in Ihrer Keyword-Taxonomie vorhandenen Keywords übereinstimmen. Sie können aber auch neue Keywords verwenden, die Sie mit dem TargetingIdeaService abrufen.

Erstellen Sie nun AdGroupEstimateRequest. Wie bei der Keywords-Liste können Sie Schätzungen für mehrere Anzeigengruppen abrufen. In diesem Beispiel wird die Schätzung nur für eine einzelne Anzeigengruppe abgerufen:

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

Erstellen Sie nun CampaignEstimateRequest. Genauere Ergebnisse erzielen Sie, wenn Sie beim Erstellen von CampaignEstimateRequest zusätzliche Kampagnenkriterien wie Standort und Sprache festlegen. Sie können in CampaignEstimateRequest und AdGroupEstimateRequest auch bestehende Kampagnen-IDs und Anzeigengruppen-IDs angeben. Vom Dienst können dann Verlaufsdaten geladen werden.

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

Konfigurieren Sie nun TrafficEstimatorSelector. Anschließend können Sie den Selektor in der get()-Operation senden, um die im Objekt TrafficEstimatorResult gekapselten Zugriffsschätzungen abzurufen. Ab Version 201605 können Sie mit der Property platformEstimateRequested eine Liste von Schätzungen auf Kampagnenebene anfordern, die nach Plattform segmentiert ist.

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)
    

Antwort verarbeiten

Von jedem CampaignEstimateRequest-Objekt im Selektor wird in TrafficEstimatorResult ein entsprechendes CampaignEstimate-Objekt generiert. Ebenso gehört zu jedem AdGroupEstimateRequest-Objekt ein entsprechendes AdGroupEstimate-Objekt im Ergebnis. Wenn Sie nach Plattform segmentierte Schätzungen auf Kampagnenebene angefordert haben, stehen diese über die platformEstimates-Property des CampaignEstimate-Objekts zur Verfügung.

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
    

Das wichtigste Objekt im Ergebnis ist das entsprechende KeywordEstimate-Objekt in AdGroupEstimate. Es enthält für jedes Keyword die untere Grenze (min) und die obere Grenze (max) der Zugriffsschätzung (StatsEstimate).

Die zurückgegebenen Werte sind nur Schätzungen. Es ist nicht garantiert, dass die tatsächliche Leistung innerhalb dieser Grenzen liegen wird.

Wert für "Geschätzte Conversions insgesamt" berechnen

Von der API wird der Wert für geschätzte Conversions insgesamt nicht wie beim Keyword-Planer direkt zurückgegeben. Sie können ihn jedoch aus den zur Verfügung gestellten Statistiken berechnen:

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

Vergleich mit Keyword-Planer

Sie können den TrafficEstimatorService ähnlich wie die Funktion Leistungsprognosen zu Klicks und Kosten abrufen des AdWords Keyword-Planers verwenden.

Um dazu den TrafficEstimatorService zu verwenden, müssen Sie entweder eine bereits bestehende Kampagne angeben oder eine Pseudokampagne erstellen, die Anzeigengruppen und Keywords enthält.

Keyword-Planer AdWords API
Keywords eingeben KeywordEstimateRequest
Ausrichtung – Standort Verwenden Sie das Location-Kriterium in CampaignEstimateRequest.criteria.
Ausrichtung – Sprache Verwenden Sie das Language-Kriterium in CampaignEstimateRequest.criteria.
Ausrichtung – Werbenetzwerk CampaignEstimateRequest.networkSetting
Zeitraum Nicht unterstützt

Im Keyword-Planer können Sie ein Tagesbudget und einen Gebotsbetrag angeben. In der AdWords API ist ein dailyBudget Bestandteil der CampaignEstimateRequest. Der Gebotsbetrag maxCpc kann entweder in der AdGroupEstimateRequest oder in der KeywordEstimateRequest festgelegt werden. Diese Werte müssen beim Senden der Anfrage angegeben werden. Auch wenn sie auf dem Bildschirm Ergebnisse des Keyword-Planers zu sehen sind, müssen sie also bei Verwendung der API in die Anfrage aufgenommen werden.

Vollständige Codebeispiele

Jede Clientbibliothek enthält im Ordner Optimierung ein vollständiges Codebeispiel:

Feedback geben zu...