Kurvendiagramm mit Messwerten zur Reichweite erstellen

Wichtig: Diese Funktion ist nur für Konten auf der Zulassungsliste verfügbar. Wenn Sie weiterhin Zugriff darauf benötigen, wenden Sie sich bitte an Ihren Kontakt bei Google.

Nachdem Sie die Targeting-Einstellungen und eine Produktmischung für Ihren Mediaplan festgelegt haben, können Sie mit der Methode GenerateReachForecast in ReachPlanService eine Kurve der Budgets im Vergleich zur potenziellen Reichweite generieren. Weitere Informationen zu den Anfragefeldern finden Sie im Glossar und im Leitfaden für Mediapläne.

Hinweis: Im Feld targeting.audience_targeting (AudienceTargeting) werden bestimmte user_interest_category-Werte in UserInterestInfo für Reichweitenprognosen nicht unterstützt. Verwenden Sie ReachPlanService.ListPlannableUserInterests und ReachPlanService.ListPlannableUserLists, um unterstützte Kriterien abzufragen, bevor Sie GenerateReachForecast aufrufen.

Prognosemesswerte

Die Antwort von GenerateReachForecast enthält verschiedene Messwerte in der Nachricht Forecast, die Aufschluss über die potenzielle Leistung Ihrer geplanten Kampagne geben. Zu diesen Messwerten gehören:

• Reichweite (Zielgruppe und insgesamt, einschließlich Co-Viewing)
• Impressionen (nach Targeting und insgesamt, einschließlich Co-Viewing und sichtbare Impressionen)
• Aufschlüsselung der effektiven Häufigkeit (wie viele einzelne Nutzer mindestens eine bestimmte Anzahl von Malen erreicht werden, z. B. 1+, 2+ oder 3+ Impressionen)
• Nutzeraktionen (TrueView-Aufrufe, Conversions und Klicks)

Reichweite für Demand Gen-Kampagnen prognostizieren

Wenn Sie Kurven für DEMAND_GEN planbare Produkte generieren, müssen Sie auch eine erwartete Conversion-Rate für jedes Produkt angeben.

Wenn Sie Vorschläge für die Conversion-Rate für unterstützte planbare Produkte erhalten möchten, verwenden Sie die Methode GenerateConversionRates. Diese Methode gibt Vorschläge für die Conversion-Rate zurück, die entweder auf der bisherigen Leistung Ihres Kontos oder auf der Leistung aller Werbetreibenden basieren.

Für DEMAND_GEN-Produkte kann GenerateConversionRates mehrere Vorschläge für dasselbe Produkt zurückgeben. Bei einigen Vorschlägen ist das Feld surface_targeting ausgefüllt. Das bedeutet, dass der Vorschlag nur für diese bestimmte Kombination von Oberflächen gilt (z. B. YouTube Shorts). Wenn surface_targeting nicht ausgefüllt ist, ist der Vorschlag ein Durchschnittswert für Demand Gen-Kampagnen für dieses Produkt. Verwenden Sie beim Erstellen von Prognosen für Demand Gen-Kampagnen mit Targeting auf Oberflächen den spezifischsten verfügbaren Vorschlag für die Conversion-Rate.

Zusätzlich zu Conversion-Raten können Nutzer von Demand Gen-Kampagnen GenerateReachForecast verwenden, um clicks zu prognostizieren. Das ist besonders relevant für Kampagnen, die für Klicks optimiert werden, z. B. Demand Gen-Kampagnen mit der Gebotsstrategie „Klicks maximieren“.

Reichweite für YouTube Select prognostizieren

YouTube Select (YTS) in ReachPlanService unterstützt das Targeting auf Paketebene für alle infrage kommenden YTS-Standorte mit Preisen für die Direktreservierung. Verwende das Feld youtube_select_lineup_targeting in ReachPlanService.ListPlannableProducts, um verfügbare Lineups zu identifizieren. youtube_select_lineup_targeting hat das Feld youtube_select_lineups ersetzt, das in v23 verworfen und in v24 entfernt wurde.

Bei der Sofortreservierung können die folgenden Fehler auftreten, wenn Sie eine Prognose für YTS anfordern:

• Nicht genügend Inventar verfügbar
• Konten ohne Ausgaben deaktiviert

Kurven speichern

Sie können nur einzelne Kurven speichern, um Ihren Nutzern die Arbeit zu erleichtern. Das massenhafte Caching von Kurven ist strengstens untersagt. Wenn Sie Kurven in großer Zahl generieren müssen, wenden Sie sich zuerst an Ihren Google-Kundenbetreuer.

Fehlerbehandlung

Anfragen an ReachPlanService müssen der grundlegenden API-Struktur entsprechen und können bei fehlgeschlagener Validierung häufige Fehler zurückgeben.

Zusätzlich zu den allgemeinen Fehlern kann ReachPlanService auch Fehler zurückgeben, die spezifisch für den Reichweiten-Planer sind und in ReachPlanError aufgeführt sind.

Codebeispiel

Die Kurve enthält die Impressionen und die Nutzerreichweite in absoluten Zahlen sowie die Grundgesamtheiten, die der offiziellen Bevölkerungszahl und der Größe der YouTube-Zielgruppe für die angeforderte demografische Gruppe und das angeforderte Land entsprechen.

Java

private void getReachCurve(
    ReachPlanServiceClient reachPlanServiceClient, GenerateReachForecastRequest request) {
  GenerateReachForecastResponse response = reachPlanServiceClient.generateReachForecast(request);
  System.out.println("Reach curve output:");
  System.out.println(
      "Currency, Cost Micros, On-Target Reach, On-Target Imprs, Total Reach, Total Imprs,"
          + " Products");
  for (ReachForecast point : response.getReachCurve().getReachForecastsList()) {
    System.out.printf(
        "%s, \"",
        Joiner.on(", ")
            .join(
                request.getCurrencyCode(),
                String.valueOf(point.getCostMicros()),
                String.valueOf(point.getForecast().getOnTargetReach()),
                String.valueOf(point.getForecast().getOnTargetImpressions()),
                String.valueOf(point.getForecast().getTotalReach()),
                String.valueOf(point.getForecast().getTotalImpressions())));
    for (PlannedProductReachForecast product : point.getPlannedProductReachForecastsList()) {
      System.out.printf("[Product: %s, ", product.getPlannableProductCode());
      System.out.printf("Budget Micros: %s]", product.getCostMicros());
    }
    System.out.printf("\"%n");
  }
}
ForecastReach.java
      

C#

public void GetReachCurve(ReachPlanServiceClient reachPlanService,
    GenerateReachForecastRequest request)
{
    GenerateReachForecastResponse response = reachPlanService.GenerateReachForecast(
        request);
    Console.WriteLine("Reach curve output:");
    Console.WriteLine(
        "Currency, Cost Micros, On-Target Reach, On-Target Impressions, Total Reach," +
        " Total Impressions, Products");
    foreach (ReachForecast point in response.ReachCurve.ReachForecasts)
    {
        Console.Write($"{request.CurrencyCode}, ");
        Console.Write($"{point.CostMicros}, ");
        Console.Write($"{point.Forecast.OnTargetReach}, ");
        Console.Write($"{point.Forecast.OnTargetImpressions}, ");
        Console.Write($"{point.Forecast.TotalReach}, ");
        Console.Write($"{point.Forecast.TotalImpressions}, ");
        Console.Write("\"[");
        foreach (PlannedProductReachForecast productReachForecast in
            point.PlannedProductReachForecasts)
        {
            Console.Write($"(Product: {productReachForecast.PlannableProductCode}, ");
            Console.Write($"Budget Micros: {productReachForecast.CostMicros}), ");
        }

        Console.WriteLine("]\"");
    }
}
ForecastReach.cs
      

PHP

private static function getReachCurve(
    GoogleAdsClient $googleAdsClient,
    int $customerId,
    array $productMix,
    string $locationId,
    string $currencyCode
) {
    // Valid durations are between 1 and 90 days.
    $duration = new CampaignDuration(['duration_in_days' => 28]);
    $targeting = new Targeting([
        'plannable_location_id' => $locationId,
        'age_range' => ReachPlanAgeRange::AGE_RANGE_18_65_UP,
        'genders' => [
            new GenderInfo(['type' => GenderType::FEMALE]),
            new GenderInfo(['type' => GenderType::MALE])
        ],
        'devices' => [
            new DeviceInfo(['type' => Device::DESKTOP]),
            new DeviceInfo(['type' => Device::MOBILE]),
            new DeviceInfo(['type' => Device::TABLET])
        ]
    ]);

    // See the docs for defaults and valid ranges:
    // https://developers.google.com/google-ads/api/reference/rpc/latest/GenerateReachForecastRequest
    $response = $googleAdsClient->getReachPlanServiceClient()->generateReachForecast(
        GenerateReachForecastRequest::build($customerId, $duration, $productMix)
            ->setCurrencyCode($currencyCode)
            ->setTargeting($targeting)
    );

    printf(
        "Reach curve output:%sCurrency, Cost Micros, On-Target Reach, On-Target Imprs," .
            " Total Reach, Total Imprs, Products%s",
        PHP_EOL,
        PHP_EOL
    );
    foreach ($response->getReachCurve()->getReachForecasts() as $point) {
        $products = '';
        /** @var ReachForecast $point */
        foreach ($point->getPlannedProductReachForecasts() as $plannedProductReachForecast) {
            /** @var PlannedProductReachForecast $plannedProductReachForecast */
            $products .= sprintf(
                '(Product: %s, Budget Micros: %s)',
                $plannedProductReachForecast->getPlannableProductCode(),
                $plannedProductReachForecast->getCostMicros()
            );
        }
        printf(
            "%s, %d, %d, %d, %d, %d, %s%s",
            $currencyCode,
            $point->getCostMicros(),
            $point->getForecast()->getOnTargetReach(),
            $point->getForecast()->getOnTargetImpressions(),
            $point->getForecast()->getTotalReach(),
            $point->getForecast()->getTotalImpressions(),
            $products,
            PHP_EOL
        );
    }
}
ForecastReach.php
      

Python

def request_reach_curve(
    client: GoogleAdsClient,
    customer_id: str,
    product_mix: list[PlannedProduct],
    location_id: str,
    currency_code: str,
):
    """Creates a sample request for a given product mix.

    Args:
        client: an initialized GoogleAdsClient instance.
        customer_id: The customer ID for the reach forecast.
        product_mix: The product mix for the reach forecast.
        location_id: The location ID to plan for.
        currency_code: Three-character ISO 4217 currency code.
    """
    # See the docs for defaults and valid ranges:
    # https://developers.google.com/google-ads/api/reference/rpc/latest/GenerateReachForecastRequest
    request: GenerateReachForecastRequest = client.get_type(
        "GenerateReachForecastRequest"
    )
    request.customer_id = customer_id
    # Valid durations are between 1 and 90 days.
    request.campaign_duration.duration_in_days = 28
    request.currency_code = currency_code
    request.cookie_frequency_cap = 0
    request.min_effective_frequency = 1
    request.planned_products = product_mix

    request.targeting.plannable_location_id = location_id
    request.targeting.age_range = (
        client.enums.ReachPlanAgeRangeEnum.AGE_RANGE_18_65_UP
    )

    # Add gender targeting to the request.
    gender_type: GenderTypeEnum
    for gender_type in [
        client.enums.GenderTypeEnum.FEMALE,
        client.enums.GenderTypeEnum.MALE,
    ]:
        gender: GenderInfo = client.get_type("GenderInfo")
        gender.type_ = gender_type
        request.targeting.genders.append(gender)

    # Add device targeting to the request.
    device_type: DeviceEnum
    for device_type in [
        client.enums.DeviceEnum.DESKTOP,
        client.enums.DeviceEnum.MOBILE,
        client.enums.DeviceEnum.TABLET,
    ]:
        device: DeviceInfo = client.get_type("DeviceInfo")
        device.type_ = device_type
        request.targeting.devices.append(device)

    reach_plan_service: ReachPlanServiceClient = client.get_service(
        "ReachPlanService"
    )
    response: GenerateReachForecastResponse = (
        reach_plan_service.generate_reach_forecast(request=request)
    )

    print(
        "Currency, Cost, On-Target Reach, On-Target Imprs, Total Reach,"
        " Total Imprs, Products"
    )
    point: ReachForecast
    for point in response.reach_curve.reach_forecasts:
        product_splits = []
        p: PlannedProductReachForecast
        for p in point.planned_product_reach_forecasts:
            product_splits.append(
                {p.plannable_product_code: p.cost_micros / ONE_MILLION}
            )
        print(
            [
                currency_code,
                point.cost_micros / ONE_MILLION,
                point.forecast.on_target_reach,
                point.forecast.on_target_impressions,
                point.forecast.total_reach,
                point.forecast.total_impressions,
                product_splits,
            ]
        )
forecast_reach.py
      

Ruby

def get_reach_curve(
  client,
  reach_plan_service,
  customer_id,
  product_mix,
  location_id,
  currency_code)
  duration = client.resource.campaign_duration do |d|
    # Valid durations are between 1 and 90 days.
    d.duration_in_days = 28
  end

  targeting = client.resource.targeting do |t|
    t.plannable_location_id = location_id
    t.age_range = :AGE_RANGE_18_65_UP
    t.genders << client.resource.gender_info do |gender|
      gender.type = :FEMALE
    end
    t.genders << client.resource.gender_info do |gender|
      gender.type = :MALE
    end
    t.devices << client.resource.device_info do |device|
      device.type = :DESKTOP
    end
    t.devices << client.resource.device_info do |device|
      device.type = :MOBILE
    end
    t.devices << client.resource.device_info do |device|
      device.type = :TABLET
    end
  end

  # See the docs for defaults and valid ranges:
  # https://developers.google.com/google-ads/api/reference/rpc/latest/GenerateReachForecastRequest
  response = reach_plan_service.generate_reach_forecast(
    customer_id: customer_id,
    campaign_duration: duration,
    planned_products: product_mix,
    currency_code: currency_code,
    targeting: targeting,
  )

  puts "Reach curve output:"
  puts "Currency, Cost Micros, On-Target Reach, On-Target Imprs, " \
    "Total Reach, Total Imprs, Products"

  response.reach_curve.reach_forecasts.each do |point|
    products = ""
    point.planned_product_reach_forecasts.each do |product|
      products += "(Product: #{product.plannable_product_code}, "\
        "Cost Micros: #{product.cost_micros})"
    end
    puts "#{currency_code}, #{point.cost_micros}, " \
      "#{point.forecast.on_target_reach}, " \
      "#{point.forecast.on_target_impressions}, " \
      "#{point.forecast.total_reach}, " \
      "#{point.forecast.total_impressions}, " \
      "#{products}"
  end
end
forecast_reach.rb
      

Perl

sub pull_reach_curve {
  my ($reach_plan_service, $reach_request) = @_;

  my $response = $reach_plan_service->generate_reach_forecast($reach_request);
  print "Reach curve output:\n";
  print "Currency,\tCost Micros,\tOn-Target Reach,\tOn-Target Imprs,\t" .
    "Total Reach,\tTotal Imprs,\tProducts\n";
  foreach my $point (@{$response->{reachCurve}{reachForecasts}}) {
    printf "%s,\t%d,\t%d,\t%d,\t%d,\t%d,\t'[", $reach_request->{currencyCode},
      $point->{costMicros}, $point->{forecast}{onTargetReach},
      $point->{forecast}{onTargetImpressions}, $point->{forecast}{totalReach},
      $point->{forecast}{totalImpressions};
    foreach my $productReachForecast (@{$point->{plannedProductReachForecasts}})
    {
      printf "(Product: %s, Budget Micros: %d), ",
        $productReachForecast->{plannableProductCode},
        $productReachForecast->{costMicros};
    }
    print "]'\n";
  }
}
forecast_reach.pl
      

curl

Hinweis: Für diesen Schritt wird hier kein direktes REST-Codebeispiel bereitgestellt. Sie können dies jedoch mit einer manuellen REST-Anfrage erreichen.

Weitere Informationen finden Sie in der Dokumentation zur REST-Schnittstelle der Google Ads API und auf den methodenspezifischen Referenzseiten. Sie müssen die JSON-Nutzlast anhand der Proto-Definitionen erstellen.

Wichtige Ressourcen:

• REST verwenden
• Struktur der REST-Schnittstelle
• JSON-Feldzuordnungen
• Informationen zum jeweiligen Dienst und zur Methode finden Sie in der REST API-Referenz.

Google Issue Tracker

Verwenden Sie den Google Issue Tracker, um Supportfragen zu stellen, Fehler zu melden oder Feature Requests einzureichen. Google verfolgt, priorisiert und veröffentlicht Updates zu Ihren Anfragen direkt im Issue Tracker. Weitere Informationen finden Sie unter Problem im Google Issue Tracker erstellen.

Erstellen Sie ein Problem mit einer der folgenden Issue Tracker-Vorlagen:

• Allgemeine Supportfrage stellen oder Feedback zur Dokumentation geben
• Technischen Fehler melden
• API-Feature Request senden

Füllen Sie alle Felder in der Vorlage mit detaillierten Informationen aus, damit Google Ihre Anfrage reproduzieren und priorisieren kann. Google schließt unvollständige Meldungen möglicherweise und bittet Sie, ein neues Problem mit den fehlenden Details einzureichen.