Especificar um plano de mídia

O Google oferece vários produtos e públicos-alvo que você pode usar para criar campanhas, mas talvez não saiba como formular um plano. Para ajudar com isso, o ReachPlanService oferece métodos de descoberta que podem ser usados para gerar uma curva.

Segmentação por público-alvo

O primeiro componente de um plano de mídia é a segmentação por público-alvo, que pode incluir os seguintes critérios:

Mix de produtos

Além das informações de segmentação, você precisa especificar um mix de produtos para gerar uma curva.

O método ListPlannableProducts em ReachPlanService mostra os formatos mais recentes disponíveis para um determinado ID de local. Eles são representados pelos seguintes campos em ProductMetadata:

Esses valores mudam periodicamente. Por isso, é melhor fornecer resultados em tempo real aos usuários em vez de respostas off-line.

Confira um exemplo de código para receber o mix de produtos de alguns critérios de segmentação:

Java

private void showPlannableProducts(
    ReachPlanServiceClient reachPlanServiceClient, String locationId) {
  ListPlannableProductsRequest request =
      ListPlannableProductsRequest.newBuilder().setPlannableLocationId(locationId).build();

  ListPlannableProductsResponse response = reachPlanServiceClient.listPlannableProducts(request);

  System.out.printf("Plannable Products for location %s:%n", locationId);
  for (ProductMetadata product : response.getProductMetadataList()) {
    System.out.printf("%s:%n", product.getPlannableProductCode());
    System.out.println("Age Ranges:");
    for (ReachPlanAgeRange ageRange : product.getPlannableTargeting().getAgeRangesList()) {
      System.out.printf("\t- %s%n", ageRange);
    }
    System.out.println("Genders:");
    for (GenderInfo gender : product.getPlannableTargeting().getGendersList()) {
      System.out.printf("\t- %s%n", gender.getType());
    }
    System.out.println("Devices:");
    for (DeviceInfo device : product.getPlannableTargeting().getDevicesList()) {
      System.out.printf("\t- %s%n", device.getType());
    }
  }
}

C#

public void ShowPlannableProducts(
    ReachPlanServiceClient reachPlanService, string locationId)
{
    ListPlannableProductsRequest request = new ListPlannableProductsRequest
    {
        PlannableLocationId = locationId
    };
    ListPlannableProductsResponse response = reachPlanService.ListPlannableProducts(
        request);

    Console.WriteLine($"Plannable Products for location {locationId}:");
    foreach (ProductMetadata product in response.ProductMetadata)
    {
        Console.WriteLine($"{product.PlannableProductCode}:");
        Console.WriteLine("Age Ranges:");
        foreach (ReachPlanAgeRange ageRange in product.PlannableTargeting.AgeRanges)
        {
            Console.WriteLine($"\t- {ageRange}");
        }

        Console.WriteLine("Genders:");
        foreach (GenderInfo gender in product.PlannableTargeting.Genders)
        {
            Console.WriteLine($"\t- {gender.Type}");
        }

        Console.WriteLine("Devices:");
        foreach (DeviceInfo device in product.PlannableTargeting.Devices)
        {
            Console.WriteLine($"\t- {device.Type}");
        }
    }
}

PHP

private static function showPlannableProducts(GoogleAdsClient $googleAdsClient)
{
    $response = $googleAdsClient->getReachPlanServiceClient()->listPlannableProducts(
        ListPlannableProductsRequest::build(self::LOCATION_ID)
    );

    print 'Plannable Products for Location ID ' . self::LOCATION_ID . ':' . PHP_EOL;
    foreach ($response->getProductMetadata() as $product) {
        /** @var ProductMetadata $product */
        print $product->getPlannableProductCode() . ':' . PHP_EOL;
        print 'Age Ranges:' . PHP_EOL;
        foreach ($product->getPlannableTargeting()->getAgeRanges() as $ageRange) {
            /** @var ReachPlanAgeRange $ageRange */
            printf("\t- %s%s", ReachPlanAgeRange::name($ageRange), PHP_EOL);
        }
        print 'Genders:' . PHP_EOL;
        foreach ($product->getPlannableTargeting()->getGenders() as $gender) {
            /** @var GenderInfo $gender */
            printf("\t- %s%s", GenderType::name($gender->getType()), PHP_EOL);
        }
        print 'Devices:' . PHP_EOL;
        foreach ($product->getPlannableTargeting()->getDevices() as $device) {
            /** @var DeviceInfo $device */
            printf("\t- %s%s", Device::name($device->getType()), PHP_EOL);
        }
    }
}

Python

def show_plannable_products(client: GoogleAdsClient, location_id: str):
    """Lists plannable products for a given location.

    Args:
        client: an initialized GoogleAdsClient instance.
        location_id: The location ID to plan for.
    """
    reach_plan_service: ReachPlanServiceClient = client.get_service(
        "ReachPlanService"
    )
    response: ListPlannableProductsResponse = (
        reach_plan_service.list_plannable_products(
            plannable_location_id=location_id
        )
    )
    print(f"Plannable Products for Location ID {location_id}")

    product_metadata: ProductMetadata
    for product_metadata in response.product_metadata:
        print(
            f"{product_metadata.plannable_product_code} : "
            f"{product_metadata.plannable_product_name}"
        )

        print("Age Ranges:")
        age_range: ReachPlanAgeRangeEnum
        for age_range in product_metadata.plannable_targeting.age_ranges:
            print(f"\t- {age_range.name}")

        print("Genders:")
        gender: GenderInfo
        for gender in product_metadata.plannable_targeting.genders:
            print(f"\t- {gender.type_.name}")

        print("Devices:")
        device: DeviceInfo
        for device in product_metadata.plannable_targeting.devices:
            print(f"\t- {device.type_.name}")

Ruby

def show_plannable_products(reach_plan_service)
  response = reach_plan_service.list_plannable_products(
    plannable_location_id: LOCATION_ID,
  )

  puts "Plannable Products for Location ID #{LOCATION_ID}:"

  response.product_metadata.each do |product|
    puts "#{product.plannable_product_code}:"
    puts "Age Ranges:"
    product.plannable_targeting.age_ranges.each do |age_range|
      puts "\t- #{age_range}"
    end
    puts "Genders:"
    product.plannable_targeting.genders.each do |gender|
      puts "\t- #{gender.type}"
    end
    puts "Devices:"
    product.plannable_targeting.devices.each do |device|
      puts "\t- #{device.type}"
    end
  end
end

Perl

sub show_plannable_products {
  my ($reach_plan_service, $location_id) = @_;

  my $response = $reach_plan_service->list_plannable_products({
    plannableLocationId => $location_id
  });

  printf "Plannable Products for location %d:\n", $location_id;
  foreach my $product (@{$response->{productMetadata}}) {
    printf "%s : '%s'\n", $product->{plannableProductCode},
      $product->{plannableProductName};
    print "Age Ranges:\n";
    foreach my $age_range (@{$product->{plannableTargeting}{ageRanges}}) {
      printf "\t- %s\n", $age_range;
    }
    print "Genders:\n";
    foreach my $gender (@{$product->{plannableTargeting}{genders}}) {
      printf "\t- %s\n", $gender->{type};
    }
    print "Devices:\n";
    foreach my $device (@{$product->{plannableTargeting}{devices}}) {
      printf "\t- %s\n", $device->{type};
    }
  }
}

curl

Para gerar uma curva, atribua um orçamento a cada produto:

Java

private void forecastManualMix(
    ReachPlanServiceClient reachPlanServiceClient,
    long customerId,
    String locationId,
    String currencyCode,
    long budgetMicros) {
  List<PlannedProduct> productMix = new ArrayList<>();

  // Set up a ratio to split the budget between two products.
  double trueviewAllocation = 0.15;
  double bumperAllocation = 1 - trueviewAllocation;

  // See listPlannableProducts on ReachPlanService to retrieve a list
  // of valid PlannableProductCode's for a given location:
  // https://developers.google.com/google-ads/api/reference/rpc/latest/ReachPlanService
  productMix.add(
      PlannedProduct.newBuilder()
          .setPlannableProductCode("TRUEVIEW_IN_STREAM")
          .setBudgetMicros((long) (budgetMicros * bumperAllocation))
          .build());
  productMix.add(
      PlannedProduct.newBuilder()
          .setPlannableProductCode("BUMPER")
          .setBudgetMicros((long) (budgetMicros * bumperAllocation))
          .build());

  GenerateReachForecastRequest request =
      buildReachRequest(customerId, productMix, locationId, currencyCode);

  getReachCurve(reachPlanServiceClient, request);
}

C#

public void ForecastMix(ReachPlanServiceClient reachPlanService, string customerId,
    string locationId, string currencyCode, long budgetMicros)
{
    List<PlannedProduct> productMix = new List<PlannedProduct>();

    // Set up a ratio to split the budget between two products.
    double trueviewAllocation = 0.15;
    double bumperAllocation = 1 - trueviewAllocation;

    // See listPlannableProducts on ReachPlanService to retrieve a list
    // of valid PlannableProductCode's for a given location:
    // https://developers.google.com/google-ads/api/reference/rpc/latest/ReachPlanService
    productMix.Add(new PlannedProduct
    {
        PlannableProductCode = "TRUEVIEW_IN_STREAM",
        BudgetMicros = Convert.ToInt64(budgetMicros * trueviewAllocation)
    });
    productMix.Add(new PlannedProduct
    {
        PlannableProductCode = "BUMPER",
        BudgetMicros = Convert.ToInt64(budgetMicros * bumperAllocation)
    });

    GenerateReachForecastRequest request =
        BuildReachRequest(customerId, productMix, locationId, currencyCode);

    GetReachCurve(reachPlanService, request);
}

PHP

private static function forecastManualMix(GoogleAdsClient $googleAdsClient, int $customerId)
{
    // Set up a ratio to split the budget between two products.
    $trueviewAllocation = floatval(0.15);
    $bumperAllocation = floatval(1 - $trueviewAllocation);

    // See listPlannableProducts on ReachPlanService to retrieve a list
    // of valid PlannableProductCode's for a given location:
    // https://developers.google.com/google-ads/api/reference/rpc/latest/ReachPlanService
    $productMix = [
        new PlannedProduct([
            'plannable_product_code' => 'TRUEVIEW_IN_STREAM',
            'budget_micros' => self::BUDGET_MICROS * $trueviewAllocation
        ]),
        new PlannedProduct([
            'plannable_product_code' => 'BUMPER',
            'budget_micros' => self::BUDGET_MICROS * $bumperAllocation
        ])
    ];

    self::getReachCurve(
        $googleAdsClient,
        $customerId,
        $productMix,
        self::LOCATION_ID,
        self::CURRENCY_CODE
    );
}

Python

def forecast_manual_mix(
    client: GoogleAdsClient,
    customer_id: str,
    location_id: str,
    currency_code: str,
    budget: int,
):
    """Pulls a forecast for product mix created manually.

    Args:
        client: an initialized GoogleAdsClient instance.
        customer_id: The customer ID for the reach forecast.
        location_id: The location ID to plan for.
        currency_code: Three-character ISO 4217 currency code.
        budget: Budget to allocate to the plan.
    """
    product_mix: list[PlannedProduct] = []
    trueview_allocation = 0.15
    bumper_allocation = 1 - trueview_allocation
    product_splits = [
        ("TRUEVIEW_IN_STREAM", trueview_allocation),
        ("BUMPER", bumper_allocation),
    ]
    product: str
    split: float
    for product, split in product_splits:
        planned_product: PlannedProduct = client.get_type("PlannedProduct")
        planned_product.plannable_product_code = product
        planned_product.budget_micros = math.trunc(budget * ONE_MILLION * split)
        product_mix.append(planned_product)

    request_reach_curve(
        client, customer_id, product_mix, location_id, currency_code
    )

Ruby

def forecast_manual_mix(client, reach_plan_service, customer_id)
  # Set up a ratio to split the budget between two products.
  trueview_allocation = 0.15
  bumper_allocation = 1 - trueview_allocation

  # See listPlannableProducts on ReachPlanService to retrieve a list
  # of valid PlannableProductCode's for a given location:
  # https://developers.google.com/google-ads/api/reference/rpc/latest/ReachPlanService
  product_mix = []

  product_mix << client.resource.planned_product do |p|
    p.plannable_product_code = 'TRUEVIEW_IN_STREAM'
    p.budget_micros = BUDGET_MICROS * trueview_allocation
  end

  product_mix << client.resource.planned_product do |p|
    p.plannable_product_code = 'BUMPER'
    p.budget_micros = BUDGET_MICROS * bumper_allocation
  end

  get_reach_curve(
    client,
    reach_plan_service,
    customer_id,
    product_mix,
    LOCATION_ID,
    CURRENCY_CODE,
  )
end

Perl

sub forecast_mix {
  my (
    $reach_plan_service, $customer_id, $location_id,
    $currency_code,      $budget_micros
  ) = @_;

  my $product_mix = [];

  # Set up a ratio to split the budget between two products.
  my $trueview_allocation = 0.15;
  my $bumper_allocation   = 1 - $trueview_allocation;

  # See list_plannable_products on ReachPlanService to retrieve a list of valid
  # plannable product codes for a given location:
  # https://developers.google.com/google-ads/api/reference/rpc/latest/ReachPlanService
  push @$product_mix,
    Google::Ads::GoogleAds::V25::Services::ReachPlanService::PlannedProduct->
    new({
      plannableProductCode => "TRUEVIEW_IN_STREAM",
      budgetMicros         => int($budget_micros * $trueview_allocation)});
  push @$product_mix,
    Google::Ads::GoogleAds::V25::Services::ReachPlanService::PlannedProduct->
    new({
      plannableProductCode => "BUMPER",
      budgetMicros         => int($budget_micros * $bumper_allocation)});

  my $reach_request =
    build_reach_request($customer_id, $product_mix, $location_id,
    $currency_code);

  pull_reach_curve($reach_plan_service, $reach_request);
}

curl

É também quando você pode definir advanced_product_targeting para as Lineups do YouTube Select.

Campos de solicitação de previsão de alcance

É necessário definir os campos customer_id, campaign_duration e planned_products para cada GenerateReachForecastRequest.

Também é possível definir os seguintes campos condicionais ou opcionais:

Campo Requisito Descrição
cookie_frequency_cap_setting Opcional O número máximo de vezes que um anúncio pode ser mostrado ao mesmo usuário durante um intervalo de tempo especificado. Esse limite pode ser definido por dia, semana ou mês. Substitui cookie_frequency_cap, que foi descontinuado em v24 e removido em v25.
currency_code Opcional Código de moeda ISO 4217 de três caracteres.
customer_reach_group Obrigatório sob certas condições O nome do cliente para quem o planejamento está sendo feito. Esse é um valor definido pelo usuário. Obrigatório se targeting.audience_targeting estiver definido.
effective_frequency_limit Opcional Especifica a maior frequência efetiva mínima (1–10) para Forecast.effective_frequency_breakdowns, mutuamente exclusiva com min_effective_frequency.
forecast_metric_options Opcional Outras opções de métricas (ForecastMetricOptions), como include_coview.
min_effective_frequency Opcional Número mínimo de vezes que uma pessoa foi exposta ao anúncio para as métricas de alcance informadas.
targeting Opcional A segmentação que será aplicada a todos os produtos selecionados no mix de produtos, incluindo local (plannable_location_ids, que substituiu plannable_location_id no v25), faixa etária, gêneros, dispositivos, rede e (no v25 e versões mais recentes) status parental.

A seguir

Saiba como gerar uma curva de alcance.

Anterior
Autenticar
Avançar
Gerar uma curva