Generación de demanda

Las campañas de generación de demanda te permiten compartir la historia de tu marca con las personas en las plataformas visuales de Google: YouTube (incluido Shorts), Descubre, Gmail, Google Maps y la Red de Display de Google. Las campañas de generación de demanda llegan a los clientes a través de múltiples puntos de contacto y usan la IA de Google para publicar creatividades para públicos pertinentes y optimizar las ofertas en todo el embudo, al mismo tiempo que te brindan control total sobre tus recursos y posiciones de la campaña.

Recursos clave de la API

Cuando administras campañas de generación de demanda en la API de Google Ads, trabajas con los siguientes recursos y parámetros de configuración:

Recurso principal	Campos y parámetros de configuración clave de las campañas de generación de demanda
CampaignBudget	explicitly_shared = false; admite presupuestos diarios (amount_micros) o totales personalizados (total_amount_micros con period = CUSTOM_PERIOD).
Campaign	advertising_channel_type = DEMAND_GEN; estrategia de ofertas (maximize_conversions, maximize_conversion_value, target_cpa, target_roas, target_spend, o target_cpc); shopping_setting opcional para los feeds de productos.
AdGroup	audience_setting.use_audience_grouped; demand_gen_ad_group_settings.channel_controls (YouTube, Descubre, Gmail, Maps, Display).
AdGroupCriterion	audience (AudienceInfo), location, language, y listing_group ( ListingGroupInfo).
AdGroupAd y Asset	ad.demand_gen_multi_asset_ad, ad.demand_gen_carousel_ad, or ad.demand_gen_video_responsive_ad.ad.demand_gen_product_ad

Crea una campaña de generación de demanda

Te recomendamos que crees el presupuesto, la campaña, el grupo de anuncios, los recursos y el anuncio de generación de demanda de forma atómica en una sola GoogleAdsService.Mutate solicitud con IDs de recursos temporales negativos para que los recursos dependientes puedan hacer referencia entre sí:

Java

// The below methods create and return MutateOperations that we later provide to
// the GoogleAdsService.Mutate method in order to create the entities in a single
// request. Since the entities for a Demand Gen campaign are closely tied to one-another
// it's considered a best practice to create them in a single Mutate request; the
// entities will either all complete successfully or fail entirely, leaving no
// orphaned entities. See:
// https://developers.google.com/google-ads/api/docs/mutating/overview
List<MutateOperation> operations = new ArrayList<>();
// A utility to create temporary IDs for the resources.
AtomicLong tempId = new AtomicLong(-1);

// Creates a new campaign budget operation and adds it to the list of operations.
String budgetResourceName = ResourceNames.campaignBudget(customerId, tempId.getAndDecrement());
operations.add(
    MutateOperation.newBuilder()
        .setCampaignBudgetOperation(createCampaignBudgetOperation(budgetResourceName))
        .build());

// Creates a new campaign operation and adds it to the list of operations.
String campaignResourceName = ResourceNames.campaign(customerId, tempId.getAndDecrement());
operations.add(
    MutateOperation.newBuilder()
        .setCampaignOperation(
            createDemandGenCampaignOperation(campaignResourceName, budgetResourceName))
        .build());

// Creates a new ad group operation and adds it to the list of operations.
String adGroupResourceName = ResourceNames.adGroup(customerId, tempId.getAndDecrement());
operations.add(
    MutateOperation.newBuilder()
        .setAdGroupOperation(
            createDemandGenAdGroupOperation(adGroupResourceName, campaignResourceName))
        .build());

// Creates the asset operations for the ad.
Map<String, String> assetResourceNames = new HashMap<>();
operations.addAll(
    createAssetOperations(customerId, youTubeVideoId, tempId, assetResourceNames));

// Creates a new ad group ad operation and adds it to the list of operations.
operations.add(
    MutateOperation.newBuilder()
        .setAdGroupAdOperation(
            createDemandGenAdGroupAdOperation(adGroupResourceName, assetResourceNames))
        .build());

// Creates the service client.
try (GoogleAdsServiceClient googleAdsServiceClient =
    googleAdsClient.getLatestVersion().createGoogleAdsServiceClient()) {
  // Sends the mutate request.
  MutateGoogleAdsResponse response =
      googleAdsServiceClient.mutate(String.valueOf(customerId), operations);

  // Prints the results.
  System.out.printf(
      "Created campaign with resource name: %s%n",
      response
          .getMutateOperationResponses(1)
          .getCampaignResult()
          .getResourceName());
  System.out.printf(
      "Created ad group with resource name: %s%n",
      response
          .getMutateOperationResponses(2)
          .getAdGroupResult()
          .getResourceName());
  for (Map.Entry<String, String> entry : assetResourceNames.entrySet()) {
    System.out.printf(
        "Created asset with temporary resource name '%s' and final resource name '%s'.%n",
        entry.getValue(),
        response
            .getMutateOperationResponses(
                operations.indexOf(getOperationForAsset(operations, entry.getValue())))
            .getAssetResult()
            .getResourceName());
  }
  System.out.printf(
      "Created ad group ad with resource name: %s%n",
      response
          .getMutateOperationResponses(operations.size() - 1)
          .getAdGroupAdResult()
          .getResourceName());
}
AddDemandGenCampaign.java
      

C#

// The below methods create and return MutateOperations that we later provide to
// the GoogleAdsService.Mutate method in order to create the entities in a single
// request. Since the entities for a Demand Gen campaign are closely tied to one-another
// it's considered a best practice to create them in a single Mutate request; the
// entities will either all complete successfully or fail entirely, leaving no
// orphaned entities. See:
// https://developers.google.com/google-ads/api/docs/mutating/overview
MutateOperation campaignBudgetOperation =
    CreateCampaignBudgetOperation(budgetResourceName);
MutateOperation campaignOperation =
    CreateDemandGenCampaignOperation(campaignResourceName, budgetResourceName);
MutateOperation adGroupOperation =
    CreateAdGroupOperation(adGroupResourceName, campaignResourceName);

// Send the operations in a single mutate request.
MutateGoogleAdsRequest mutateGoogleAdsRequest = new MutateGoogleAdsRequest
{
    CustomerId = customerId.ToString()
};
// It's important to create these entities in this order because they depend on
// each other, for example the ad group depends on the
// campaign, and the ad group ad depends on the ad group.
mutateGoogleAdsRequest.MutateOperations.Add(campaignBudgetOperation);
mutateGoogleAdsRequest.MutateOperations.Add(campaignOperation);
mutateGoogleAdsRequest.MutateOperations.Add(adGroupOperation);

mutateGoogleAdsRequest.MutateOperations.AddRange(
    CreateAssetOperations(
        videoAssetResourceName,
        videoId,
        logoResourceName,
        client.Config
    )
);

mutateGoogleAdsRequest.MutateOperations.Add(
    CreateDemandGenAdOperation(
        adGroupResourceName,
        videoAssetResourceName,
        logoResourceName
    )
);

MutateGoogleAdsResponse response =
        googleAdsServiceClient.Mutate(mutateGoogleAdsRequest);
AddDemandGenCampaign.cs
      

PHP

This example is not yet available in PHP; you can take a look at the other languages.
    

Python

# The below methods create and return MutateOperations that we later provide
# to the GoogleAdsService.Mutate method in order to create the entities in a
# single request. Since the entities for a Demand Gen campaign are closely
# tied to one-another it's considered a best practice to create them in a
# single Mutate request; the entities will either all complete successfully
# or fail entirely, leaving no orphaned entities. See:
# https://developers.google.com/google-ads/api/docs/mutating/overview
mutate_operations: List[MutateOperation] = [
    # It's important to create these entities in this order because they
    # depend on each other, for example the ad group depends on the
    # campaign, and the ad group ad depends on the ad group.
    create_campaign_budget_operation(client, budget_resource_name),
    create_demand_gen_campaign_operation(
        client, campaign_resource_name, budget_resource_name
    ),
    create_ad_group_operation(
        client, ad_group_resource_name, campaign_resource_name
    ),
    *create_asset_operations(  # Use iterable unpacking
        client,
        video_asset_resource_name,
        video_id,
        logo_asset_resource_name,
    ),
    create_demand_gen_ad_operation(
        client,
        ad_group_resource_name,
        video_asset_resource_name,
        logo_asset_resource_name,
    ),
]

# Send the operations in a single mutate request.
googleads_service.mutate(
    customer_id=customer_id, mutate_operations=mutate_operations
)
add_demand_gen_campaign.py
      

Ruby

operations = []

operations << client.operation.mutate do |m|
  m.campaign_budget_operation = create_campaign_budget_operation(client, budget_resource_name)
end

operations << client.operation.mutate do |m|
  m.campaign_operation = create_demand_gen_campaign_operation(client, campaign_resource_name, budget_resource_name)
end

operations << client.operation.mutate do |m|
  m.ad_group_operation = create_ad_group_operation(client, ad_group_resource_name, campaign_resource_name)
end

operations += create_asset_operations(client, video_asset_resource_name, video_id, logo_asset_resource_name).map do |asset_op|
  client.operation.mutate do |m|
    m.asset_operation = asset_op
  end
end

operations << client.operation.mutate do |m|
  m.ad_group_ad_operation = create_demand_gen_ad_operation(client, ad_group_resource_name, video_asset_resource_name, logo_asset_resource_name)
end

response = client.service.google_ads.mutate(
  customer_id: customer_id,
  mutate_operations: operations,
)
add_demand_gen_campaign.rb
      

Perl

This example is not yet available in Perl; you can take a look at the other languages.
    

curl

Nota: Si bien aquí no se proporciona una muestra de código REST directa para este paso, puedes lograrlo con una solicitud REST manual.

Consulta la documentación de la interfaz REST de la API de Google Ads y las páginas de referencia específicas del método. Deberás construir la carga útil JSON según las definiciones de proto.

Recursos clave:

• Uso de REST
• Estructura de la interfaz REST
• Asignaciones de campos JSON
• Consulta la referencia de la API de REST para obtener información sobre el servicio y el método específicos.

Para obtener instrucciones paso a paso sobre los presupuestos, las estrategias de ofertas y los formatos de anuncios, consulta Crea una campaña de generación de demanda.

Consulta campañas de generación de demanda

Usa GoogleAdsService.SearchStream para recuperar los atributos y las métricas de rendimiento de las campañas de generación de demanda segmentados por red y plataforma de YouTube (segments.ad_network_type y segments.ad_sub_network_type deben seleccionarse juntos):

SELECT
  campaign.id,
  campaign.name,
  campaign.status,
  campaign.bidding_strategy_type,
  segments.ad_network_type,
  segments.ad_sub_network_type,
  metrics.impressions,
  metrics.clicks,
  metrics.conversions,
  metrics.cost_micros
FROM campaign
WHERE campaign.advertising_channel_type = DEMAND_GEN
  AND segments.date DURING LAST_30_DAYS

Para obtener consultas de desglose a nivel del anuncio, del recurso y de la conversión, consulta Informes de campañas de generación de demanda.

Próximos pasos

• Crea una campaña de generación de demanda
• Configura la segmentación por público
• Usa feeds de productos con las campañas de generación de demanda
• Configura los controles de canales
• Recupera informes de campañas de generación de demanda