Inizia a utilizzare Performance Max

Questa guida fornisce un elenco di controllo di concetti e attività per ciascuno dei tre scopi commerciali di Performance Max per aiutarti a creare la tua campagna. Per iniziare, seleziona un obiettivo commerciale:

Vendite online o generazione di lead Vendite online con un feed dei prodotti Scopi relativi ai viaggi

Suggerimento: hai già una campagna pubblicitaria di cui vuoi eseguire l'upgrade? Consulta la guida all'upgrade.

Performance Max per le vendite online o la generazione di lead (standard)

Performance Max consente agli inserzionisti di accedere a tutti i canali e all'inventario di Google Ads da una singola campagna unificata. Di seguito sono riportati i passaggi per creare una campagna Performance Max standard. Fai clic sui link di ogni sezione per saperne di più.

Importante: per utilizzare le campagne Performance Max, devi aver configurato il monitoraggio delle conversioni nel tuo account Google Ads.

Concetti di Performance Max

Scopri di più su Performance Max per le vendite online o la generazione di lead (standard)

Uno degli obiettivi più comuni tra gli inserzionisti è incoraggiare i clienti a intraprendere un'azione specifica per raggiungere un obiettivo, ad esempio generare vendite o lead. Nell'API Google Ads, le campagne Performance Max per le vendite online o la generazione di lead sono spesso indicate come campagne Performance Max standard.

Quando crei una campagna Performance Max, puoi utilizzare una richiesta di modifica collettiva per creare le risorse necessarie per formare una campagna valida e pubblicata in una singola richiesta. Non è necessario creare tutte le risorse in una singola richiesta di modifica collettiva. Per creare una campagna Performance Max valida e pubblicabile, sono necessarie le seguenti risorse. Scopri di più nella guida alle richieste di struttura.

• CampaignBudget
• Campaign
• AssetGroups
• AssetGroupAssets

Importante: AssetGroups e AssetGroupAssets che collegano gli asset minimi richiesti a ogni AssetGroup devono essere creati insieme in un'unica richiesta di modifica collettiva.

---

Campagna e budget della campagna

Aggiungere un budget della campagna

• Il budget deve avere un periodo di budget DAILY (scopri di più).
• Il budget non può essere condiviso.

Esempio di codice

Java

/** Creates a MutateOperation that creates a new CampaignBudget. */
private MutateOperation createCampaignBudgetOperation(long customerId) {
  CampaignBudget campaignBudget =
      CampaignBudget.newBuilder()
          .setName("Performance Max campaign budget #" + getPrintableDateTime())
          // The budget period already defaults to DAILY.
          .setAmountMicros(50_000_000)
          .setDeliveryMethod(BudgetDeliveryMethod.STANDARD)
          // A Performance Max campaign cannot use a shared campaign budget.
          .setExplicitlyShared(false)
          // Set a temporary ID in the budget's resource name, so it can be referenced
          // by the campaign in later steps.
          .setResourceName(ResourceNames.campaignBudget(customerId, BUDGET_TEMPORARY_ID))
          .build();

  return MutateOperation.newBuilder()
      .setCampaignBudgetOperation(
          CampaignBudgetOperation.newBuilder().setCreate(campaignBudget).build())
      .build();
}
AddPerformanceMaxCampaign.java
      

C#

/// <summary>
/// Creates a MutateOperation that creates a new CampaignBudget.
///
/// A temporary ID will be assigned to this campaign budget so that it can be
/// referenced by other objects being created in the same Mutate request.
/// </summary>
/// <param name="budgetResourceName">The temporary resource name of the budget to
/// create.</param>
/// <returns>A MutateOperation that creates a CampaignBudget.</returns>
private MutateOperation CreateCampaignBudgetOperation(string budgetResourceName)
{
    MutateOperation operation = new MutateOperation
    {
        CampaignBudgetOperation = new CampaignBudgetOperation
        {
            Create = new CampaignBudget
            {
                Name = "Performance Max campaign budget #"
                  + ExampleUtilities.GetRandomString(),

                // The budget period already defaults to DAILY.
                AmountMicros = 50000000,
                DeliveryMethod = BudgetDeliveryMethod.Standard,

                // A Performance Max campaign cannot use a shared campaign budget.
                ExplicitlyShared = false,

                // Set a temporary ID in the budget's resource name so it can be referenced
                // by the campaign in later steps.
                ResourceName = budgetResourceName
            }
        }
    };

    return operation;
}
AddPerformanceMaxCampaign.cs
      

PHP

private static function createCampaignBudgetOperation(int $customerId): MutateOperation
{
    // Creates a mutate operation that creates a campaign budget operation.
    return new MutateOperation([
        'campaign_budget_operation' => new CampaignBudgetOperation([
            'create' => new CampaignBudget([
                // Sets a temporary ID in the budget's resource name so it can be referenced
                // by the campaign in later steps.
                'resource_name' => ResourceNames::forCampaignBudget(
                    $customerId,
                    self::BUDGET_TEMPORARY_ID
                ),
                'name' => 'Performance Max campaign budget #' . Helper::getPrintableDatetime(),
                // The budget period already defaults to DAILY.
                'amount_micros' => 50000000,
                'delivery_method' => BudgetDeliveryMethod::STANDARD,
                // A Performance Max campaign cannot use a shared campaign budget.
                'explicitly_shared' => false
            ])
        ])
    ]);
}
AddPerformanceMaxCampaign.php
      

Python

def create_campaign_budget_operation(
    client,
    customer_id,
):
    """Creates a MutateOperation that creates a new CampaignBudget.

    A temporary ID will be assigned to this campaign budget so that it can be
    referenced by other objects being created in the same Mutate request.

    Args:
        client: an initialized GoogleAdsClient instance.
        customer_id: a client customer ID.

    Returns:
        a MutateOperation that creates a CampaignBudget.
    """
    mutate_operation = client.get_type("MutateOperation")
    campaign_budget_operation = mutate_operation.campaign_budget_operation
    campaign_budget = campaign_budget_operation.create
    campaign_budget.name = f"Performance Max campaign budget #{uuid4()}"
    # The budget period already defaults to DAILY.
    campaign_budget.amount_micros = 50000000
    campaign_budget.delivery_method = (
        client.enums.BudgetDeliveryMethodEnum.STANDARD
    )
    # A Performance Max campaign cannot use a shared campaign budget.
    campaign_budget.explicitly_shared = False

    # Set a temporary ID in the budget's resource name so it can be referenced
    # by the campaign in later steps.
    campaign_budget.resource_name = client.get_service(
        "CampaignBudgetService"
    ).campaign_budget_path(customer_id, _BUDGET_TEMPORARY_ID)

    return mutate_operation
add_performance_max_campaign.py
      

Ruby

# Creates a MutateOperation that creates a new CampaignBudget.
#
# A temporary ID will be assigned to this campaign budget so that it can be
# referenced by other objects being created in the same Mutate request.
def create_campaign_budget_operation(client, customer_id)
  client.operation.mutate do |m|
    m.campaign_budget_operation = client.operation.create_resource.campaign_budget do |cb|
      cb.name = "Performance Max campaign budget #{SecureRandom.uuid}"
      # The budget period already defaults to DAILY.
      cb.amount_micros = 50_000_000
      cb.delivery_method = :STANDARD
        # A Performance Max campaign cannot use a shared campaign budget.
        cb.explicitly_shared = false

      # Set a temporary ID in the budget's resource name so it can be referenced
      # by the campaign in later steps.
      cb.resource_name = client.path.campaign_budget(customer_id, BUDGET_TEMPORARY_ID)
    end
  end
end
add_performance_max_campaign.rb
      

Perl

sub create_campaign_budget_operation {
  my ($customer_id) = @_;

  # Create a mutate operation that creates a campaign budget operation.
  return
    Google::Ads::GoogleAds::V18::Services::GoogleAdsService::MutateOperation->
    new({
      campaignBudgetOperation =>
        Google::Ads::GoogleAds::V18::Services::CampaignBudgetService::CampaignBudgetOperation
        ->new({
          create => Google::Ads::GoogleAds::V18::Resources::CampaignBudget->new(
            {
              # Set a temporary ID in the budget's resource name so it can be
              # referenced by the campaign in later steps.
              resourceName =>
                Google::Ads::GoogleAds::V18::Utils::ResourceNames::campaign_budget(
                $customer_id, BUDGET_TEMPORARY_ID
                ),
              name => "Performance Max campaign budget #" . uniqid(),
              # The budget period already defaults to DAILY.
              amountMicros   => 50000000,
              deliveryMethod => STANDARD,
              # A Performance Max campaign cannot use a shared campaign budget.
              explicitlyShared => "false",
            })})});
}
add_performance_max_campaign.pl
      

---

Aggiungere una campagna e una strategia di offerta

Le campagne Performance Max hanno un valore di AdvertisingChannelType pari a PERFORMANCE_MAX. Nessun AdvertisingChannelSubType deve essere impostato.

Queste sono le uniche strategie di offerta supportate:

• Se non monitori i valori e tutte le conversioni hanno la stessa importanza, utilizza la strategia di offerta MaximizeConversions. È possibile impostare un CPA (costo per azione) target facoltativo. Scopri di più.

• Se monitori i valori insieme alle conversioni, imposta la strategia di offerta MaximizeConversionValue. È possibile impostare un ROAS (ritorno sulla spesa pubblicitaria) target facoltativo. Scopri di più.

Esempio di codice

Java

/** Creates a MutateOperation that creates a new Performance Max campaign. */
private MutateOperation createPerformanceMaxCampaignOperation(long customerId) {
  Campaign performanceMaxCampaign =
      Campaign.newBuilder()
          .setName("Performance Max campaign #" + getPrintableDateTime())
          // Sets the campaign status as PAUSED. The campaign is the only entity in
          // the mutate request that should have its status set.
          .setStatus(CampaignStatus.PAUSED)
          // All Performance Max campaigns have an advertising_channel_type of
          // PERFORMANCE_MAX. The advertising_channel_sub_type should not be set.
          .setAdvertisingChannelType(AdvertisingChannelType.PERFORMANCE_MAX)
          // Bidding strategy must be set directly on the campaign.
          // Setting a portfolio bidding strategy by resource name is not supported.
          // Max Conversion and Maximize Conversion Value are the only strategies
          // supported for Performance Max campaigns.
          // An optional ROAS (Return on Advertising Spend) can be set for
          // maximize_conversion_value. The ROAS value must be specified as a ratio in
          // the API. It is calculated by dividing "total value" by "total spend".
          // For more information on Maximize Conversion Value, see the support
          // article: http://support.google.com/google-ads/answer/7684216.
          // A targetRoas of 3.5 corresponds to a 350% return on ad spend.
          .setMaximizeConversionValue(
              MaximizeConversionValue.newBuilder().setTargetRoas(3.5).build())
          // Sets the Final URL expansion opt out. This flag is specific to
          // Performance Max campaigns. If opted out (True), only the final URLs in
          // the asset group or URLs specified in the advertiser's Google Merchant
          // Center or business data feeds are targeted.
          // If opted in (False), the entire domain will be targeted. For best
          // results, set this value to false to opt in and allow URL expansions. You
          // can optionally add exclusions to limit traffic to parts of your website.
          .setUrlExpansionOptOut(false)
          // Assigns the resource name with a temporary ID.
          .setResourceName(
              ResourceNames.campaign(customerId, PERFORMANCE_MAX_CAMPAIGN_TEMPORARY_ID))
          // Sets the budget using the given budget resource name.
          .setCampaignBudget(ResourceNames.campaignBudget(customerId, BUDGET_TEMPORARY_ID))
          // Optional fields.
          .setStartDate(new DateTime().plusDays(1).toString("yyyyMMdd"))
          .setEndDate(new DateTime().plusDays(365).toString("yyyyMMdd"))
          .build();

  return MutateOperation.newBuilder()
      .setCampaignOperation(
          CampaignOperation.newBuilder().setCreate(performanceMaxCampaign).build())
      .build();
}
AddPerformanceMaxCampaign.java
      

C#

/// Creates a MutateOperation that creates a new Performance Max campaign.
/// <param name="campaignResourceName">The campaign resource name.</param>
/// <param name="campaignBudgetResourceName">The campaign budget resource name.</param>
/// <returns>A MutateOperations that will create this new campaign.</returns>
private MutateOperation CreatePerformanceMaxCampaignOperation(
    string campaignResourceName,
    string campaignBudgetResourceName)
{
    MutateOperation operation = new MutateOperation()
    {
        CampaignOperation = new CampaignOperation()
        {
            Create = new Campaign()
            {
                Name = "Performance Max campaign #" + ExampleUtilities.GetRandomString(),

                // Set the campaign status as PAUSED. The campaign is the only entity in
                // the mutate request that should have its status set.
                Status = CampaignStatus.Paused,

                // All Performance Max campaigns have an AdvertisingChannelType of
                // PerformanceMax. The AdvertisingChannelSubType should not be set.
                AdvertisingChannelType = AdvertisingChannelType.PerformanceMax,

                // Bidding strategy must be set directly on the campaign. Setting a
                // portfolio bidding strategy by resource name is not supported. Max
                // Conversion and Maximize Conversion Value are the only strategies
                // supported for Performance Max campaigns. BiddingStrategyType is
                // read-only and cannot be set by the API. An optional ROAS (Return on
                // Advertising Spend) can be set to enable the MaximizeConversionValue
                // bidding strategy. The ROAS value must be specified as a ratio in the API.
                // It is calculated by dividing "total value" by "total spend".
                //
                // For more information on Maximize Conversion Value, see the support
                // article:
                // http://support.google.com/google-ads/answer/7684216.
                //
                // A target_roas of 3.5 corresponds to a 350% return on ad spend.
                MaximizeConversionValue = new MaximizeConversionValue()
                {
                    TargetRoas = 3.5
                },

                // Set the Final URL expansion opt out. This flag is specific to
                // Performance Max campaigns. If opted out (True), only the final URLs in
                // the asset group or URLs specified in the advertiser's Google Merchant
                // Center or business data feeds are targeted.
                // If opted in (False), the entire domain will be targeted. For best
                // results, set this value to false to opt in and allow URL expansions. You
                // can optionally add exclusions to limit traffic to parts of your website.
                UrlExpansionOptOut = false,

                // Use the temporary resource name created earlier
                ResourceName = campaignResourceName,

                // Set the budget using the given budget resource name.
                CampaignBudget = campaignBudgetResourceName,

                // Optional fields
                StartDate = DateTime.Now.AddDays(1).ToString("yyyyMMdd"),
                EndDate = DateTime.Now.AddDays(365).ToString("yyyyMMdd")
            }
        }
    };

    return operation;
}
AddPerformanceMaxCampaign.cs
      

PHP

private static function createPerformanceMaxCampaignOperation(int $customerId): MutateOperation
{
    // Creates a mutate operation that creates a campaign operation.
    return new MutateOperation([
        'campaign_operation' => new CampaignOperation([
            'create' => new Campaign([
                'name' => 'Performance Max campaign #' . Helper::getPrintableDatetime(),
                // Assigns the resource name with a temporary ID.
                'resource_name' => ResourceNames::forCampaign(
                    $customerId,
                    self::PERFORMANCE_MAX_CAMPAIGN_TEMPORARY_ID
                ),
                // Sets the budget using the given budget resource name.
                'campaign_budget' => ResourceNames::forCampaignBudget(
                    $customerId,
                    self::BUDGET_TEMPORARY_ID
                ),
                // The campaign is the only entity in the mutate request that should have its
                // status set.
                // Recommendation: Set the campaign to PAUSED when creating it to prevent
                // the ads from immediately serving.
                'status' => CampaignStatus::PAUSED,
                // All Performance Max campaigns have an advertising_channel_type of
                // PERFORMANCE_MAX. The advertising_channel_sub_type should not be set.
                'advertising_channel_type' => AdvertisingChannelType::PERFORMANCE_MAX,

                // Bidding strategy must be set directly on the campaign.
                // Setting a portfolio bidding strategy by resource name is not supported.
                // Max Conversion and Maximize Conversion Value are the only strategies
                // supported for Performance Max campaigns.
                // An optional ROAS (Return on Advertising Spend) can be set for
                // maximize_conversion_value. The ROAS value must be specified as a ratio in
                // the API. It is calculated by dividing "total value" by "total spend".
                // For more information on Maximize Conversion Value, see the support
                // article: http://support.google.com/google-ads/answer/7684216.
                // A target_roas of 3.5 corresponds to a 350% return on ad spend.
                'maximize_conversion_value' => new MaximizeConversionValue([
                    'target_roas' => 3.5
                ]),

                // Sets the Final URL expansion opt out. This flag is specific to
                // Performance Max campaigns. If opted out (true), only the final URLs in
                // the asset group or URLs specified in the advertiser's Google Merchant
                // Center or business data feeds are targeted.
                // If opted in (false), the entire domain will be targeted. For best
                // results, set this value to false to opt in and allow URL expansions. You
                // can optionally add exclusions to limit traffic to parts of your website.
                'url_expansion_opt_out' => false,

                // Optional fields.
                'start_date' => date('Ymd', strtotime('+1 day')),
                'end_date' => date('Ymd', strtotime('+365 days'))
            ])
        ])
    ]);
}
AddPerformanceMaxCampaign.php
      

Python

def create_performance_max_campaign_operation(
    client,
    customer_id,
):
    """Creates a MutateOperation that creates a new Performance Max campaign.

    A temporary ID will be assigned to this campaign so that it can
    be referenced by other objects being created in the same Mutate request.

    Args:
        client: an initialized GoogleAdsClient instance.
        customer_id: a client customer ID.

    Returns:
        a MutateOperation that creates a campaign.
    """
    mutate_operation = client.get_type("MutateOperation")
    campaign = mutate_operation.campaign_operation.create
    campaign.name = f"Performance Max campaign #{uuid4()}"
    # Set the campaign status as PAUSED. The campaign is the only entity in
    # the mutate request that should have its status set.
    campaign.status = client.enums.CampaignStatusEnum.PAUSED
    # All Performance Max campaigns have an advertising_channel_type of
    # PERFORMANCE_MAX. The advertising_channel_sub_type should not be set.
    campaign.advertising_channel_type = (
        client.enums.AdvertisingChannelTypeEnum.PERFORMANCE_MAX
    )
    # Bidding strategy must be set directly on the campaign.
    # Setting a portfolio bidding strategy by resource name is not supported.
    # Max Conversion and Maximize Conversion Value are the only strategies
    # supported for Performance Max campaigns.
    # An optional ROAS (Return on Advertising Spend) can be set for
    # maximize_conversion_value. The ROAS value must be specified as a ratio in
    # the API. It is calculated by dividing "total value" by "total spend".
    # For more information on Maximize Conversion Value, see the support
    # article: http://support.google.com/google-ads/answer/7684216.
    # A target_roas of 3.5 corresponds to a 350% return on ad spend.
    campaign.bidding_strategy_type = (
        client.enums.BiddingStrategyTypeEnum.MAXIMIZE_CONVERSION_VALUE
    )
    campaign.maximize_conversion_value.target_roas = 3.5

    # Set the Final URL expansion opt out. This flag is specific to
    # Performance Max campaigns. If opted out (True), only the final URLs in
    # the asset group or URLs specified in the advertiser's Google Merchant
    # Center or business data feeds are targeted.
    # If opted in (False), the entire domain will be targeted. For best
    # results, set this value to false to opt in and allow URL expansions. You
    # can optionally add exclusions to limit traffic to parts of your website.
    campaign.url_expansion_opt_out = False

    # Assign the resource name with a temporary ID.
    campaign_service = client.get_service("CampaignService")
    campaign.resource_name = campaign_service.campaign_path(
        customer_id, _PERFORMANCE_MAX_CAMPAIGN_TEMPORARY_ID
    )
    # Set the budget using the given budget resource name.
    campaign.campaign_budget = campaign_service.campaign_budget_path(
        customer_id, _BUDGET_TEMPORARY_ID
    )

    # Optional fields
    campaign.start_date = (datetime.now() + timedelta(1)).strftime("%Y%m%d")
    campaign.end_date = (datetime.now() + timedelta(365)).strftime("%Y%m%d")

    return mutate_operation
add_performance_max_campaign.py
      

Ruby

# Creates a MutateOperation that creates a new Performance Max campaign.
#
# A temporary ID will be assigned to this campaign so that it can
# be referenced by other objects being created in the same Mutate request.
def create_performance_max_campaign_operation(client, customer_id)
  client.operation.mutate do |m|
    m.campaign_operation = client.operation.create_resource.campaign do |c|
      c.name = "Performance Max campaign #{SecureRandom.uuid}"
      # Set the campaign status as PAUSED. The campaign is the only entity in
      # the mutate request that should have its status set.
      c.status = :PAUSED
      # All Performance Max campaigns have an advertising_channel_type of
      # PERFORMANCE_MAX. The advertising_channel_sub_type should not be set.
      c.advertising_channel_type = :PERFORMANCE_MAX
      # Bidding strategy must be set directly on the campaign.
      # Setting a portfolio bidding strategy by resource name is not supported.
      # Max Conversion and Maximize Conversion Value are the only strategies
      # supported for Performance Max campaigns.
      # An optional ROAS (Return on Advertising Spend) can be set for
      # maximize_conversion_value. The ROAS value must be specified as a ratio in
      # the API. It is calculated by dividing "total value" by "total spend".
      # For more information on Maximize Conversion Value, see the support
      # article: http://support.google.com/google-ads/answer/7684216.
      # A target_roas of 3.5 corresponds to a 350% return on ad spend.
      c.bidding_strategy_type = :MAXIMIZE_CONVERSION_VALUE
      c.maximize_conversion_value = client.resource.maximize_conversion_value do |mcv|
        mcv.target_roas = 3.5
      end
      # Set the Final URL expansion opt out. This flag is specific to
      # Performance Max campaigns. If opted out (true), only the final URLs in
      # the asset group or URLs specified in the advertiser's Google Merchant
      # Center or business data feeds are targeted.
      # If opted in (false), the entire domain will be targeted. For best
      # results, set this value to false to opt in and allow URL expansions. You
      # can optionally add exclusions to limit traffic to parts of your website.
      c.url_expansion_opt_out = false

      # Assign the resource name with a temporary ID.
      c.resource_name = client.path.campaign(customer_id, PERFORMANCE_MAX_CAMPAIGN_TEMPORARY_ID)
      # Set the budget using the given budget resource name.
      c.campaign_budget = client.path.campaign_budget(customer_id, BUDGET_TEMPORARY_ID)

      # Optional fields
      c.start_date = DateTime.parse((Date.today + 1).to_s).strftime('%Y%m%d')
      c.end_date = DateTime.parse(Date.today.next_year.to_s).strftime('%Y%m%d')
    end
  end
end
add_performance_max_campaign.rb
      

Perl

sub create_performance_max_campaign_operation {
  my ($customer_id) = @_;

  # Create a mutate operation that creates a campaign operation.
  return
    Google::Ads::GoogleAds::V18::Services::GoogleAdsService::MutateOperation->
    new({
      campaignOperation =>
        Google::Ads::GoogleAds::V18::Services::CampaignService::CampaignOperation
        ->new({
          create => Google::Ads::GoogleAds::V18::Resources::Campaign->new({
              # Assign the resource name with a temporary ID.
              resourceName =>
                Google::Ads::GoogleAds::V18::Utils::ResourceNames::campaign(
                $customer_id, PERFORMANCE_MAX_CAMPAIGN_TEMPORARY_ID
                ),
              name => "Performance Max campaign #" . uniqid(),
              # Set the budget using the given budget resource name.
              campaignBudget =>
                Google::Ads::GoogleAds::V18::Utils::ResourceNames::campaign_budget(
                $customer_id, BUDGET_TEMPORARY_ID
                ),
              # Set the campaign status as PAUSED. The campaign is the only entity in
              # the mutate request that should have its status set.
              status =>
                Google::Ads::GoogleAds::V18::Enums::CampaignStatusEnum::PAUSED,
              # All Performance Max campaigns have an advertisingChannelType of
              # PERFORMANCE_MAX. The advertisingChannelSubType should not be set.
              advertisingChannelType => PERFORMANCE_MAX,

              # Bidding strategy must be set directly on the campaign.
              # Setting a portfolio bidding strategy by resource name is not supported.
              # Max Conversion and Maximize Conversion Value are the only strategies
              # supported for Performance Max campaigns.
              # An optional ROAS (Return on Advertising Spend) can be set for
              # maximizeConversionValue. The ROAS value must be specified as a ratio in
              # the API. It is calculated by dividing "total value" by "total spend".
              # For more information on Maximize Conversion Value, see the support
              # article: http://support.google.com/google-ads/answer/7684216.
              # A targetRoas of 3.5 corresponds to a 350% return on ad spend.
              maximizeConversionValue =>
                Google::Ads::GoogleAds::V18::Common::MaximizeConversionValue->
                new({
                  targetRoas => 3.5
                }
                ),

              # Set the final URL expansion opt out. This flag is specific to
              # Performance Max campaigns. If opted out (true), only the final URLs in
              # the asset group or URLs specified in the advertiser's Google Merchant
              # Center or business data feeds are targeted.
              # If opted in (false), the entire domain will be targeted. For best
              # results, set this value to false to opt in and allow URL expansions. You
              # can optionally add exclusions to limit traffic to parts of your website.
              urlExpansionOptOut => "false",

              # Optional fields.
              startDate => strftime("%Y%m%d", localtime(time + 60 * 60 * 24)),
              endDate   =>
                strftime("%Y%m%d", localtime(time + 60 * 60 * 24 * 365)),
            })})});
}
add_performance_max_campaign.pl
      

---

(Facoltativo) Aggiungi obiettivi di conversione personalizzati

Se gli obiettivi di conversione non sono impostati esplicitamente per la campagna, per impostazione predefinita vengono utilizzati gli obiettivi di conversione a livello di cliente. Tuttavia, puoi sostituire gli obiettivi di conversione dei clienti per impostare obiettivi di conversione specifici per la campagna (scopri di più).

Esempio di codice

Java

/** Retrieves the list of customer conversion goals. */
private static List<CustomerConversionGoal> getCustomerConversionGoals(
    GoogleAdsClient googleAdsClient, long customerId) {
  String query =
      "SELECT customer_conversion_goal.category, customer_conversion_goal.origin "
          + "FROM customer_conversion_goal";

  List<CustomerConversionGoal> customerConversionGoals = new ArrayList<>();
  try (GoogleAdsServiceClient googleAdsServiceClient =
      googleAdsClient.getLatestVersion().createGoogleAdsServiceClient()) {
    // The number of conversion goals is typically less than 50, so we use
    // GoogleAdsService.search instead of search_stream.
    SearchPagedResponse response =
        googleAdsServiceClient.search(Long.toString(customerId), query);
    for (GoogleAdsRow googleAdsRow : response.iterateAll()) {
      customerConversionGoals.add(googleAdsRow.getCustomerConversionGoal());
    }
  }

  return customerConversionGoals;
}

/** Creates a list of MutateOperations that override customer conversion goals. */
private static List<MutateOperation> createConversionGoalOperations(
    long customerId, List<CustomerConversionGoal> customerConversionGoals) {
  List<MutateOperation> mutateOperations = new ArrayList<>();
  // To override the customer conversion goals, we will change the
  // biddability of each of the customer conversion goals so that only
  // the desired conversion goal is biddable in this campaign.
  for (CustomerConversionGoal customerConversionGoal : customerConversionGoals) {
    ConversionActionCategory category = customerConversionGoal.getCategory();
    ConversionOrigin origin = customerConversionGoal.getOrigin();
    String campaignConversionGoalResourceName =
        ResourceNames.campaignConversionGoal(
            customerId, PERFORMANCE_MAX_CAMPAIGN_TEMPORARY_ID, category, origin);
    CampaignConversionGoal.Builder campaignConversionGoalBuilder =
        CampaignConversionGoal.newBuilder().setResourceName(campaignConversionGoalResourceName);
    // Change the biddability for the campaign conversion goal.
    // Set biddability to True for the desired (category, origin).
    // Set biddability to False for all other conversion goals.
    // Note:
    //  1- It is assumed that this Conversion Action
    //     (category=PURCHASE, origin=WEBSITE) exists in this account.
    //  2- More than one goal can be biddable if desired. This example
    //     shows only one.
    if (category == ConversionActionCategory.PURCHASE && origin == ConversionOrigin.WEBSITE) {
      campaignConversionGoalBuilder.setBiddable(true);
    } else {
      campaignConversionGoalBuilder.setBiddable(false);
    }
    CampaignConversionGoal campaignConversionGoal = campaignConversionGoalBuilder.build();
    CampaignConversionGoalOperation campaignConversionGoalOperation =
        CampaignConversionGoalOperation.newBuilder()
            .setUpdate(campaignConversionGoal)
            .setUpdateMask(FieldMasks.allSetFieldsOf(campaignConversionGoal))
            .build();
    mutateOperations.add(
        MutateOperation.newBuilder()
            .setCampaignConversionGoalOperation(campaignConversionGoalOperation)
            .build());
  }
  return mutateOperations;
}
AddPerformanceMaxRetailCampaign.java
      

C#

/// <summary>
/// Creates a MutateOperation that links an asset to an asset group.
/// </summary>
/// <param name="fieldType">The field type of the asset to be linked.</param>
/// <param name="assetGroupResourceName">The resource name of the asset group
/// to link the asset to.</param>
/// <param name="assetResourceName">The resource name of the text asset to be
/// linked.</param>
/// <returns>A MutateOperation that links an asset to an asset group.</returns>
private MutateOperation CreateLinkAssetOperation(
    AssetFieldType fieldType,
    string assetGroupResourceName,
    string assetResourceName) => new MutateOperation()
    {
        AssetGroupAssetOperation = new AssetGroupAssetOperation()
        {
            Create = new AssetGroupAsset()
            {
                FieldType = fieldType,
                AssetGroup = assetGroupResourceName,
                Asset = assetResourceName
            }
        }
    };
AddPerformanceMaxRetailCampaign.cs
      

PHP

private static function getCustomerConversionGoals(
    GoogleAdsClient $googleAdsClient,
    int $customerId
): array {
    $customerConversionGoals = [];
    $googleAdsServiceClient = $googleAdsClient->getGoogleAdsServiceClient();
    // Creates a query that retrieves all customer conversion goals.
    $query = 'SELECT customer_conversion_goal.category, customer_conversion_goal.origin ' .
        'FROM customer_conversion_goal';
    // The number of conversion goals is typically less than 50 so we use a search request
    // instead of search stream.
    $response =
        $googleAdsServiceClient->search(SearchGoogleAdsRequest::build($customerId, $query));

    // Iterates over all rows in all pages and builds the list of conversion goals.
    foreach ($response->iterateAllElements() as $googleAdsRow) {
        /** @var GoogleAdsRow $googleAdsRow */
        $customerConversionGoals[] = [
            'category' => $googleAdsRow->getCustomerConversionGoal()->getCategory(),
            'origin' => $googleAdsRow->getCustomerConversionGoal()->getOrigin()
        ];
    }

    return $customerConversionGoals;
}

/**
 * Creates a list of MutateOperations that override customer conversion goals.
 *
 * @param int $customerId the customer ID
 * @param array $customerConversionGoals the list of customer conversion goals that will be
 *      overridden
 * @return MutateOperation[] a list of MutateOperations that update campaign conversion goals
 */
private static function createConversionGoalOperations(
    int $customerId,
    array $customerConversionGoals
): array {
    $operations = [];

    // To override the customer conversion goals, we will change the biddability of each of the
    // customer conversion goals so that only the desired conversion goal is biddable in this
    // campaign.
    foreach ($customerConversionGoals as $customerConversionGoal) {
        $campaignConversionGoal = new CampaignConversionGoal([
            'resource_name' => ResourceNames::forCampaignConversionGoal(
                $customerId,
                self::PERFORMANCE_MAX_CAMPAIGN_TEMPORARY_ID,
                ConversionActionCategory::name($customerConversionGoal['category']),
                ConversionOrigin::name($customerConversionGoal['origin'])
            )
        ]);
        // Changes the biddability for the campaign conversion goal.
        // Sets biddability to true for the desired (category, origin).
        // Sets biddability to false for all other conversion goals.
        // Note:
        //  1- It is assumed that this Conversion Action
        //     (category=PURCHASE, origin=WEBSITE) exists in this account.
        //  2- More than one goal can be biddable if desired. This example
        //     shows only one.
        if (
            $customerConversionGoal["category"] === ConversionActionCategory::PURCHASE
            && $customerConversionGoal["origin"] === ConversionOrigin::WEBSITE
        ) {
            $campaignConversionGoal->setBiddable(true);
        } else {
            $campaignConversionGoal->setBiddable(false);
        }

        $operations[] = new MutateOperation([
            'campaign_conversion_goal_operation' => new CampaignConversionGoalOperation([
                'update' => $campaignConversionGoal,
                // Sets the update mask on the operation. Here the update mask will be a list
                // of all the fields that were set on the update object.
                'update_mask' => FieldMasks::allSetFieldsOf($campaignConversionGoal)
            ])
        ]);
    }

    return $operations;
}
AddPerformanceMaxRetailCampaign.php
      

Python

def get_customer_conversion_goals(client, customer_id):
    """Retrieves the list of customer conversion goals.

    Args:
        client: an initialized GoogleAdsClient instance.
        customer_id: a client customer ID.

    Returns:
        a list of dicts containing the category and origin of customer
        conversion goals.
    """
    ga_service = client.get_service("GoogleAdsService")
    customer_conversion_goals = []
    query = """
            SELECT
              customer_conversion_goal.category,
              customer_conversion_goal.origin
            FROM customer_conversion_goal
            """
    # The number of conversion goals is typically less than 50 so we use
    # GoogleAdsService.search instead of search_stream.
    search_request = client.get_type("SearchGoogleAdsRequest")
    search_request.customer_id = customer_id
    search_request.query = query
    results = ga_service.search(request=search_request)

    # Iterate over the results and build the list of conversion goals.
    for row in results:
        customer_conversion_goals.append(
            {
                "category": row.customer_conversion_goal.category,
                "origin": row.customer_conversion_goal.origin,
            }
        )
    return customer_conversion_goals


def create_conversion_goal_operations(
    client,
    customer_id,
    customer_conversion_goals,
):
    """Creates a list of MutateOperations that override customer conversion goals.

    Args:
        client: an initialized GoogleAdsClient instance.
        customer_id: a client customer ID.
        customer_conversion_goals: the list of customer conversion goals that
          will be overridden.

    Returns:
        MutateOperations that update campaign conversion goals.
    """
    campaign_conversion_goal_service = client.get_service(
        "CampaignConversionGoalService"
    )
    operations = []

    # To override the customer conversion goals, we will change the
    # biddability of each of the customer conversion goals so that only
    # the desired conversion goal is biddable in this campaign.
    for customer_conversion_goal in customer_conversion_goals:
        mutate_operation = client.get_type("MutateOperation")
        campaign_conversion_goal = (
            mutate_operation.campaign_conversion_goal_operation.update
        )

        campaign_conversion_goal.resource_name = (
            campaign_conversion_goal_service.campaign_conversion_goal_path(
                customer_id,
                _PERFORMANCE_MAX_CAMPAIGN_TEMPORARY_ID,
                customer_conversion_goal["category"].name,
                customer_conversion_goal["origin"].name,
            )
        )
        # Change the biddability for the campaign conversion goal.
        # Set biddability to True for the desired (category, origin).
        # Set biddability to False for all other conversion goals.
        # Note:
        #  1- It is assumed that this Conversion Action
        #     (category=PURCHASE, origin=WEBSITE) exists in this account.
        #  2- More than one goal can be biddable if desired. This example
        #     shows only one.
        if (
            customer_conversion_goal["category"]
            == client.enums.ConversionActionCategoryEnum.PURCHASE
            and customer_conversion_goal["origin"]
            == client.enums.ConversionOriginEnum.WEBSITE
        ):
            biddable = True
        else:
            biddable = False
        campaign_conversion_goal.biddable = biddable
        field_mask = protobuf_helpers.field_mask(
            None, campaign_conversion_goal._pb
        )
        client.copy_from(
            mutate_operation.campaign_conversion_goal_operation.update_mask,
            field_mask,
        )
        operations.append(mutate_operation)

    return operations
add_performance_max_retail_campaign.py
      

Ruby

def _get_customer_conversion_goals(client, customer_id)
  query = <<~EOD
    SELECT
        customer_conversion_goal.category,
        customer_conversion_goal.origin
    FROM customer_conversion_goal
  EOD

  customer_conversion_goals = []

  ga_service = client.service.google_ads
  # The number of conversion goals is typically less than 50 so we use
  # GoogleAdsService.search instead of search_stream.
  response = ga_service.search(
      customer_id: customer_id,
      query: query,
  )

  # Iterate over the results and build the list of conversion goals.
  response.each do |row|
    customer_conversion_goals << {
        "category" => row.customer_conversion_goal.category,
        "origin" => row.customer_conversion_goal.origin
    }
  end

  customer_conversion_goals
end

def create_conversion_goal_operations(client, customer_id, customer_conversion_goals)
  campaign_conversion_goal_service = client.service.campaign_conversion_goal

  operations = []

  # To override the customer conversion goals, we will change the
  # biddability of each of the customer conversion goals so that only
  # the desired conversion goal is biddable in this campaign.
  customer_conversion_goals.each do |customer_conversion_goal|
    operations << client.operation.mutate do |m|
        m.campaign_conversion_goal_operation = client.operation.campaign_conversion_goal do |op|
          op.update = client.resource.campaign_conversion_goal do |ccg|
              ccg.resource_name = client.path.campaign_conversion_goal(
                  customer_id,
                  PERFORMANCE_MAX_CAMPAIGN_TEMPORARY_ID,
                  customer_conversion_goal["category"].to_s,
                  customer_conversion_goal["origin"].to_s)
              # Change the biddability for the campaign conversion goal.
              # Set biddability to True for the desired (category, origin).
              # Set biddability to False for all other conversion goals.
              # Note:
              #  1- It is assumed that this Conversion Action
              #     (category=PURCHASE, origin=WEBSITE) exists in this account.
              #  2- More than one goal can be biddable if desired. This example
              #     shows only one.
              ccg.biddable = (customer_conversion_goal["category"] == :PURCHASE &&
                  customer_conversion_goal["origin"] == :WEBSITE)
          end
          op.update_mask = Google::Ads::GoogleAds::FieldMaskUtil.all_set_fields_of(op.update)
        end
    end
  end

  operations
end
add_performance_max_retail_campaign.rb
      

Perl

sub get_customer_conversion_goals {
  my ($api_client, $customer_id) = @_;

  my $customer_conversion_goals = [];
  # Create a query that retrieves all customer conversion goals.
  my $query =
    "SELECT customer_conversion_goal.category, customer_conversion_goal.origin "
    . "FROM customer_conversion_goal";
  # The number of conversion goals is typically less than 50 so we use
  # GoogleAdsService->search() method instead of search_stream().
  my $search_response = $api_client->GoogleAdsService()->search({
    customerId => $customer_id,
    query      => $query
  });

  # Iterate over the results and build the list of conversion goals.
  foreach my $google_ads_row (@{$search_response->{results}}) {
    push @$customer_conversion_goals,
      {
      category => $google_ads_row->{customerConversionGoal}{category},
      origin   => $google_ads_row->{customerConversionGoal}{origin}};
  }

  return $customer_conversion_goals;
}

# Creates a list of MutateOperations that override customer conversion goals.
sub create_conversion_goal_operations {
  my ($customer_id, $customer_conversion_goals) = @_;

  my $operations = [];
  # To override the customer conversion goals, we will change the biddability of
  # each of the customer conversion goals so that only the desired conversion goal
  # is biddable in this campaign.
  foreach my $customer_conversion_goal (@$customer_conversion_goals) {
    my $campaign_conversion_goal =
      Google::Ads::GoogleAds::V18::Resources::CampaignConversionGoal->new({
        resourceName =>
          Google::Ads::GoogleAds::V18::Utils::ResourceNames::campaign_conversion_goal(
          $customer_id,
          PERFORMANCE_MAX_CAMPAIGN_TEMPORARY_ID,
          $customer_conversion_goal->{category},
          $customer_conversion_goal->{origin})});
    # Change the biddability for the campaign conversion goal.
    # Set biddability to true for the desired (category, origin).
    # Set biddability to false for all other conversion goals.
    # Note:
    #  1- It is assumed that this Conversion Action
    #     (category=PURCHASE, origin=WEBSITE) exists in this account.
    #  2- More than one goal can be biddable if desired. This example
    #     shows only one.
    if ( $customer_conversion_goal->{category} eq PURCHASE
      && $customer_conversion_goal->{origin} eq WEBSITE)
    {
      $campaign_conversion_goal->{biddable} = "true";
    } else {
      $campaign_conversion_goal->{biddable} = "false";
    }

    push @$operations,
      Google::Ads::GoogleAds::V18::Services::GoogleAdsService::MutateOperation
      ->new({
        campaignConversionGoalOperation =>
          Google::Ads::GoogleAds::V18::Services::CampaignConversionGoalService::CampaignConversionGoalOperation
          ->new({
            update => $campaign_conversion_goal,
            # Set the update mask on the operation. Here the update mask will be
            # a list of all the fields that were set on the update object.
            updateMask => all_set_fields_of($campaign_conversion_goal)})});
  }

  return $operations;
}
add_performance_max_retail_campaign.pl
      

---

Aggiungere il targeting della campagna (facoltativo)

Le campagne Performance Max supportano i seguenti tipi di criteri:

• AD_SCHEDULE (scopri di più)
• BRAND
• LANGUAGE (scopri di più)
• LOCATION (scopri di più)
• LOCATION_GROUP (scopri di più)
• WEBPAGE

Esempio di codice

Java

/** Creates a list of MutateOperations that create new campaign criteria. */
private List<MutateOperation> createCampaignCriterionOperations(long customerId) {
  String campaignResourceName =
      ResourceNames.campaign(customerId, PERFORMANCE_MAX_CAMPAIGN_TEMPORARY_ID);
  List<CampaignCriterion> campaignCriteria = new ArrayList<>();
  // Sets the LOCATION campaign criteria.
  // Targets all of New York City except Brooklyn.
  // Location IDs are listed here:
  // https://developers.google.com/google-ads/api/reference/data/geotargets
  // and they can also be retrieved using the GeoTargetConstantService as shown
  // here: https://developers.google.com/google-ads/api/docs/targeting/location-targeting
  //
  // We will add one positive location target for New York City (ID=1023191)
  // and one negative location target for Brooklyn (ID=1022762).
  // First, adds the positive (negative = False) for New York City.
  campaignCriteria.add(
      CampaignCriterion.newBuilder()
          .setCampaign(campaignResourceName)
          .setLocation(
              LocationInfo.newBuilder()
                  .setGeoTargetConstant(ResourceNames.geoTargetConstant(1023191))
                  .build())
          .setNegative(false)
          .build());
  // Next adds the negative target for Brooklyn.
  campaignCriteria.add(
      CampaignCriterion.newBuilder()
          .setCampaign(campaignResourceName)
          .setLocation(
              LocationInfo.newBuilder()
                  .setGeoTargetConstant(ResourceNames.geoTargetConstant(1022762))
                  .build())
          .setNegative(true)
          .build());
  // Sets the LANGUAGE campaign criterion.
  campaignCriteria.add(
      CampaignCriterion.newBuilder()
          .setCampaign(campaignResourceName)
          // Sets the language.
          // For a list of all language codes, see:
          // https://developers.google.com/google-ads/api/reference/data/codes-formats#expandable-7
          .setLanguage(
              LanguageInfo.newBuilder()
                  .setLanguageConstant(ResourceNames.languageConstant(1000)) // English
                  .build())
          .build());
  // Returns a list of mutate operations with one operation per criterion.
  return campaignCriteria.stream()
      .map(
          criterion ->
              MutateOperation.newBuilder()
                  .setCampaignCriterionOperation(
                      CampaignCriterionOperation.newBuilder().setCreate(criterion).build())
                  .build())
      .collect(Collectors.toList());
}
AddPerformanceMaxCampaign.java
      

C#

/// <summary>
/// Creates a list of MutateOperations that create new campaign criteria.
/// </summary>
/// <param name="campaignResourceName">The campaign resource name.</param>
/// <returns>A list of MutateOperations that create new campaign criteria.</returns>
private List<MutateOperation> CreateCampaignCriterionOperations(
    string campaignResourceName)
{
    List<MutateOperation> operations = new List<MutateOperation>();

    // Set the LOCATION campaign criteria.
    // Target all of New York City except Brooklyn.
    // Location IDs are listed here:
    // https://developers.google.com/google-ads/api/reference/data/geotargets
    // and they can also be retrieved using the GeoTargetConstantService as shown
    // here: https://developers.google.com/google-ads/api/docs/targeting/location-targeting
    //
    // We will add one positive location target for New York City (ID=1023191)
    // and one negative location target for Brooklyn (ID=1022762).
    // First, add the positive (negative = False) for New York City.
    MutateOperation operation1 = new MutateOperation()
    {
        CampaignCriterionOperation = new CampaignCriterionOperation()
        {
            Create = new CampaignCriterion()
            {
                Campaign = campaignResourceName,
                Location = new LocationInfo()
                {
                    GeoTargetConstant = ResourceNames.GeoTargetConstant(1023191)
                },

                Negative = false
            }
        }
    };

    operations.Add(operation1);

    // Next add the negative target for Brooklyn.
    MutateOperation operation2 = new MutateOperation()
    {
        CampaignCriterionOperation = new CampaignCriterionOperation()
        {
            Create = new CampaignCriterion()
            {
                Campaign = campaignResourceName,
                Location = new LocationInfo()
                {
                    GeoTargetConstant = ResourceNames.GeoTargetConstant(1022762)
                },

                Negative = true
            }
        }
    };

    operations.Add(operation2);

    // Set the LANGUAGE campaign criterion.
    MutateOperation operation3 = new MutateOperation()
    {
        CampaignCriterionOperation = new CampaignCriterionOperation()
        {
            Create = new CampaignCriterion()
            {
                Campaign = campaignResourceName,

                // Set the language.
                // For a list of all language codes, see:
                // https://developers.google.com/google-ads/api/reference/data/codes-formats#expandable-7
                Language = new LanguageInfo()
                {
                    LanguageConstant = ResourceNames.LanguageConstant(1000) // English
                },
            }
        }
    };

    operations.Add(operation3);

    return operations;
}
AddPerformanceMaxCampaign.cs
      

PHP

private static function createCampaignCriterionOperations(int $customerId): array
{
    $operations = [];
    // Set the LOCATION campaign criteria.
    // Target all of New York City except Brooklyn.
    // Location IDs are listed here:
    // https://developers.google.com/google-ads/api/reference/data/geotargets
    // and they can also be retrieved using the GeoTargetConstantService as shown
    // here: https://developers.google.com/google-ads/api/docs/targeting/location-targeting
    //
    // We will add one positive location target for New York City (ID=1023191)
    // and one negative location target for Brooklyn (ID=1022762).
    // First, adds the positive (negative = false) for New York City.
    $operations[] = new MutateOperation([
        'campaign_criterion_operation' => new CampaignCriterionOperation([
            'create' => new CampaignCriterion([
                'campaign' => ResourceNames::forCampaign(
                    $customerId,
                    self::PERFORMANCE_MAX_CAMPAIGN_TEMPORARY_ID
                ),
                'location' => new LocationInfo([
                    'geo_target_constant' => ResourceNames::forGeoTargetConstant(1023191)
                ]),
                'negative' => false
            ])
        ])
    ]);

    // Next adds the negative target for Brooklyn.
    $operations[] = new MutateOperation([
        'campaign_criterion_operation' => new CampaignCriterionOperation([
            'create' => new CampaignCriterion([
                'campaign' => ResourceNames::forCampaign(
                    $customerId,
                    self::PERFORMANCE_MAX_CAMPAIGN_TEMPORARY_ID
                ),
                'location' => new LocationInfo([
                    'geo_target_constant' => ResourceNames::forGeoTargetConstant(1022762)
                ]),
                'negative' => true
            ])
        ])
    ]);

    // Sets the LANGUAGE campaign criterion.
    $operations[] = new MutateOperation([
        'campaign_criterion_operation' => new CampaignCriterionOperation([
            'create' => new CampaignCriterion([
                'campaign' => ResourceNames::forCampaign(
                    $customerId,
                    self::PERFORMANCE_MAX_CAMPAIGN_TEMPORARY_ID
                ),
                // Set the language.
                // For a list of all language codes, see:
                // https://developers.google.com/google-ads/api/reference/data/codes-formats#expandable-7
                'language' => new LanguageInfo([
                    'language_constant' => ResourceNames::forLanguageConstant(1000)  // English
                ])
            ])
        ])
    ]);

    return $operations;
}
AddPerformanceMaxCampaign.php
      

Python

def create_campaign_criterion_operations(
    client,
    customer_id,
):
    """Creates a list of MutateOperations that create new campaign criteria.

    Args:
        client: an initialized GoogleAdsClient instance.
        customer_id: a client customer ID.

    Returns:
        a list of MutateOperations that create new campaign criteria.
    """
    campaign_service = client.get_service("CampaignService")
    geo_target_constant_service = client.get_service("GeoTargetConstantService")
    googleads_service = client.get_service("GoogleAdsService")

    operations = []
    # Set the LOCATION campaign criteria.
    # Target all of New York City except Brooklyn.
    # Location IDs are listed here:
    # https://developers.google.com/google-ads/api/reference/data/geotargets
    # and they can also be retrieved using the GeoTargetConstantService as shown
    # here: https://developers.google.com/google-ads/api/docs/targeting/location-targeting
    #
    # We will add one positive location target for New York City (ID=1023191)
    # and one negative location target for Brooklyn (ID=1022762).
    # First, add the positive (negative = False) for New York City.
    mutate_operation = client.get_type("MutateOperation")
    campaign_criterion = mutate_operation.campaign_criterion_operation.create
    campaign_criterion.campaign = campaign_service.campaign_path(
        customer_id, _PERFORMANCE_MAX_CAMPAIGN_TEMPORARY_ID
    )
    campaign_criterion.location.geo_target_constant = (
        geo_target_constant_service.geo_target_constant_path("1023191")
    )
    campaign_criterion.negative = False
    operations.append(mutate_operation)

    # Next add the negative target for Brooklyn.
    mutate_operation = client.get_type("MutateOperation")
    campaign_criterion = mutate_operation.campaign_criterion_operation.create
    campaign_criterion.campaign = campaign_service.campaign_path(
        customer_id, _PERFORMANCE_MAX_CAMPAIGN_TEMPORARY_ID
    )
    campaign_criterion.location.geo_target_constant = (
        geo_target_constant_service.geo_target_constant_path("1022762")
    )
    campaign_criterion.negative = True
    operations.append(mutate_operation)

    # Set the LANGUAGE campaign criterion.
    mutate_operation = client.get_type("MutateOperation")
    campaign_criterion = mutate_operation.campaign_criterion_operation.create
    campaign_criterion.campaign = campaign_service.campaign_path(
        customer_id, _PERFORMANCE_MAX_CAMPAIGN_TEMPORARY_ID
    )
    # Set the language.
    # For a list of all language codes, see:
    # https://developers.google.com/google-ads/api/reference/data/codes-formats#expandable-7
    campaign_criterion.language.language_constant = (
        googleads_service.language_constant_path("1000")
    )  # English
    operations.append(mutate_operation)

    return operations
add_performance_max_campaign.py
      

Ruby

# Creates a list of MutateOperations that create new campaign criteria.
def create_campaign_criterion_operations(client, customer_id)
  operations = []

  # Set the LOCATION campaign criteria.
  # Target all of New York City except Brooklyn.
  # Location IDs are listed here:
  # https://developers.google.com/google-ads/api/reference/data/geotargets
  # and they can also be retrieved using the GeoTargetConstantService as shown
  # here: https://developers.google.com/google-ads/api/docs/targeting/location-targeting
  #
  # We will add one positive location target for New York City (ID=1023191)
  # and one negative location target for Brooklyn (ID=1022762).
  # First, add the positive (negative = false) for New York City.
  operations << client.operation.mutate do |m|
    m.campaign_criterion_operation =
      client.operation.create_resource.campaign_criterion do |cc|
      cc.campaign = client.path.campaign(
        customer_id, PERFORMANCE_MAX_CAMPAIGN_TEMPORARY_ID)
      cc.location = client.resource.location_info do  |li|
        li.geo_target_constant = client.path.geo_target_constant("1023191")
      end
      cc.negative = false
    end
  end

  # Next add the negative target for Brooklyn.
  operations << client.operation.mutate do |m|
    m.campaign_criterion_operation =
      client.operation.create_resource.campaign_criterion do |cc|
      cc.campaign = client.path.campaign(
        customer_id, PERFORMANCE_MAX_CAMPAIGN_TEMPORARY_ID)
      cc.location = client.resource.location_info do  |li|
        li.geo_target_constant = client.path.geo_target_constant("1022762")
      end
      cc.negative = true
    end
  end

  # Set the LANGUAGE campaign criterion.
  operations << client.operation.mutate do |m|
    m.campaign_criterion_operation =
      client.operation.create_resource.campaign_criterion do |cc|
      cc.campaign = client.path.campaign(
        customer_id, PERFORMANCE_MAX_CAMPAIGN_TEMPORARY_ID)
      # Set the language.
      # For a list of all language codes, see:
      # https://developers.google.com/google-ads/api/reference/data/codes-formats#expandable-7
      cc.language = client.resource.language_info do |li|
        li.language_constant = client.path.language_constant("1000")  # English
      end
    end
  end

  operations
end
add_performance_max_campaign.rb
      

Perl

sub create_campaign_criterion_operations {
  my ($customer_id) = @_;

  my $operations = [];
  # Set the LOCATION campaign criteria.
  # Target all of New York City except Brooklyn.
  # Location IDs are listed here:
  # https://developers.google.com/google-ads/api/reference/data/geotargets
  # and they can also be retrieved using the GeoTargetConstantService as shown
  # here: https://developers.google.com/google-ads/api/docs/targeting/location-targeting.
  #
  # We will add one positive location target for New York City (ID=1023191)
  # and one negative location target for Brooklyn (ID=1022762).
  # First, add the positive (negative = false) for New York City.
  push @$operations,
    Google::Ads::GoogleAds::V18::Services::GoogleAdsService::MutateOperation->
    new({
      campaignCriterionOperation =>
        Google::Ads::GoogleAds::V18::Services::CampaignCriterionService::CampaignCriterionOperation
        ->new({
          create =>
            Google::Ads::GoogleAds::V18::Resources::CampaignCriterion->new({
              campaign =>
                Google::Ads::GoogleAds::V18::Utils::ResourceNames::campaign(
                $customer_id, PERFORMANCE_MAX_CAMPAIGN_TEMPORARY_ID
                ),
              location =>
                Google::Ads::GoogleAds::V18::Common::LocationInfo->new({
                  geoTargetConstant =>
                    Google::Ads::GoogleAds::V18::Utils::ResourceNames::geo_target_constant(
                    1023191)}
                ),
              negative => "false"
            })})});

  # Next add the negative target for Brooklyn.
  push @$operations,
    Google::Ads::GoogleAds::V18::Services::GoogleAdsService::MutateOperation->
    new({
      campaignCriterionOperation =>
        Google::Ads::GoogleAds::V18::Services::CampaignCriterionService::CampaignCriterionOperation
        ->new({
          create =>
            Google::Ads::GoogleAds::V18::Resources::CampaignCriterion->new({
              campaign =>
                Google::Ads::GoogleAds::V18::Utils::ResourceNames::campaign(
                $customer_id, PERFORMANCE_MAX_CAMPAIGN_TEMPORARY_ID
                ),
              location =>
                Google::Ads::GoogleAds::V18::Common::LocationInfo->new({
                  geoTargetConstant =>
                    Google::Ads::GoogleAds::V18::Utils::ResourceNames::geo_target_constant(
                    1022762)}
                ),
              negative => "true"
            })})});

  # Set the LANGUAGE campaign criterion.
  push @$operations,
    Google::Ads::GoogleAds::V18::Services::GoogleAdsService::MutateOperation->
    new({
      campaignCriterionOperation =>
        Google::Ads::GoogleAds::V18::Services::CampaignCriterionService::CampaignCriterionOperation
        ->new({
          create =>
            Google::Ads::GoogleAds::V18::Resources::CampaignCriterion->new({
              campaign =>
                Google::Ads::GoogleAds::V18::Utils::ResourceNames::campaign(
                $customer_id, PERFORMANCE_MAX_CAMPAIGN_TEMPORARY_ID
                ),
              # Set the language.
              # For a list of all language codes, see:
              # https://developers.google.com/google-ads/api/reference/data/codes-formats#expandable-7.
              language =>
                Google::Ads::GoogleAds::V18::Common::LanguageInfo->new({
                  languageConstant =>
                    Google::Ads::GoogleAds::V18::Utils::ResourceNames::language_constant(
                    1000)    # English
                })})})});

  return $operations;
}
add_performance_max_campaign.pl
      

---

Asset e gruppi di asset

Aggiungere asset a livello di account

Le campagne Performance Max hanno alcune caratteristiche uniche in merito agli asset.

1. Esiste un numero minimo obbligatorio di gli asset forniti dall'inserzionista di diversi tipi.
2. Gli asset sono raggruppati in una raccolta chiamata AssetGroup, che è esclusiva delle campagne Performance Max.
3. Alcuni asset vengono generati automaticamente da Google utilizzando il machine learning.

Nota: poiché gli asset vengono creati a livello di cliente, puoi scegliere di aggiungerli prima di creare la campagna. Tuttavia, puoi anche includere la creazione di asset nella richiesta di modifica collettiva che crea la campagna Performance Max.

Esempio di codice

Java

/** Creates multiple text assets and returns the list of resource names. */
private List<String> createMultipleTextAssets(
    GoogleAdsClient googleAdsClient, long customerId, List<String> texts) {
  List<MutateOperation> mutateOperations = new ArrayList<>();
  for (String text : texts) {
    Asset asset = Asset.newBuilder().setTextAsset(TextAsset.newBuilder().setText(text)).build();
    AssetOperation assetOperation = AssetOperation.newBuilder().setCreate(asset).build();
    mutateOperations.add(MutateOperation.newBuilder().setAssetOperation(assetOperation).build());
  }

  List<String> assetResourceNames = new ArrayList<>();
  // Creates the service client.
  try (GoogleAdsServiceClient googleAdsServiceClient =
      googleAdsClient.getLatestVersion().createGoogleAdsServiceClient()) {
    // Sends the operations in a single Mutate request.
    MutateGoogleAdsResponse response =
        googleAdsServiceClient.mutate(Long.toString(customerId), mutateOperations);
    for (MutateOperationResponse result : response.getMutateOperationResponsesList()) {
      if (result.hasAssetResult()) {
        assetResourceNames.add(result.getAssetResult().getResourceName());
      }
    }
    printResponseDetails(response);
  }
  return assetResourceNames;
}
AddPerformanceMaxCampaign.java
      

C#

/// <summary>
/// Creates multiple text assets and returns the list of resource names.
/// </summary>
/// <param name="client">The Google Ads Client.</param>
/// <param name="customerId">The customer's ID.</param>
/// <param name="texts">The texts to add.</param>
/// <returns>A list of asset resource names.</returns>
private List<string> CreateMultipleTextAssets(
    GoogleAdsClient client,
    long customerId,
    string[] texts)
{
    // Get the GoogleAdsService.
    GoogleAdsServiceClient googleAdsServiceClient =
        client.GetService(Services.V18.GoogleAdsService);

    MutateGoogleAdsRequest request = new MutateGoogleAdsRequest()
    {
        CustomerId = customerId.ToString()
    };

    foreach (string text in texts)
    {
        request.MutateOperations.Add(
            new MutateOperation()
            {
                AssetOperation = new AssetOperation()
                {
                    Create = new Asset()
                    {
                        TextAsset = new TextAsset()
                        {
                            Text = text
                        }
                    }
                }
            }
        );
    }

    // Send the operations in a single Mutate request.
    MutateGoogleAdsResponse response = googleAdsServiceClient.Mutate(request);

    List<string> assetResourceNames = new List<string>();

    foreach (MutateOperationResponse operationResponse in response.MutateOperationResponses)
    {
        MutateAssetResult assetResult = operationResponse.AssetResult;
        assetResourceNames.Add(assetResult.ResourceName);
    }

    PrintResponseDetails(response);

    return assetResourceNames;
}
AddPerformanceMaxCampaign.cs
      

PHP

private static function createMultipleTextAssets(
    GoogleAdsClient $googleAdsClient,
    int $customerId,
    array $texts
): array {
    // Here again, we use the GoogleAdService to create multiple text assets in a single
    // request.
    $operations = [];
    foreach ($texts as $text) {
        // Creates a mutate operation for a text asset.
        $operations[] = new MutateOperation([
            'asset_operation' => new AssetOperation([
                'create' => new Asset(['text_asset' => new TextAsset(['text' => $text])])
            ])
        ]);
    }

    // Issues a mutate request to add all assets.
    $googleAdsService = $googleAdsClient->getGoogleAdsServiceClient();
    /** @var MutateGoogleAdsResponse $mutateGoogleAdsResponse */
    $mutateGoogleAdsResponse =
        $googleAdsService->mutate(MutateGoogleAdsRequest::build($customerId, $operations));

    $assetResourceNames = [];
    foreach ($mutateGoogleAdsResponse->getMutateOperationResponses() as $response) {
        /** @var MutateOperationResponse $response */
        $assetResourceNames[] = $response->getAssetResult()->getResourceName();
    }
    self::printResponseDetails($mutateGoogleAdsResponse);

    return $assetResourceNames;
}
AddPerformanceMaxCampaign.php
      

Python

def create_multiple_text_assets(client, customer_id, texts):
    """Creates multiple text assets and returns the list of resource names.

    Args:
        client: an initialized GoogleAdsClient instance.
        customer_id: a client customer ID.
        texts: a list of strings, each of which will be used to create a text
          asset.

    Returns:
        asset_resource_names: a list of asset resource names.
    """
    # Here again we use the GoogleAdService to create multiple text
    # assets in a single request.
    googleads_service = client.get_service("GoogleAdsService")

    operations = []
    for text in texts:
        mutate_operation = client.get_type("MutateOperation")
        asset = mutate_operation.asset_operation.create
        asset.text_asset.text = text
        operations.append(mutate_operation)

    # Send the operations in a single Mutate request.
    response = googleads_service.mutate(
        customer_id=customer_id,
        mutate_operations=operations,
    )
    asset_resource_names = []
    for result in response.mutate_operation_responses:
        if result._pb.HasField("asset_result"):
            asset_resource_names.append(result.asset_result.resource_name)
    print_response_details(response)
    return asset_resource_names
add_performance_max_campaign.py
      

Ruby

# Creates multiple text assets and returns the list of resource names.
def create_multiple_text_assets(client, customer_id, texts)
  operations = texts.map do |text|
    client.operation.mutate do |m|
      m.asset_operation = client.operation.create_resource.asset do |asset|
        asset.text_asset = client.resource.text_asset do |text_asset|
          text_asset.text = text
        end
      end
    end
  end

  # Send the operations in a single Mutate request.
  response = client.service.google_ads.mutate(
    customer_id: customer_id,
    mutate_operations: operations,
  )

  asset_resource_names = []
  response.mutate_operation_responses.each do |result|
    if result.asset_result
      asset_resource_names.append(result.asset_result.resource_name)
    end
  end
  print_response_details(response)
  asset_resource_names
end
add_performance_max_campaign.rb
      

Perl

sub create_multiple_text_assets {
  my ($api_client, $customer_id, $texts) = @_;

  # Here again we use the GoogleAdService to create multiple text assets in a
  # single request.
  my $operations = [];
  foreach my $text (@$texts) {
    # Create a mutate operation for a text asset.
    push @$operations,
      Google::Ads::GoogleAds::V18::Services::GoogleAdsService::MutateOperation
      ->new({
        assetOperation =>
          Google::Ads::GoogleAds::V18::Services::AssetService::AssetOperation->
          new({
            create => Google::Ads::GoogleAds::V18::Resources::Asset->new({
                textAsset =>
                  Google::Ads::GoogleAds::V18::Common::TextAsset->new({
                    text => $text
                  })})})});
  }

  # Issue a mutate request to add all assets.
  my $mutate_google_ads_response = $api_client->GoogleAdsService()->mutate({
    customerId       => $customer_id,
    mutateOperations => $operations
  });

  my $asset_resource_names = [];
  foreach
    my $response (@{$mutate_google_ads_response->{mutateOperationResponses}})
  {
    push @$asset_resource_names, $response->{assetResult}{resourceName};
  }
  print_response_details($mutate_google_ads_response);

  return $asset_resource_names;
}
add_performance_max_campaign.pl
      

---

Aggiungi gruppi di asset

Un gruppo di asset è una raccolta di asset incentrata su un tema o correlata a un pubblico di destinazione. Il gruppo di asset viene utilizzato per combinare tutti gli annunci e creare un inventario per tutti i formati dell'annuncio adatti al tuo obiettivo pubblicitario. Scopri di più sui gruppi di asset.

I gruppi di asset contengono uno o più URL finali. È necessario almeno un URL finale. Utilizza l'URL più pertinente al percorso di conversione per il gruppo di asset e gli scopi della campagna specificati.

Importante: AssetGroups e AssetGroupAssets che collegano gli asset minimi richiesti a ciascun AssetGroup devono essere creati insieme in un'unica richiesta di modifica collettiva.

Esempio di codice

Java

/** Creates a list of MutateOperations that create a new AssetGroup. */
private List<MutateOperation> createAssetGroupOperations(
    long customerId,
    String assetGroupResourceName,
    List<String> headlineAssetResourceNames,
    List<String> descriptionAssetResourceNames)
    throws IOException {
  List<MutateOperation> mutateOperations = new ArrayList<>();
  String campaignResourceName =
      ResourceNames.campaign(customerId, PERFORMANCE_MAX_CAMPAIGN_TEMPORARY_ID);
  // Creates the AssetGroup.
  AssetGroup assetGroup =
      AssetGroup.newBuilder()
          .setName("Performance Max asset group #" + getPrintableDateTime())
          .setCampaign(campaignResourceName)
          .addFinalUrls("http://www.example.com")
          .addFinalMobileUrls("http://www.example.com")
          .setStatus(AssetGroupStatus.PAUSED)
          .setResourceName(assetGroupResourceName)
          .build();
  AssetGroupOperation assetGroupOperation =
      AssetGroupOperation.newBuilder().setCreate(assetGroup).build();
  mutateOperations.add(
      MutateOperation.newBuilder().setAssetGroupOperation(assetGroupOperation).build());

  // For the list of required assets for a Performance Max campaign, see
  // https://developers.google.com/google-ads/api/docs/performance-max/assets

  // An AssetGroup is linked to an Asset by creating a new AssetGroupAsset
  // and providing:
  //   the resource name of the AssetGroup
  //   the resource name of the Asset
  //   the field_type of the Asset in this AssetGroup.

  // To learn more about AssetGroups, see
  // https://developers.google.com/google-ads/api/docs/performance-max/asset-groups

  // Links the previously created multiple text assets.

  // Links the headline assets.
  for (String resourceName : headlineAssetResourceNames) {
    AssetGroupAsset assetGroupAsset =
        AssetGroupAsset.newBuilder()
            .setFieldType(AssetFieldType.HEADLINE)
            .setAssetGroup(assetGroupResourceName)
            .setAsset(resourceName)
            .build();
    AssetGroupAssetOperation assetGroupAssetOperation =
        AssetGroupAssetOperation.newBuilder().setCreate(assetGroupAsset).build();
    mutateOperations.add(
        MutateOperation.newBuilder()
            .setAssetGroupAssetOperation(assetGroupAssetOperation)
            .build());
  }

  // Links the description assets.
  for (String resourceName : descriptionAssetResourceNames) {
    AssetGroupAsset assetGroupAsset =
        AssetGroupAsset.newBuilder()
            .setFieldType(AssetFieldType.DESCRIPTION)
            .setAssetGroup(assetGroupResourceName)
            .setAsset(resourceName)
            .build();
    AssetGroupAssetOperation assetGroupAssetOperation =
        AssetGroupAssetOperation.newBuilder().setCreate(assetGroupAsset).build();
    mutateOperations.add(
        MutateOperation.newBuilder()
            .setAssetGroupAssetOperation(assetGroupAssetOperation)
            .build());
  }

  // Creates and links the long headline text asset.
  List<MutateOperation> createAndLinkTextAssetOperations =
      createAndLinkTextAsset(customerId, "Travel the World", AssetFieldType.LONG_HEADLINE);
  mutateOperations.addAll(createAndLinkTextAssetOperations);

  // Creates and links the business name text asset.
  createAndLinkTextAssetOperations =
      createAndLinkTextAsset(customerId, "Interplanetary Cruises", AssetFieldType.BUSINESS_NAME);
  mutateOperations.addAll(createAndLinkTextAssetOperations);

  // Creates and links the image assets.

  // Creates and links the Logo Asset.
  createAndLinkTextAssetOperations =
      createAndLinkImageAsset(
          customerId, "https://gaagl.page.link/bjYi", AssetFieldType.LOGO, "Marketing Logo");
  mutateOperations.addAll(createAndLinkTextAssetOperations);

  // Creates and links the Marketing Image Asset.
  createAndLinkTextAssetOperations =
      createAndLinkImageAsset(
          customerId,
          "https://gaagl.page.link/Eit5",
          AssetFieldType.MARKETING_IMAGE,
          "Marketing Image");
  mutateOperations.addAll(createAndLinkTextAssetOperations);

  // Creates and links the Square Marketing Image Asset.
  createAndLinkTextAssetOperations =
      createAndLinkImageAsset(
          customerId,
          "https://gaagl.page.link/bjYi",
          AssetFieldType.SQUARE_MARKETING_IMAGE,
          "Square Marketing Image");
  mutateOperations.addAll(createAndLinkTextAssetOperations);

  return mutateOperations;
}
AddPerformanceMaxCampaign.java
      

C#

/// <summary>
/// Creates a list of MutateOperations that create a new asset_group.
/// </summary>
/// <param name="campaignResourceName">The campaign resource name.</param>
/// <param name="assetGroupResourceName">The asset group resource name.</param>
/// <param name="headlineAssetResourceNames">The headline asset resource names.</param>
/// <param name="descriptionAssetResourceNames">The description asset resource
/// names.</param>
/// <param name="resourceNameGenerator">A generator for unique temporary ID's.</param>
/// <param name="config">The Google Ads config.</param>
/// <returns>A list of MutateOperations that create the new asset group.</returns>
private List<MutateOperation> CreateAssetGroupOperations(
    string campaignResourceName,
    string assetGroupResourceName,
    List<string> headlineAssetResourceNames,
    List<string> descriptionAssetResourceNames,
    AssetGroupAssetTemporaryResourceNameGenerator resourceNameGenerator,
    GoogleAdsConfig config)
{
    List<MutateOperation> operations = new List<MutateOperation>();

    // Create the AssetGroup
    operations.Add(
        new MutateOperation()
        {
            AssetGroupOperation = new AssetGroupOperation()
            {
                Create = new AssetGroup()
                {
                    Name = "Performance Max asset group #" +
                        ExampleUtilities.GetRandomString(),
                    Campaign = campaignResourceName,
                    FinalUrls = { "http://www.example.com" },
                    FinalMobileUrls = { "http://www.example.com" },
                    Status = AssetGroupStatus.Paused,
                    ResourceName = assetGroupResourceName
                }
            }
        }
    );

    // For the list of required assets for a Performance Max campaign, see
    // https://developers.google.com/google-ads/api/docs/performance-max/assets

    // An AssetGroup is linked to an Asset by creating a new AssetGroupAsset
    // and providing:
    //   the resource name of the AssetGroup
    //   the resource name of the Asset
    //   the field_type of the Asset in this AssetGroup.
    //
    // To learn more about AssetGroups, see
    // https://developers.google.com/google-ads/api/docs/performance-max/asset-groups

    // Link the previously created multiple text assets.

    // Link the headline assets.
    foreach (string resourceName in headlineAssetResourceNames)
    {
        operations.Add(
            new MutateOperation()
            {
                AssetGroupAssetOperation = new AssetGroupAssetOperation()
                {
                    Create = new AssetGroupAsset()
                    {
                        FieldType = AssetFieldType.Headline,
                        AssetGroup = assetGroupResourceName,
                        Asset = resourceName
                    }
                }
            }
        );
    }

    // Link the description assets.
    foreach (string resourceName in descriptionAssetResourceNames)
    {
        operations.Add(
            new MutateOperation()
            {
                AssetGroupAssetOperation = new AssetGroupAssetOperation()
                {
                    Create = new AssetGroupAsset()
                    {
                        FieldType = AssetFieldType.Description,
                        AssetGroup = assetGroupResourceName,
                        Asset = resourceName
                    }
                }
            }
        );
    }

    // Create and link the long headline text asset.
    operations.AddRange(
        CreateAndLinkTextAsset(
            assetGroupResourceName,
            resourceNameGenerator.Next(),
            "Travel the World",
            AssetFieldType.LongHeadline
        )
    );

    // Create and link the business name text asset.
    operations.AddRange(
        CreateAndLinkTextAsset(
            assetGroupResourceName,
            resourceNameGenerator.Next(),
            "Interplanetary Cruises",
            AssetFieldType.BusinessName
        )
    );

    // Create and link the image assets.

    // Create and link the Logo Asset.
    operations.AddRange(
        CreateAndLinkImageAsset(
            assetGroupResourceName,
            resourceNameGenerator.Next(),
            "https://gaagl.page.link/bjYi",
            AssetFieldType.Logo,
            "Marketing Logo",
            config
        )
    );

    // Create and link the Marketing Image Asset.
    operations.AddRange(
        CreateAndLinkImageAsset(
            assetGroupResourceName,
            resourceNameGenerator.Next(),
            "https://gaagl.page.link/Eit5",
            AssetFieldType.MarketingImage,
            "Marketing Image",
            config
        )
    );

    // Create and link the Square Marketing Image Asset.
    operations.AddRange(
        CreateAndLinkImageAsset(
            assetGroupResourceName,
            resourceNameGenerator.Next(),
            "https://gaagl.page.link/bjYi",
            AssetFieldType.SquareMarketingImage,
            "Square Marketing Image",
            config
        )
    );

    return operations;
}
AddPerformanceMaxCampaign.cs
      

PHP

private static function createAssetGroupOperations(
    int $customerId,
    array $headlineAssetResourceNames,
    array $descriptionAssetResourceNames
): array {
    $operations = [];
    // Creates a new mutate operation that creates an asset group operation.
    $operations[] = new MutateOperation([
        'asset_group_operation' => new AssetGroupOperation([
            'create' => new AssetGroup([
                'resource_name' => ResourceNames::forAssetGroup(
                    $customerId,
                    self::ASSET_GROUP_TEMPORARY_ID
                ),
                'name' => 'Performance Max asset group #' . Helper::getPrintableDatetime(),
                'campaign' => ResourceNames::forCampaign(
                    $customerId,
                    self::PERFORMANCE_MAX_CAMPAIGN_TEMPORARY_ID
                ),
                'final_urls' => ['http://www.example.com'],
                'final_mobile_urls' => ['http://www.example.com'],
                'status' => AssetGroupStatus::PAUSED
            ])
        ])
    ]);

    // For the list of required assets for a Performance Max campaign, see
    // https://developers.google.com/google-ads/api/docs/performance-max/assets

    // An AssetGroup is linked to an Asset by creating a new AssetGroupAsset
    // and providing:
    // -  the resource name of the AssetGroup
    // -  the resource name of the Asset
    // -  the field_type of the Asset in this AssetGroup
    //
    // To learn more about AssetGroups, see
    // https://developers.google.com/google-ads/api/docs/performance-max/asset-groups.

    // Links the previously created multiple text assets.

    // Links the headline assets.
    foreach ($headlineAssetResourceNames as $resourceName) {
        $operations[] = new MutateOperation([
            'asset_group_asset_operation' => new AssetGroupAssetOperation([
                'create' => new AssetGroupAsset([
                    'asset' => $resourceName,
                    'asset_group' => ResourceNames::forAssetGroup(
                        $customerId,
                        self::ASSET_GROUP_TEMPORARY_ID
                    ),
                    'field_type' => AssetFieldType::HEADLINE
                ])
            ])
        ]);
    }
    // Links the description assets.
    foreach ($descriptionAssetResourceNames as $resourceName) {
        $operations[] = new MutateOperation([
            'asset_group_asset_operation' => new AssetGroupAssetOperation([
                'create' => new AssetGroupAsset([
                    'asset' => $resourceName,
                    'asset_group' => ResourceNames::forAssetGroup(
                        $customerId,
                        self::ASSET_GROUP_TEMPORARY_ID
                    ),
                    'field_type' => AssetFieldType::DESCRIPTION
                ])
            ])
        ]);
    }

    // Creates and links the long headline text asset.
    $operations = array_merge($operations, self::createAndLinkTextAsset(
        $customerId,
        'Travel the World',
        AssetFieldType::LONG_HEADLINE
    ));
    // Creates and links the business name text asset.
    $operations = array_merge($operations, self::createAndLinkTextAsset(
        $customerId,
        'Interplanetary Cruises',
        AssetFieldType::BUSINESS_NAME
    ));

    // Creates and links the image assets.

    // Creates and links the Logo Asset.
    $operations = array_merge($operations, self::createAndLinkImageAsset(
        $customerId,
        'https://gaagl.page.link/bjYi',
        AssetFieldType::LOGO,
        'Marketing Logo'
    ));
    // Creates and links the Marketing Image Asset.
    $operations = array_merge($operations, self::createAndLinkImageAsset(
        $customerId,
        'https://gaagl.page.link/Eit5',
        AssetFieldType::MARKETING_IMAGE,
        'Marketing Image'
    ));
    // Creates and links the Square Marketing Image Asset.
    $operations = array_merge($operations, self::createAndLinkImageAsset(
        $customerId,
        'https://gaagl.page.link/bjYi',
        AssetFieldType::SQUARE_MARKETING_IMAGE,
        'Square Marketing Image'
    ));

    return $operations;
}
AddPerformanceMaxCampaign.php
      

Python

def create_asset_group_operation(
    client,
    customer_id,
    headline_asset_resource_names,
    description_asset_resource_names,
):
    """Creates a list of MutateOperations that create a new asset_group.

    A temporary ID will be assigned to this asset group so that it can
    be referenced by other objects being created in the same Mutate request.

    Args:
        client: an initialized GoogleAdsClient instance.
        customer_id: a client customer ID.
        headline_asset_resource_names: a list of headline resource names.
        description_asset_resource_names: a list of description resource names.

    Returns:
        MutateOperations that create a new asset group and related assets.
    """
    asset_group_service = client.get_service("AssetGroupService")
    campaign_service = client.get_service("CampaignService")

    operations = []

    # Create the AssetGroup
    mutate_operation = client.get_type("MutateOperation")
    asset_group = mutate_operation.asset_group_operation.create
    asset_group.name = f"Performance Max asset group #{uuid4()}"
    asset_group.campaign = campaign_service.campaign_path(
        customer_id, _PERFORMANCE_MAX_CAMPAIGN_TEMPORARY_ID
    )
    asset_group.final_urls.append("http://www.example.com")
    asset_group.final_mobile_urls.append("http://www.example.com")
    asset_group.status = client.enums.AssetGroupStatusEnum.PAUSED
    asset_group.resource_name = asset_group_service.asset_group_path(
        customer_id,
        _ASSET_GROUP_TEMPORARY_ID,
    )
    operations.append(mutate_operation)

    # For the list of required assets for a Performance Max campaign, see
    # https://developers.google.com/google-ads/api/docs/performance-max/assets

    # An AssetGroup is linked to an Asset by creating a new AssetGroupAsset
    # and providing:
    #   the resource name of the AssetGroup
    #   the resource name of the Asset
    #   the field_type of the Asset in this AssetGroup.
    #
    # To learn more about AssetGroups, see
    # https://developers.google.com/google-ads/api/docs/performance-max/asset-groups

    # Link the previously created multiple text assets.

    # Link the headline assets.
    for resource_name in headline_asset_resource_names:
        mutate_operation = client.get_type("MutateOperation")
        asset_group_asset = mutate_operation.asset_group_asset_operation.create
        asset_group_asset.field_type = client.enums.AssetFieldTypeEnum.HEADLINE
        asset_group_asset.asset_group = asset_group_service.asset_group_path(
            customer_id,
            _ASSET_GROUP_TEMPORARY_ID,
        )
        asset_group_asset.asset = resource_name
        operations.append(mutate_operation)

    #  Link the description assets.
    for resource_name in description_asset_resource_names:
        mutate_operation = client.get_type("MutateOperation")
        asset_group_asset = mutate_operation.asset_group_asset_operation.create
        asset_group_asset.field_type = (
            client.enums.AssetFieldTypeEnum.DESCRIPTION
        )
        asset_group_asset.asset_group = asset_group_service.asset_group_path(
            customer_id,
            _ASSET_GROUP_TEMPORARY_ID,
        )
        asset_group_asset.asset = resource_name
        operations.append(mutate_operation)

    # Create and link the long headline text asset.
    mutate_operations = create_and_link_text_asset(
        client,
        customer_id,
        "Travel the World",
        client.enums.AssetFieldTypeEnum.LONG_HEADLINE,
    )
    operations.extend(mutate_operations)

    # Create and link the business name text asset.
    mutate_operations = create_and_link_text_asset(
        client,
        customer_id,
        "Interplanetary Cruises",
        client.enums.AssetFieldTypeEnum.BUSINESS_NAME,
    )
    operations.extend(mutate_operations)

    # Create and link the image assets.

    # Create and link the Logo Asset.
    mutate_operations = create_and_link_image_asset(
        client,
        customer_id,
        "https://gaagl.page.link/bjYi",
        client.enums.AssetFieldTypeEnum.LOGO,
        "Marketing Logo",
    )
    operations.extend(mutate_operations)

    # Create and link the Marketing Image Asset.
    mutate_operations = create_and_link_image_asset(
        client,
        customer_id,
        "https://gaagl.page.link/Eit5",
        client.enums.AssetFieldTypeEnum.MARKETING_IMAGE,
        "Marketing Image",
    )
    operations.extend(mutate_operations)

    # Create and link the Square Marketing Image Asset.
    mutate_operations = create_and_link_image_asset(
        client,
        customer_id,
        "https://gaagl.page.link/bjYi",
        client.enums.AssetFieldTypeEnum.SQUARE_MARKETING_IMAGE,
        "Square Marketing Image",
    )
    operations.extend(mutate_operations)
    return operations
add_performance_max_campaign.py
      

Ruby

# Creates a list of MutateOperations that create a new asset_group.
#
# A temporary ID will be assigned to this asset group so that it can
# be referenced by other objects being created in the same Mutate request.
def create_asset_group_operation(
    client,
    customer_id,
    headline_asset_resource_names,
    description_asset_resource_names)
  operations = []

  # Create the AssetGroup
  operations << client.operation.mutate do |m|
    m.asset_group_operation = client.operation.create_resource.asset_group do |ag|
      ag.name = "Performance Max asset group #{SecureRandom.uuid}"
      ag.campaign = client.path.campaign(
        customer_id,
        PERFORMANCE_MAX_CAMPAIGN_TEMPORARY_ID)
      ag.final_urls << "http://www.example.com"
      ag.final_mobile_urls << "http://www.example.com"
      ag.status = :PAUSED
      ag.resource_name = client.path.asset_group(
        customer_id,
        ASSET_GROUP_TEMPORARY_ID)
    end
  end

  # For the list of required assets for a Performance Max campaign, see
  # https://developers.google.com/google-ads/api/docs/performance-max/assets
  #
  # An AssetGroup is linked to an Asset by creating a new AssetGroupAsset
  # and providing:
  #   the resource name of the AssetGroup
  #   the resource name of the Asset
  #   the field_type of the Asset in this AssetGroup.
  #
  # To learn more about AssetGroups, see
  # https://developers.google.com/google-ads/api/docs/performance-max/asset-groups

  # Link the previously created multiple text assets.

  # Link the headline assets.
  headline_asset_resource_names.each do |resource_name|
    operations << client.operation.mutate do |m|
      m.asset_group_asset_operation = client.operation.create_resource
          .asset_group_asset do |aga|
        aga.field_type = :HEADLINE
        aga.asset_group = client.path.asset_group(
          customer_id,
          ASSET_GROUP_TEMPORARY_ID)
        aga.asset = resource_name
      end
    end
  end

  #  Link the description assets.
  description_asset_resource_names.each do |resource_name|
    operations << client.operation.mutate do |m|
      m.asset_group_asset_operation = client.operation.create_resource
          .asset_group_asset do |aga|
        aga.field_type = :DESCRIPTION
        aga.asset_group = client.path.asset_group(
          customer_id,
          ASSET_GROUP_TEMPORARY_ID)
        aga.asset = resource_name
      end
    end
  end

  # Create and link the long headline text asset.
  operations += create_and_link_text_asset(
    client,
    customer_id,
    "Travel the World",
    :LONG_HEADLINE)

  # Create and link the business name text asset.
  operations += create_and_link_text_asset(
    client,
    customer_id,
    "Interplanetary Cruises",
    :BUSINESS_NAME)

  # Create and link the image assets.

  # Create and link the Logo Asset.
  operations += create_and_link_image_asset(
    client,
    customer_id,
    "https://gaagl.page.link/bjYi",
    :LOGO,
    "Marketing Logo")

  # Create and link the Marketing Image Asset.
  operations += create_and_link_image_asset(
    client,
    customer_id,
    "https://gaagl.page.link/Eit5",
    :MARKETING_IMAGE,
    "Marketing Image")

  # Create and link the Square Marketing Image Asset.
  operations += create_and_link_image_asset(
    client,
    customer_id,
    "https://gaagl.page.link/bjYi",
    :SQUARE_MARKETING_IMAGE,
    "Square Marketing Image")

  operations
end
add_performance_max_campaign.rb
      

Perl

sub create_asset_group_operations {
  my (
    $customer_id,
    $headline_asset_resource_names,
    $description_asset_resource_names
  ) = @_;

  my $operations = [];
  # Create a mutate operation that creates an asset group operation.
  push @$operations,
    Google::Ads::GoogleAds::V18::Services::GoogleAdsService::MutateOperation->
    new({
      assetGroupOperation =>
        Google::Ads::GoogleAds::V18::Services::AssetGroupService::AssetGroupOperation
        ->new({
          create => Google::Ads::GoogleAds::V18::Resources::AssetGroup->new({
              resourceName =>
                Google::Ads::GoogleAds::V18::Utils::ResourceNames::asset_group(
                $customer_id, ASSET_GROUP_TEMPORARY_ID
                ),
              name     => "Performance Max asset group #" . uniqid(),
              campaign =>
                Google::Ads::GoogleAds::V18::Utils::ResourceNames::campaign(
                $customer_id, PERFORMANCE_MAX_CAMPAIGN_TEMPORARY_ID
                ),
              finalUrls       => ["http://www.example.com"],
              finalMobileUrls => ["http://www.example.com"],
              status          =>
                Google::Ads::GoogleAds::V18::Enums::AssetGroupStatusEnum::PAUSED
            })})});

  # For the list of required assets for a Performance Max campaign, see
  # https://developers.google.com/google-ads/api/docs/performance-max/assets.

  # An AssetGroup is linked to an Asset by creating a new AssetGroupAsset
  # and providing:
  # - the resource name of the AssetGroup
  # - the resource name of the Asset
  # - the fieldType of the Asset in this AssetGroup
  #
  # To learn more about AssetGroups, see
  # https://developers.google.com/google-ads/api/docs/performance-max/asset-groups.

  # Link the previously created multiple text assets.

  # Link the headline assets.
  foreach my $resource_name (@$headline_asset_resource_names) {
    push @$operations,
      Google::Ads::GoogleAds::V18::Services::GoogleAdsService::MutateOperation
      ->new({
        assetGroupAssetOperation =>
          Google::Ads::GoogleAds::V18::Services::AssetGroupAssetService::AssetGroupAssetOperation
          ->new({
            create =>
              Google::Ads::GoogleAds::V18::Resources::AssetGroupAsset->new({
                asset      => $resource_name,
                assetGroup =>
                  Google::Ads::GoogleAds::V18::Utils::ResourceNames::asset_group(
                  $customer_id, ASSET_GROUP_TEMPORARY_ID
                  ),
                fieldType => HEADLINE
              })})});
  }

  # Link the description assets.
  foreach my $resource_name (@$description_asset_resource_names) {
    push @$operations,
      Google::Ads::GoogleAds::V18::Services::GoogleAdsService::MutateOperation
      ->new({
        assetGroupAssetOperation =>
          Google::Ads::GoogleAds::V18::Services::AssetGroupAssetService::AssetGroupAssetOperation
          ->new({
            create =>
              Google::Ads::GoogleAds::V18::Resources::AssetGroupAsset->new({
                asset      => $resource_name,
                assetGroup =>
                  Google::Ads::GoogleAds::V18::Utils::ResourceNames::asset_group(
                  $customer_id, ASSET_GROUP_TEMPORARY_ID
                  ),
                fieldType => DESCRIPTION
              })})});
  }

  # Create and link the long headline text asset.
  push @$operations,
    @{create_and_link_text_asset($customer_id, "Travel the World",
      LONG_HEADLINE)};

  # Create and link the business name text asset.
  push @$operations,
    @{
    create_and_link_text_asset($customer_id, "Interplanetary Cruises",
      BUSINESS_NAME)};

  # Create and link the image assets.

  # Create and link the logo asset.
  push @$operations,
    @{
    create_and_link_image_asset($customer_id, "https://gaagl.page.link/bjYi",
      LOGO, "Marketing Logo")};

  # Create and link the marketing image asset.
  push @$operations,
    @{
    create_and_link_image_asset(
      $customer_id,    "https://gaagl.page.link/Eit5",
      MARKETING_IMAGE, "Marketing Image"
    )};

  # Create and link the square marketing image asset.
  push @$operations,
    @{
    create_and_link_image_asset(
      $customer_id,           "https://gaagl.page.link/bjYi",
      SQUARE_MARKETING_IMAGE, "Square Marketing Image"
    )};

  return $operations;
}
add_performance_max_campaign.pl
      

---

Collegare gli asset ai gruppi di asset

Una AssetGroup è collegata a una Asset creando un nuovo AssetGroupAsset e fornendo quanto segue:

• Nome della risorsa del AssetGroup
• Nome della risorsa del Asset
• AssetFieldType del Asset in AssetGroup

Esempio di codice

Java

/** Creates a list of MutateOperations that create a new AssetGroup. */
private List<MutateOperation> createAssetGroupOperations(
    long customerId,
    String assetGroupResourceName,
    List<String> headlineAssetResourceNames,
    List<String> descriptionAssetResourceNames)
    throws IOException {
  List<MutateOperation> mutateOperations = new ArrayList<>();
  String campaignResourceName =
      ResourceNames.campaign(customerId, PERFORMANCE_MAX_CAMPAIGN_TEMPORARY_ID);
  // Creates the AssetGroup.
  AssetGroup assetGroup =
      AssetGroup.newBuilder()
          .setName("Performance Max asset group #" + getPrintableDateTime())
          .setCampaign(campaignResourceName)
          .addFinalUrls("http://www.example.com")
          .addFinalMobileUrls("http://www.example.com")
          .setStatus(AssetGroupStatus.PAUSED)
          .setResourceName(assetGroupResourceName)
          .build();
  AssetGroupOperation assetGroupOperation =
      AssetGroupOperation.newBuilder().setCreate(assetGroup).build();
  mutateOperations.add(
      MutateOperation.newBuilder().setAssetGroupOperation(assetGroupOperation).build());

  // For the list of required assets for a Performance Max campaign, see
  // https://developers.google.com/google-ads/api/docs/performance-max/assets

  // An AssetGroup is linked to an Asset by creating a new AssetGroupAsset
  // and providing:
  //   the resource name of the AssetGroup
  //   the resource name of the Asset
  //   the field_type of the Asset in this AssetGroup.

  // To learn more about AssetGroups, see
  // https://developers.google.com/google-ads/api/docs/performance-max/asset-groups

  // Links the previously created multiple text assets.

  // Links the headline assets.
  for (String resourceName : headlineAssetResourceNames) {
    AssetGroupAsset assetGroupAsset =
        AssetGroupAsset.newBuilder()
            .setFieldType(AssetFieldType.HEADLINE)
            .setAssetGroup(assetGroupResourceName)
            .setAsset(resourceName)
            .build();
    AssetGroupAssetOperation assetGroupAssetOperation =
        AssetGroupAssetOperation.newBuilder().setCreate(assetGroupAsset).build();
    mutateOperations.add(
        MutateOperation.newBuilder()
            .setAssetGroupAssetOperation(assetGroupAssetOperation)
            .build());
  }

  // Links the description assets.
  for (String resourceName : descriptionAssetResourceNames) {
    AssetGroupAsset assetGroupAsset =
        AssetGroupAsset.newBuilder()
            .setFieldType(AssetFieldType.DESCRIPTION)
            .setAssetGroup(assetGroupResourceName)
            .setAsset(resourceName)
            .build();
    AssetGroupAssetOperation assetGroupAssetOperation =
        AssetGroupAssetOperation.newBuilder().setCreate(assetGroupAsset).build();
    mutateOperations.add(
        MutateOperation.newBuilder()
            .setAssetGroupAssetOperation(assetGroupAssetOperation)
            .build());
  }

  // Creates and links the long headline text asset.
  List<MutateOperation> createAndLinkTextAssetOperations =
      createAndLinkTextAsset(customerId, "Travel the World", AssetFieldType.LONG_HEADLINE);
  mutateOperations.addAll(createAndLinkTextAssetOperations);

  // Creates and links the business name text asset.
  createAndLinkTextAssetOperations =
      createAndLinkTextAsset(customerId, "Interplanetary Cruises", AssetFieldType.BUSINESS_NAME);
  mutateOperations.addAll(createAndLinkTextAssetOperations);

  // Creates and links the image assets.

  // Creates and links the Logo Asset.
  createAndLinkTextAssetOperations =
      createAndLinkImageAsset(
          customerId, "https://gaagl.page.link/bjYi", AssetFieldType.LOGO, "Marketing Logo");
  mutateOperations.addAll(createAndLinkTextAssetOperations);

  // Creates and links the Marketing Image Asset.
  createAndLinkTextAssetOperations =
      createAndLinkImageAsset(
          customerId,
          "https://gaagl.page.link/Eit5",
          AssetFieldType.MARKETING_IMAGE,
          "Marketing Image");
  mutateOperations.addAll(createAndLinkTextAssetOperations);

  // Creates and links the Square Marketing Image Asset.
  createAndLinkTextAssetOperations =
      createAndLinkImageAsset(
          customerId,
          "https://gaagl.page.link/bjYi",
          AssetFieldType.SQUARE_MARKETING_IMAGE,
          "Square Marketing Image");
  mutateOperations.addAll(createAndLinkTextAssetOperations);

  return mutateOperations;
}
AddPerformanceMaxCampaign.java
      

C#

/// <summary>
/// Creates a list of MutateOperations that create a new asset_group.
/// </summary>
/// <param name="campaignResourceName">The campaign resource name.</param>
/// <param name="assetGroupResourceName">The asset group resource name.</param>
/// <param name="headlineAssetResourceNames">The headline asset resource names.</param>
/// <param name="descriptionAssetResourceNames">The description asset resource
/// names.</param>
/// <param name="resourceNameGenerator">A generator for unique temporary ID's.</param>
/// <param name="config">The Google Ads config.</param>
/// <returns>A list of MutateOperations that create the new asset group.</returns>
private List<MutateOperation> CreateAssetGroupOperations(
    string campaignResourceName,
    string assetGroupResourceName,
    List<string> headlineAssetResourceNames,
    List<string> descriptionAssetResourceNames,
    AssetGroupAssetTemporaryResourceNameGenerator resourceNameGenerator,
    GoogleAdsConfig config)
{
    List<MutateOperation> operations = new List<MutateOperation>();

    // Create the AssetGroup
    operations.Add(
        new MutateOperation()
        {
            AssetGroupOperation = new AssetGroupOperation()
            {
                Create = new AssetGroup()
                {
                    Name = "Performance Max asset group #" +
                        ExampleUtilities.GetRandomString(),
                    Campaign = campaignResourceName,
                    FinalUrls = { "http://www.example.com" },
                    FinalMobileUrls = { "http://www.example.com" },
                    Status = AssetGroupStatus.Paused,
                    ResourceName = assetGroupResourceName
                }
            }
        }
    );

    // For the list of required assets for a Performance Max campaign, see
    // https://developers.google.com/google-ads/api/docs/performance-max/assets

    // An AssetGroup is linked to an Asset by creating a new AssetGroupAsset
    // and providing:
    //   the resource name of the AssetGroup
    //   the resource name of the Asset
    //   the field_type of the Asset in this AssetGroup.
    //
    // To learn more about AssetGroups, see
    // https://developers.google.com/google-ads/api/docs/performance-max/asset-groups

    // Link the previously created multiple text assets.

    // Link the headline assets.
    foreach (string resourceName in headlineAssetResourceNames)
    {
        operations.Add(
            new MutateOperation()
            {
                AssetGroupAssetOperation = new AssetGroupAssetOperation()
                {
                    Create = new AssetGroupAsset()
                    {
                        FieldType = AssetFieldType.Headline,
                        AssetGroup = assetGroupResourceName,
                        Asset = resourceName
                    }
                }
            }
        );
    }

    // Link the description assets.
    foreach (string resourceName in descriptionAssetResourceNames)
    {
        operations.Add(
            new MutateOperation()
            {
                AssetGroupAssetOperation = new AssetGroupAssetOperation()
                {
                    Create = new AssetGroupAsset()
                    {
                        FieldType = AssetFieldType.Description,
                        AssetGroup = assetGroupResourceName,
                        Asset = resourceName
                    }
                }
            }
        );
    }

    // Create and link the long headline text asset.
    operations.AddRange(
        CreateAndLinkTextAsset(
            assetGroupResourceName,
            resourceNameGenerator.Next(),
            "Travel the World",
            AssetFieldType.LongHeadline
        )
    );

    // Create and link the business name text asset.
    operations.AddRange(
        CreateAndLinkTextAsset(
            assetGroupResourceName,
            resourceNameGenerator.Next(),
            "Interplanetary Cruises",
            AssetFieldType.BusinessName
        )
    );

    // Create and link the image assets.

    // Create and link the Logo Asset.
    operations.AddRange(
        CreateAndLinkImageAsset(
            assetGroupResourceName,
            resourceNameGenerator.Next(),
            "https://gaagl.page.link/bjYi",
            AssetFieldType.Logo,
            "Marketing Logo",
            config
        )
    );

    // Create and link the Marketing Image Asset.
    operations.AddRange(
        CreateAndLinkImageAsset(
            assetGroupResourceName,
            resourceNameGenerator.Next(),
            "https://gaagl.page.link/Eit5",
            AssetFieldType.MarketingImage,
            "Marketing Image",
            config
        )
    );

    // Create and link the Square Marketing Image Asset.
    operations.AddRange(
        CreateAndLinkImageAsset(
            assetGroupResourceName,
            resourceNameGenerator.Next(),
            "https://gaagl.page.link/bjYi",
            AssetFieldType.SquareMarketingImage,
            "Square Marketing Image",
            config
        )
    );

    return operations;
}
AddPerformanceMaxCampaign.cs
      

PHP

private static function createAssetGroupOperations(
    int $customerId,
    array $headlineAssetResourceNames,
    array $descriptionAssetResourceNames
): array {
    $operations = [];
    // Creates a new mutate operation that creates an asset group operation.
    $operations[] = new MutateOperation([
        'asset_group_operation' => new AssetGroupOperation([
            'create' => new AssetGroup([
                'resource_name' => ResourceNames::forAssetGroup(
                    $customerId,
                    self::ASSET_GROUP_TEMPORARY_ID
                ),
                'name' => 'Performance Max asset group #' . Helper::getPrintableDatetime(),
                'campaign' => ResourceNames::forCampaign(
                    $customerId,
                    self::PERFORMANCE_MAX_CAMPAIGN_TEMPORARY_ID
                ),
                'final_urls' => ['http://www.example.com'],
                'final_mobile_urls' => ['http://www.example.com'],
                'status' => AssetGroupStatus::PAUSED
            ])
        ])
    ]);

    // For the list of required assets for a Performance Max campaign, see
    // https://developers.google.com/google-ads/api/docs/performance-max/assets

    // An AssetGroup is linked to an Asset by creating a new AssetGroupAsset
    // and providing:
    // -  the resource name of the AssetGroup
    // -  the resource name of the Asset
    // -  the field_type of the Asset in this AssetGroup
    //
    // To learn more about AssetGroups, see
    // https://developers.google.com/google-ads/api/docs/performance-max/asset-groups.

    // Links the previously created multiple text assets.

    // Links the headline assets.
    foreach ($headlineAssetResourceNames as $resourceName) {
        $operations[] = new MutateOperation([
            'asset_group_asset_operation' => new AssetGroupAssetOperation([
                'create' => new AssetGroupAsset([
                    'asset' => $resourceName,
                    'asset_group' => ResourceNames::forAssetGroup(
                        $customerId,
                        self::ASSET_GROUP_TEMPORARY_ID
                    ),
                    'field_type' => AssetFieldType::HEADLINE
                ])
            ])
        ]);
    }
    // Links the description assets.
    foreach ($descriptionAssetResourceNames as $resourceName) {
        $operations[] = new MutateOperation([
            'asset_group_asset_operation' => new AssetGroupAssetOperation([
                'create' => new AssetGroupAsset([
                    'asset' => $resourceName,
                    'asset_group' => ResourceNames::forAssetGroup(
                        $customerId,
                        self::ASSET_GROUP_TEMPORARY_ID
                    ),
                    'field_type' => AssetFieldType::DESCRIPTION
                ])
            ])
        ]);
    }

    // Creates and links the long headline text asset.
    $operations = array_merge($operations, self::createAndLinkTextAsset(
        $customerId,
        'Travel the World',
        AssetFieldType::LONG_HEADLINE
    ));
    // Creates and links the business name text asset.
    $operations = array_merge($operations, self::createAndLinkTextAsset(
        $customerId,
        'Interplanetary Cruises',
        AssetFieldType::BUSINESS_NAME
    ));

    // Creates and links the image assets.

    // Creates and links the Logo Asset.
    $operations = array_merge($operations, self::createAndLinkImageAsset(
        $customerId,
        'https://gaagl.page.link/bjYi',
        AssetFieldType::LOGO,
        'Marketing Logo'
    ));
    // Creates and links the Marketing Image Asset.
    $operations = array_merge($operations, self::createAndLinkImageAsset(
        $customerId,
        'https://gaagl.page.link/Eit5',
        AssetFieldType::MARKETING_IMAGE,
        'Marketing Image'
    ));
    // Creates and links the Square Marketing Image Asset.
    $operations = array_merge($operations, self::createAndLinkImageAsset(
        $customerId,
        'https://gaagl.page.link/bjYi',
        AssetFieldType::SQUARE_MARKETING_IMAGE,
        'Square Marketing Image'
    ));

    return $operations;
}
AddPerformanceMaxCampaign.php
      

Python

def create_asset_group_operation(
    client,
    customer_id,
    headline_asset_resource_names,
    description_asset_resource_names,
):
    """Creates a list of MutateOperations that create a new asset_group.

    A temporary ID will be assigned to this asset group so that it can
    be referenced by other objects being created in the same Mutate request.

    Args:
        client: an initialized GoogleAdsClient instance.
        customer_id: a client customer ID.
        headline_asset_resource_names: a list of headline resource names.
        description_asset_resource_names: a list of description resource names.

    Returns:
        MutateOperations that create a new asset group and related assets.
    """
    asset_group_service = client.get_service("AssetGroupService")
    campaign_service = client.get_service("CampaignService")

    operations = []

    # Create the AssetGroup
    mutate_operation = client.get_type("MutateOperation")
    asset_group = mutate_operation.asset_group_operation.create
    asset_group.name = f"Performance Max asset group #{uuid4()}"
    asset_group.campaign = campaign_service.campaign_path(
        customer_id, _PERFORMANCE_MAX_CAMPAIGN_TEMPORARY_ID
    )
    asset_group.final_urls.append("http://www.example.com")
    asset_group.final_mobile_urls.append("http://www.example.com")
    asset_group.status = client.enums.AssetGroupStatusEnum.PAUSED
    asset_group.resource_name = asset_group_service.asset_group_path(
        customer_id,
        _ASSET_GROUP_TEMPORARY_ID,
    )
    operations.append(mutate_operation)

    # For the list of required assets for a Performance Max campaign, see
    # https://developers.google.com/google-ads/api/docs/performance-max/assets

    # An AssetGroup is linked to an Asset by creating a new AssetGroupAsset
    # and providing:
    #   the resource name of the AssetGroup
    #   the resource name of the Asset
    #   the field_type of the Asset in this AssetGroup.
    #
    # To learn more about AssetGroups, see
    # https://developers.google.com/google-ads/api/docs/performance-max/asset-groups

    # Link the previously created multiple text assets.

    # Link the headline assets.
    for resource_name in headline_asset_resource_names:
        mutate_operation = client.get_type("MutateOperation")
        asset_group_asset = mutate_operation.asset_group_asset_operation.create
        asset_group_asset.field_type = client.enums.AssetFieldTypeEnum.HEADLINE
        asset_group_asset.asset_group = asset_group_service.asset_group_path(
            customer_id,
            _ASSET_GROUP_TEMPORARY_ID,
        )
        asset_group_asset.asset = resource_name
        operations.append(mutate_operation)

    #  Link the description assets.
    for resource_name in description_asset_resource_names:
        mutate_operation = client.get_type("MutateOperation")
        asset_group_asset = mutate_operation.asset_group_asset_operation.create
        asset_group_asset.field_type = (
            client.enums.AssetFieldTypeEnum.DESCRIPTION
        )
        asset_group_asset.asset_group = asset_group_service.asset_group_path(
            customer_id,
            _ASSET_GROUP_TEMPORARY_ID,
        )
        asset_group_asset.asset = resource_name
        operations.append(mutate_operation)

    # Create and link the long headline text asset.
    mutate_operations = create_and_link_text_asset(
        client,
        customer_id,
        "Travel the World",
        client.enums.AssetFieldTypeEnum.LONG_HEADLINE,
    )
    operations.extend(mutate_operations)

    # Create and link the business name text asset.
    mutate_operations = create_and_link_text_asset(
        client,
        customer_id,
        "Interplanetary Cruises",
        client.enums.AssetFieldTypeEnum.BUSINESS_NAME,
    )
    operations.extend(mutate_operations)

    # Create and link the image assets.

    # Create and link the Logo Asset.
    mutate_operations = create_and_link_image_asset(
        client,
        customer_id,
        "https://gaagl.page.link/bjYi",
        client.enums.AssetFieldTypeEnum.LOGO,
        "Marketing Logo",
    )
    operations.extend(mutate_operations)

    # Create and link the Marketing Image Asset.
    mutate_operations = create_and_link_image_asset(
        client,
        customer_id,
        "https://gaagl.page.link/Eit5",
        client.enums.AssetFieldTypeEnum.MARKETING_IMAGE,
        "Marketing Image",
    )
    operations.extend(mutate_operations)

    # Create and link the Square Marketing Image Asset.
    mutate_operations = create_and_link_image_asset(
        client,
        customer_id,
        "https://gaagl.page.link/bjYi",
        client.enums.AssetFieldTypeEnum.SQUARE_MARKETING_IMAGE,
        "Square Marketing Image",
    )
    operations.extend(mutate_operations)
    return operations
add_performance_max_campaign.py
      

Ruby

# Creates a list of MutateOperations that create a new asset_group.
#
# A temporary ID will be assigned to this asset group so that it can
# be referenced by other objects being created in the same Mutate request.
def create_asset_group_operation(
    client,
    customer_id,
    headline_asset_resource_names,
    description_asset_resource_names)
  operations = []

  # Create the AssetGroup
  operations << client.operation.mutate do |m|
    m.asset_group_operation = client.operation.create_resource.asset_group do |ag|
      ag.name = "Performance Max asset group #{SecureRandom.uuid}"
      ag.campaign = client.path.campaign(
        customer_id,
        PERFORMANCE_MAX_CAMPAIGN_TEMPORARY_ID)
      ag.final_urls << "http://www.example.com"
      ag.final_mobile_urls << "http://www.example.com"
      ag.status = :PAUSED
      ag.resource_name = client.path.asset_group(
        customer_id,
        ASSET_GROUP_TEMPORARY_ID)
    end
  end

  # For the list of required assets for a Performance Max campaign, see
  # https://developers.google.com/google-ads/api/docs/performance-max/assets
  #
  # An AssetGroup is linked to an Asset by creating a new AssetGroupAsset
  # and providing:
  #   the resource name of the AssetGroup
  #   the resource name of the Asset
  #   the field_type of the Asset in this AssetGroup.
  #
  # To learn more about AssetGroups, see
  # https://developers.google.com/google-ads/api/docs/performance-max/asset-groups

  # Link the previously created multiple text assets.

  # Link the headline assets.
  headline_asset_resource_names.each do |resource_name|
    operations << client.operation.mutate do |m|
      m.asset_group_asset_operation = client.operation.create_resource
          .asset_group_asset do |aga|
        aga.field_type = :HEADLINE
        aga.asset_group = client.path.asset_group(
          customer_id,
          ASSET_GROUP_TEMPORARY_ID)
        aga.asset = resource_name
      end
    end
  end

  #  Link the description assets.
  description_asset_resource_names.each do |resource_name|
    operations << client.operation.mutate do |m|
      m.asset_group_asset_operation = client.operation.create_resource
          .asset_group_asset do |aga|
        aga.field_type = :DESCRIPTION
        aga.asset_group = client.path.asset_group(
          customer_id,
          ASSET_GROUP_TEMPORARY_ID)
        aga.asset = resource_name
      end
    end
  end

  # Create and link the long headline text asset.
  operations += create_and_link_text_asset(
    client,
    customer_id,
    "Travel the World",
    :LONG_HEADLINE)

  # Create and link the business name text asset.
  operations += create_and_link_text_asset(
    client,
    customer_id,
    "Interplanetary Cruises",
    :BUSINESS_NAME)

  # Create and link the image assets.

  # Create and link the Logo Asset.
  operations += create_and_link_image_asset(
    client,
    customer_id,
    "https://gaagl.page.link/bjYi",
    :LOGO,
    "Marketing Logo")

  # Create and link the Marketing Image Asset.
  operations += create_and_link_image_asset(
    client,
    customer_id,
    "https://gaagl.page.link/Eit5",
    :MARKETING_IMAGE,
    "Marketing Image")

  # Create and link the Square Marketing Image Asset.
  operations += create_and_link_image_asset(
    client,
    customer_id,
    "https://gaagl.page.link/bjYi",
    :SQUARE_MARKETING_IMAGE,
    "Square Marketing Image")

  operations
end
add_performance_max_campaign.rb
      

Perl

sub create_asset_group_operations {
  my (
    $customer_id,
    $headline_asset_resource_names,
    $description_asset_resource_names
  ) = @_;

  my $operations = [];
  # Create a mutate operation that creates an asset group operation.
  push @$operations,
    Google::Ads::GoogleAds::V18::Services::GoogleAdsService::MutateOperation->
    new({
      assetGroupOperation =>
        Google::Ads::GoogleAds::V18::Services::AssetGroupService::AssetGroupOperation
        ->new({
          create => Google::Ads::GoogleAds::V18::Resources::AssetGroup->new({
              resourceName =>
                Google::Ads::GoogleAds::V18::Utils::ResourceNames::asset_group(
                $customer_id, ASSET_GROUP_TEMPORARY_ID
                ),
              name     => "Performance Max asset group #" . uniqid(),
              campaign =>
                Google::Ads::GoogleAds::V18::Utils::ResourceNames::campaign(
                $customer_id, PERFORMANCE_MAX_CAMPAIGN_TEMPORARY_ID
                ),
              finalUrls       => ["http://www.example.com"],
              finalMobileUrls => ["http://www.example.com"],
              status          =>
                Google::Ads::GoogleAds::V18::Enums::AssetGroupStatusEnum::PAUSED
            })})});

  # For the list of required assets for a Performance Max campaign, see
  # https://developers.google.com/google-ads/api/docs/performance-max/assets.

  # An AssetGroup is linked to an Asset by creating a new AssetGroupAsset
  # and providing:
  # - the resource name of the AssetGroup
  # - the resource name of the Asset
  # - the fieldType of the Asset in this AssetGroup
  #
  # To learn more about AssetGroups, see
  # https://developers.google.com/google-ads/api/docs/performance-max/asset-groups.

  # Link the previously created multiple text assets.

  # Link the headline assets.
  foreach my $resource_name (@$headline_asset_resource_names) {
    push @$operations,
      Google::Ads::GoogleAds::V18::Services::GoogleAdsService::MutateOperation
      ->new({
        assetGroupAssetOperation =>
          Google::Ads::GoogleAds::V18::Services::AssetGroupAssetService::AssetGroupAssetOperation
          ->new({
            create =>
              Google::Ads::GoogleAds::V18::Resources::AssetGroupAsset->new({
                asset      => $resource_name,
                assetGroup =>
                  Google::Ads::GoogleAds::V18::Utils::ResourceNames::asset_group(
                  $customer_id, ASSET_GROUP_TEMPORARY_ID
                  ),
                fieldType => HEADLINE
              })})});
  }

  # Link the description assets.
  foreach my $resource_name (@$description_asset_resource_names) {
    push @$operations,
      Google::Ads::GoogleAds::V18::Services::GoogleAdsService::MutateOperation
      ->new({
        assetGroupAssetOperation =>
          Google::Ads::GoogleAds::V18::Services::AssetGroupAssetService::AssetGroupAssetOperation
          ->new({
            create =>
              Google::Ads::GoogleAds::V18::Resources::AssetGroupAsset->new({
                asset      => $resource_name,
                assetGroup =>
                  Google::Ads::GoogleAds::V18::Utils::ResourceNames::asset_group(
                  $customer_id, ASSET_GROUP_TEMPORARY_ID
                  ),
                fieldType => DESCRIPTION
              })})});
  }

  # Create and link the long headline text asset.
  push @$operations,
    @{create_and_link_text_asset($customer_id, "Travel the World",
      LONG_HEADLINE)};

  # Create and link the business name text asset.
  push @$operations,
    @{
    create_and_link_text_asset($customer_id, "Interplanetary Cruises",
      BUSINESS_NAME)};

  # Create and link the image assets.

  # Create and link the logo asset.
  push @$operations,
    @{
    create_and_link_image_asset($customer_id, "https://gaagl.page.link/bjYi",
      LOGO, "Marketing Logo")};

  # Create and link the marketing image asset.
  push @$operations,
    @{
    create_and_link_image_asset(
      $customer_id,    "https://gaagl.page.link/Eit5",
      MARKETING_IMAGE, "Marketing Image"
    )};

  # Create and link the square marketing image asset.
  push @$operations,
    @{
    create_and_link_image_asset(
      $customer_id,           "https://gaagl.page.link/bjYi",
      SQUARE_MARKETING_IMAGE, "Square Marketing Image"
    )};

  return $operations;
}
add_performance_max_campaign.pl
      

---

Aggiungere indicatori dei gruppi di asset (facoltativo)

Un AssetGroupSignal è un indicatore che puoi fornire a Google per ottimizzare la pubblicazione degli annunci a livello di gruppo di asset. Esistono due tipi di suggerimenti che puoi fornire a Google:

• audience: una raccolta riutilizzabile di segmenti mirati, targeting demografico ed esclusioni
• search_theme: informazioni sulle ricerche dei tuoi clienti e sugli argomenti che generano conversioni per la tua attività che puoi fornire all'IA di Google

Esempio di codice dell'indicatore sui segmenti di pubblico

Java

AssetGroupSignal audienceSignal =
    AssetGroupSignal.newBuilder()
        .setAssetGroup(assetGroupResourceName)
        .setAudience(
            AudienceInfo.newBuilder()
                .setAudience(ResourceNames.audience(customerId, audienceId)))
        .build();

mutateOperations.add(
    MutateOperation.newBuilder()
        .setAssetGroupSignalOperation(
            AssetGroupSignalOperation.newBuilder().setCreate(audienceSignal))
        .build());
AddPerformanceMaxCampaign.java
      

C#

operations.Add(
    new MutateOperation()
    {
        AssetGroupSignalOperation = new AssetGroupSignalOperation()
        {
            Create = new AssetGroupSignal()
            {
                AssetGroup = assetGroupResourceName,
                Audience = new AudienceInfo()
                {
                    Audience = ResourceNames.Audience(customerId, audienceId.Value)
                }
            }
        }
    }
);
AddPerformanceMaxCampaign.cs
      

PHP

private static function createAssetGroupSignalOperations(
    int $customerId,
    string $assetGroupResourceName,
    ?int $audienceId
): array {
    $operations = [];
    if (is_null($audienceId)) {
        return $operations;
    }

    $operations[] = new MutateOperation([
        'asset_group_signal_operation' => new AssetGroupSignalOperation([
            // To learn more about Audience Signals, see
            // https://developers.google.com/google-ads/api/docs/performance-max/asset-groups#audience_signals.
            'create' => new AssetGroupSignal([
                'asset_group' => $assetGroupResourceName,
                'audience' => new AudienceInfo([
                    'audience' => ResourceNames::forAudience($customerId, $audienceId)
                ])
            ])
        ])
    ]);

    return $operations;
}
AddPerformanceMaxCampaign.php
      

Python

mutate_operation = client.get_type("MutateOperation")
operation = mutate_operation.asset_group_signal_operation.create
operation.asset_group = asset_group_resource_name
operation.audience.audience = googleads_service.audience_path(
    customer_id, audience_id
)
operations.append(mutate_operation)
add_performance_max_campaign.py
      

Ruby

# Create a list of MutateOperations that create AssetGroupSignals.
def create_asset_group_signal_operations(client, customer_id, audience_id)
  operations = []
  return operations if audience_id.nil?

  operations << client.operation.mutate do |m|
    m.asset_group_signal_operation = client.operation.create_resource.
        asset_group_signal do |ags|
      ags.asset_group = client.path.asset_group(
        customer_id,
        ASSET_GROUP_TEMPORARY_ID,
      )
      ags.audience = client.resource.audience_info do |ai|
        ai.audience = client.path.audience(customer_id, audience_id)
      end
    end
  end

  operations
end
add_performance_max_campaign.rb
      

Perl

sub create_asset_group_signal_operations {
  my ($customer_id, $audience_id) = @_;

  my $operations = [];
  return $operations if not defined $audience_id;

  push @$operations,
    Google::Ads::GoogleAds::V18::Services::GoogleAdsService::MutateOperation->
    new({
      assetGroupSignalOperation =>
        Google::Ads::GoogleAds::V18::Services::AssetGroupSignalService::AssetGroupSignalOperation
        ->new({
          # To learn more about Audience Signals, see:
          # https://developers.google.com/google-ads/api/docs/performance-max/asset-groups#audience_signals
          create =>
            Google::Ads::GoogleAds::V18::Resources::AssetGroupSignal->new({
              assetGroup =>
                Google::Ads::GoogleAds::V18::Utils::ResourceNames::asset_group(
                $customer_id, ASSET_GROUP_TEMPORARY_ID
                ),
              audience =>
                Google::Ads::GoogleAds::V18::Common::AudienceInfo->new({
                  audience =>
                    Google::Ads::GoogleAds::V18::Utils::ResourceNames::audience(
                    $customer_id, $audience_id
                    )})})})});
  return $operations;
}
add_performance_max_campaign.pl
      

Esempio di codice dell'indicatore del tema di ricerca

Java

AssetGroupSignal searchThemeSignal =
    AssetGroupSignal.newBuilder()
        .setAssetGroup(assetGroupResourceName)
        .setSearchTheme(SearchThemeInfo.newBuilder().setText("travel").build())
        .build();

mutateOperations.add(
    MutateOperation.newBuilder()
        .setAssetGroupSignalOperation(
            AssetGroupSignalOperation.newBuilder().setCreate(searchThemeSignal))
        .build());
AddPerformanceMaxCampaign.java
      

C#

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

PHP

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

Python

mutate_operation = client.get_type("MutateOperation")
operation = mutate_operation.asset_group_signal_operation.create
operation.asset_group = asset_group_resource_name
operation.search_theme.text = "travel"
operations.append(mutate_operation)
add_performance_max_campaign.py
      

Ruby

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

Perl

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

---

Specifica i parametri ValueTrack (facoltativo)

Solo alcuni parametri ValueTrack sono supportati per le campagne Performance Max (scopri di più).

---

Ottimizzazione con consigli

Ottimizzare il rendimento delle campagne con i consigli

Categorie di consigli Performance Max:

• Offerte

• Efficacia del gruppo di asset

• Indicatori dei gruppi di asset

---

Procedura dettagliata per i video