شروع به کار با «عملکرد بیشینه»

/** 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
      

/// <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,

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

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
      

def create_campaign_budget_operation(
    client: GoogleAdsClient,
    customer_id: str,
) -> MutateOperation:
    """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: MutateOperation = client.get_type("MutateOperation")
    campaign_budget_operation: CampaignBudgetOperation = (
        mutate_operation.campaign_budget_operation
    )
    campaign_budget: CampaignBudget = 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
      

# 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
      

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

  # Create a mutate operation that creates a campaign budget operation.
  return
    Google::Ads::GoogleAds::V26::Services::GoogleAdsService::MutateOperation->
    new({
      campaignBudgetOperation =>
        Google::Ads::GoogleAds::V26::Services::CampaignBudgetService::CampaignBudgetOperation
        ->new({
          create => Google::Ads::GoogleAds::V26::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::V26::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
      

/** Creates a MutateOperation that creates a new Performance Max campaign. */
private MutateOperation createPerformanceMaxCampaignOperation(
    long customerId, boolean brandGuidelinesEnabled) {
  TextGuidelines textGuidelines =
      TextGuidelines.newBuilder()
          // Specifies a list of terms that should not be used in any auto-generated
          // text assets.
          .addAllTermExclusions(ImmutableList.of("cheap", "free"))
          // Specifies freeform messaging restriction prompts that will apply to all
          // auto-generated text assets.
          .addMessagingRestrictions(
              MessagingRestriction.newBuilder()
                  .setRestrictionText("Don't mention competitor names")
                  .setRestrictionType(
                      MessagingRestrictionType.RESTRICTION_BASED_EXCLUSION)
                  .build())
          .build();
  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 if the campaign is enabled for brand guidelines. For more information on brand
          // guidelines, see https://support.google.com/google-ads/answer/14934472.
          .setBrandGuidelinesEnabled(brandGuidelinesEnabled)
          // Sets the text guidelines.
          .setTextGuidelines(textGuidelines)
          // 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))
          // Declares whether this campaign serves political ads targeting the EU.
          .setContainsEuPoliticalAdvertising(DOES_NOT_CONTAIN_EU_POLITICAL_ADVERTISING)
          // Optional fields.
          .setStartDateTime(new DateTime().plusDays(1).toString("yyyy-MM-dd 00:00:00"))
          .setEndDateTime(new DateTime().plusDays(365).toString("yyyy-MM-dd 23:59:59"))
          // Configures the optional opt-in/out status for asset automation settings.
          .addAllAssetAutomationSettings(ImmutableList.of(
              AssetAutomationSetting.newBuilder()
                  .setAssetAutomationType(AssetAutomationType.GENERATE_IMAGE_EXTRACTION)
                  .setAssetAutomationStatus(AssetAutomationStatus.OPTED_IN).build(),
              AssetAutomationSetting.newBuilder()
                  .setAssetAutomationType(
                      AssetAutomationType.FINAL_URL_EXPANSION_TEXT_ASSET_AUTOMATION)
                  .setAssetAutomationStatus(AssetAutomationStatus.OPTED_IN).build(),
              AssetAutomationSetting.newBuilder()
                  .setAssetAutomationType(AssetAutomationType.TEXT_ASSET_AUTOMATION)
                  .setAssetAutomationStatus(AssetAutomationStatus.OPTED_IN).build(),
              AssetAutomationSetting.newBuilder()
                  .setAssetAutomationType(AssetAutomationType.GENERATE_ENHANCED_YOUTUBE_VIDEOS)
                  .setAssetAutomationStatus(AssetAutomationStatus.OPTED_IN).build(),
              AssetAutomationSetting.newBuilder()
                  .setAssetAutomationType(AssetAutomationType.GENERATE_IMAGE_ENHANCEMENT)
                  .setAssetAutomationStatus(AssetAutomationStatus.OPTED_IN).build()))
          .build();

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

/// 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>
/// <param name="brandGuidelinesEnabled">Whether or not to enable brand guidelines.</param>
/// <returns>A MutateOperations that will create this new campaign.</returns>
private MutateOperation CreatePerformanceMaxCampaignOperation(
    string campaignResourceName,
    string campaignBudgetResourceName,
    bool brandGuidelinesEnabled)
{
    Campaign.Types.TextGuidelines textGuidelines =
        new Campaign.Types.TextGuidelines();
    textGuidelines.TermExclusions.AddRange(["cheap", "free"]);
    textGuidelines.MessagingRestrictions.Add(
        new Campaign.Types.MessagingRestriction()
        {
            RestrictionText = "Don't mention competitor names",
            RestrictionType = MessagingRestrictionType.RestrictionBasedExclusion
        }
    );

    Campaign campaign = 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
        },

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

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

        // Set if the campaign is enabled for brand guidelines. For more information
        // on brand guidelines, see https://support.google.com/google-ads/answer/14934472.
        BrandGuidelinesEnabled = brandGuidelinesEnabled,

        // Declare whether or not this campaign contains political ads targeting the EU.
        ContainsEuPoliticalAdvertising = EuPoliticalAdvertisingStatus.DoesNotContainEuPoliticalAdvertising,

        TextGuidelines = textGuidelines,

        // Optional fields
        StartDateTime = DateTime.Now.AddDays(1).ToString("yyyyMMdd 00:00:00"),
        EndDateTime = DateTime.Now.AddDays(365).ToString("yyyyMMdd 23:59:59")
    };

    campaign.AssetAutomationSettings.AddRange(new[]{
        new Campaign.Types.AssetAutomationSetting
        {
            AssetAutomationType = AssetAutomationType.GenerateImageExtraction,
            AssetAutomationStatus = AssetAutomationStatus.OptedIn
        },
        new Campaign.Types.AssetAutomationSetting
        {
            AssetAutomationType = AssetAutomationType.FinalUrlExpansionTextAssetAutomation,
            AssetAutomationStatus = AssetAutomationStatus.OptedIn
        },
        new Campaign.Types.AssetAutomationSetting
        {
            AssetAutomationType = AssetAutomationType.TextAssetAutomation,
            AssetAutomationStatus = AssetAutomationStatus.OptedIn
        },
        new Campaign.Types.AssetAutomationSetting
        {
            AssetAutomationType = AssetAutomationType.GenerateEnhancedYoutubeVideos,
            AssetAutomationStatus = AssetAutomationStatus.OptedIn
        },
        new Campaign.Types.AssetAutomationSetting
        {
            AssetAutomationType = AssetAutomationType.GenerateImageEnhancement,
            AssetAutomationStatus = AssetAutomationStatus.OptedIn
        },
    });

    MutateOperation operation = new MutateOperation()
    {
        CampaignOperation = new CampaignOperation()
        {
            Create = campaign
        }
    };

    return operation;
}
AddPerformanceMaxCampaign.cs
      

private static function createPerformanceMaxCampaignOperation(
    int $customerId,
    bool $brandGuidelinesEnabled
): 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
                    ]
                ),

                'asset_automation_settings' => [
                    new AssetAutomationSetting(
                        [
                        'asset_automation_type' => AssetAutomationType::TEXT_ASSET_AUTOMATION,
                        'asset_automation_status' => AssetAutomationStatus::OPTED_IN
                        ]
                    ),
                    new AssetAutomationSetting(
                        [
                        'asset_automation_type' => AssetAutomationType::URL_EXPANSION,
                        'asset_automation_status' => AssetAutomationStatus::OPTED_IN
                        ]
                    )
                ],


                // Sets if the campaign is enabled for brand guidelines. For more information
                // on brand guidelines, see
                // https://support.google.com/google-ads/answer/14934472.
                'brand_guidelines_enabled' => $brandGuidelinesEnabled,

                // Declare whether or not this campaign serves political ads targeting the EU.
                'contains_eu_political_advertising' =>
                    EuPoliticalAdvertisingStatus::DOES_NOT_CONTAIN_EU_POLITICAL_ADVERTISING,

                // Optional fields.
                'start_date_time' => date('Y-m-d 00:00:00', strtotime('+1 day')),
                'end_date_time' => date('Y-m-d 23:59:59', strtotime('+365 days'))
                ]
            )
            ]
        )
        ]
    );
}
AddPerformanceMaxCampaign.php
      

def create_performance_max_campaign_operation(
    client: GoogleAdsClient,
    customer_id: str,
    brand_guidelines_enabled: bool,
) -> MutateOperation:
    """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.
        brand_guidelines_enabled: a boolean value indicating if the campaign is
          enabled for brand guidelines.

    Returns:
        a MutateOperation that creates a campaign.
    """
    mutate_operation: MutateOperation = client.get_type("MutateOperation")
    campaign: 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 if the campaign is enabled for brand guidelines. For more information
    # on brand guidelines, see https://support.google.com/google-ads/answer/14934472.
    campaign.brand_guidelines_enabled = brand_guidelines_enabled

    # Assign the resource name with a temporary ID.
    campaign_service: CampaignServiceClient = 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
    )

    # Declare whether or not this campaign serves political ads targeting the
    # EU. Valid values are:
    #   CONTAINS_EU_POLITICAL_ADVERTISING
    #   DOES_NOT_CONTAIN_EU_POLITICAL_ADVERTISING
    campaign.contains_eu_political_advertising = (
        client.enums.EuPoliticalAdvertisingStatusEnum.DOES_NOT_CONTAIN_EU_POLITICAL_ADVERTISING
    )

    # Optional fields
    campaign.start_date_time = (datetime.now() + timedelta(1)).strftime(
        "%Y%m%d 00:00:00"
    )
    campaign.end_date_time = (datetime.now() + timedelta(365)).strftime(
        "%Y%m%d 23:59:59"
    )

    campaign.text_guidelines.term_exclusions = ["cheap", "free"]
    messaging_restriction = campaign.MessagingRestriction()
    messaging_restriction.restriction_text = "Don't mention competitor names"
    messaging_restriction.restriction_type = (
        client.enums.MessagingRestrictionTypeEnum.RESTRICTION_BASED_EXCLUSION
    )
    campaign.text_guidelines.messaging_restrictions.append(
        messaging_restriction
    )

    # Configures the optional opt-in/out status for asset automation settings.
    for asset_automation_type_enum in [
        client.enums.AssetAutomationTypeEnum.GENERATE_IMAGE_EXTRACTION,
        client.enums.AssetAutomationTypeEnum.FINAL_URL_EXPANSION_TEXT_ASSET_AUTOMATION,
        client.enums.AssetAutomationTypeEnum.TEXT_ASSET_AUTOMATION,
        client.enums.AssetAutomationTypeEnum.GENERATE_ENHANCED_YOUTUBE_VIDEOS,
        client.enums.AssetAutomationTypeEnum.GENERATE_IMAGE_ENHANCEMENT,
    ]:
        asset_automattion_setting: Campaign.AssetAutomationSetting = (
            client.get_type("Campaign").AssetAutomationSetting()
        )
        asset_automattion_setting.asset_automation_type = (
            asset_automation_type_enum
        )
        asset_automattion_setting.asset_automation_status = (
            client.enums.AssetAutomationStatusEnum.OPTED_IN
        )
        campaign.asset_automation_settings.append(asset_automattion_setting)

    return mutate_operation
add_performance_max_campaign.py
      

# 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,
    brand_guidelines_enabled)
  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

      # Configures the optional opt-in/out status for asset automation settings.
      c.asset_automation_settings << client.resource.asset_automation_setting do |aas|
        aas.asset_automation_type = :GENERATE_IMAGE_EXTRACTION
        aas.asset_automation_status = :OPTED_IN
      end
      c.asset_automation_settings << client.resource.asset_automation_setting do |aas|
        aas.asset_automation_type = :FINAL_URL_EXPANSION_TEXT_ASSET_AUTOMATION
        aas.asset_automation_status = :OPTED_IN
      end
      c.asset_automation_settings << client.resource.asset_automation_setting do |aas|
        aas.asset_automation_type = :TEXT_ASSET_AUTOMATION
        aas.asset_automation_status = :OPTED_IN
      end
      c.asset_automation_settings << client.resource.asset_automation_setting do |aas|
        aas.asset_automation_type = :GENERATE_ENHANCED_YOUTUBE_VIDEOS
        aas.asset_automation_status = :OPTED_IN
      end
      c.asset_automation_settings << client.resource.asset_automation_setting do |aas|
        aas.asset_automation_type = :GENERATE_IMAGE_ENHANCEMENT
        aas.asset_automation_status = :OPTED_IN
      end

      # Set if the campaign is enabled for brand guidelines. For more
      # information on brand guidelines, see
      # https://support.google.com/google-ads/answer/14934472.
      c.brand_guidelines_enabled = brand_guidelines_enabled

      # 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)

      # Declare whether or not this campaign serves political ads targeting the EU.
      # Valid values are CONTAINS_EU_POLITICAL_ADVERTISING and
      # DOES_NOT_CONTAIN_EU_POLITICAL_ADVERTISING.
      c.contains_eu_political_advertising = :DOES_NOT_CONTAIN_EU_POLITICAL_ADVERTISING

      # Optional fields
      c.start_date_time = DateTime.parse((Date.today + 1).to_s).strftime('%Y%m%d %H:%M:%S')
      c.end_date_time = DateTime.parse(Date.today.next_year.to_s).strftime('%Y%m%d %H:%M:%S')
    end
  end
end
add_performance_max_campaign.rb
      

sub create_performance_max_campaign_operation {
  my ($customer_id, $brand_guidelines_enabled) = @_;
  # Configures the optional opt-in/out status for asset automation settings.
  # When we create the campaign object, we set campaign->{assetAutomationSettings}
  # equal to $asset_automation_settings.
  my $asset_automation_settings = [];
  my $asset_automation_types    = [
    GENERATE_IMAGE_EXTRACTION, FINAL_URL_EXPANSION_TEXT_ASSET_AUTOMATION,
    TEXT_ASSET_AUTOMATION,     GENERATE_ENHANCED_YOUTUBE_VIDEOS,
    GENERATE_IMAGE_ENHANCEMENT
  ];
  foreach my $asset_automation_type (@$asset_automation_types) {
    push @$asset_automation_settings,
      Google::Ads::GoogleAds::V26::Resources::AssetAutomationSetting->new({
        assetAutomationStatus => OPTED_IN,
        assetAutomationType   => $asset_automation_type
      });
  }

  my $text_guidelines =
    Google::Ads::GoogleAds::V26::Resources::TextGuidelines->new({
      termExclusions        => ["cheap", "free"],
      messagingRestrictions => [
        Google::Ads::GoogleAds::V26::Resources::MessagingRestriction->new({
            restrictionText => "Don't mention competitor names",
            restrictionType => RESTRICTION_BASED_EXCLUSION
          })]});

  # Create a mutate operation that creates a campaign operation.
  return
    Google::Ads::GoogleAds::V26::Services::GoogleAdsService::MutateOperation->
    new({
      campaignOperation =>
        Google::Ads::GoogleAds::V26::Services::CampaignService::CampaignOperation
        ->new({
          create => Google::Ads::GoogleAds::V26::Resources::Campaign->new({
              # Assign the resource name with a temporary ID.
              resourceName =>
                Google::Ads::GoogleAds::V26::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::V26::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::V26::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::V26::Common::MaximizeConversionValue->
                new({
                  targetRoas => 3.5
                }
                ),

              # Set if the campaign is enabled for brand guidelines. For more information
              # on brand guidelines, see https://support.google.com/google-ads/answer/14934472.
              brandGuidelinesEnabled => $brand_guidelines_enabled,

              # Configures the optional opt-in/out status for asset automation settings.
              assetAutomationSettings => $asset_automation_settings,

              # Set the text guidelines.
              textGuidelines => $text_guidelines,

              # Optional fields.
              startDateTime =>
                strftime("%Y%m%d 00:00:00", localtime(time + 60 * 60 * 24)),
              endDateTime => strftime(
                "%Y%m%d 23:59:59",
                localtime(time + 60 * 60 * 24 * 365)
              ),

              # Declare whether or not this campaign serves political ads targeting the EU.
              # Valid values are CONTAINS_EU_POLITICAL_ADVERTISING and
              # DOES_NOT_CONTAIN_EU_POLITICAL_ADVERTISING.
              containsEuPoliticalAdvertising =>
                DOES_NOT_CONTAIN_EU_POLITICAL_ADVERTISING
            })})});
}
add_performance_max_campaign.pl
      

/** 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
      

/// <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="linkedEntityResourceName">The resource name of the entity (asset group or
/// campaign) to link the asset to.</param>
/// <param name="assetResourceName">The resource name of the text asset to be
/// linked.</param>
/// <param name="brandGuidelinesEnabled">Whether or not to enable brand guidelines.</param>
/// <returns>A MutateOperation that links an asset to an asset group.</returns>
private MutateOperation CreateLinkAssetOperation(
    AssetFieldType fieldType,
    string linkedEntityResourceName,
    string assetResourceName,
    bool brandGuidelinesEnabled = false)
{ if (brandGuidelinesEnabled)
    {
        return new MutateOperation()
        {
            CampaignAssetOperation = new CampaignAssetOperation()
            {
                Create = new CampaignAsset()
                {
                    FieldType = fieldType,
                    Campaign = linkedEntityResourceName,
                    Asset = assetResourceName
                }
            }
        };
    } else
    {   return new MutateOperation()
        {
            AssetGroupAssetOperation = new AssetGroupAssetOperation()
            {
                Create = new AssetGroupAsset()
                {
                    FieldType = fieldType,
                    AssetGroup = linkedEntityResourceName,
                    Asset = assetResourceName
                }
            }
        };
    }
}
AddPerformanceMaxRetailCampaign.cs
      

    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
      

def get_customer_conversion_goals(
    client: GoogleAdsClient, customer_id: str
) -> List[
    Dict[
        str,
        Union[
            ConversionActionCategoryEnum.ConversionActionCategory,
            ConversionOriginEnum.ConversionOrigin,
        ],
    ]
]:
    """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: GoogleAdsServiceClient = client.get_service("GoogleAdsService")
    customer_conversion_goals: List[
        Dict[
            str,
            Union[
                ConversionActionCategoryEnum.ConversionActionCategory,
                ConversionOriginEnum.ConversionOrigin,
            ],
        ]
    ] = []
    query: str = """
            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: SearchGoogleAdsRequest = client.get_type(
        "SearchGoogleAdsRequest"
    )
    search_request.customer_id = customer_id
    search_request.query = query
    results: SearchGoogleAdsResponse = 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: GoogleAdsClient,
    customer_id: str,
    customer_conversion_goals: List[
        Dict[
            str,
            Union[
                ConversionActionCategoryEnum.ConversionActionCategory,
                ConversionOriginEnum.ConversionOrigin,
            ],
        ]
    ],
) -> List[MutateOperation]:
    """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: CampaignConversionGoalServiceClient = (
        client.get_service("CampaignConversionGoalService")
    )
    operations: List[MutateOperation] = []

    # 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_goal_dict in customer_conversion_goals:
        mutate_operation: MutateOperation = client.get_type("MutateOperation")
        campaign_conversion_goal: CampaignConversionGoal = (
            mutate_operation.campaign_conversion_goal_operation.update
        )

        category_enum_value: (
            ConversionActionCategoryEnum.ConversionActionCategory
        ) = customer_goal_dict["category"]
        origin_enum_value: ConversionOriginEnum.ConversionOrigin = (
            customer_goal_dict["origin"]
        )

        campaign_conversion_goal.resource_name = (
            campaign_conversion_goal_service.campaign_conversion_goal_path(
                customer_id,
                _PERFORMANCE_MAX_CAMPAIGN_TEMPORARY_ID,
                category_enum_value.name,
                origin_enum_value.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 (
            category_enum_value
            == client.enums.ConversionActionCategoryEnum.PURCHASE
            and origin_enum_value == 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
      

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
      

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::V26::Resources::CampaignConversionGoal->new({
        resourceName =>
          Google::Ads::GoogleAds::V26::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::V26::Services::GoogleAdsService::MutateOperation
      ->new({
        campaignConversionGoalOperation =>
          Google::Ads::GoogleAds::V26::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
      

/** 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
      

/// <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.V26.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
      

    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
      

def create_multiple_text_assets(
    client: GoogleAdsClient, customer_id: str, texts: List[str]
) -> List[str]:
    """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: GoogleAdsServiceClient = client.get_service(
        "GoogleAdsService"
    )

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

    # Send the operations in a single Mutate request.
    response: MutateGoogleAdsResponse = googleads_service.mutate(
        customer_id=customer_id,
        mutate_operations=operations,
    )
    asset_resource_names: List[str] = []
    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
      

# 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
      

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::V26::Services::GoogleAdsService::MutateOperation
      ->new({
        assetOperation =>
          Google::Ads::GoogleAds::V26::Services::AssetService::AssetOperation->
          new({
            create => Google::Ads::GoogleAds::V26::Resources::Asset->new({
                textAsset =>
                  Google::Ads::GoogleAds::V26::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
      

/** Creates a list of MutateOperations that create a new AssetGroup. */
private List<MutateOperation> createAssetGroupOperations(
    long customerId,
    String assetGroupResourceName,
    List<String> headlineAssetResourceNames,
    List<String> descriptionAssetResourceNames,
    boolean brandGuidelinesEnabled)
    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) {
    mutateOperations.add(
        createAssetGroupAssetMutateOperation(
            AssetFieldType.HEADLINE, resourceName, assetGroupResourceName));
  }

  // Links the description assets.
  for (String resourceName : descriptionAssetResourceNames) {
    mutateOperations.add(
        createAssetGroupAssetMutateOperation(
            AssetFieldType.DESCRIPTION, resourceName, assetGroupResourceName));
  }

  // 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 and logo assets.
  List<MutateOperation> createAndLinkBrandAssets =
      createAndLinkBrandAssets(
          customerId,
          brandGuidelinesEnabled,
          "Interplanetary Cruises",
          "https://gaagl.page.link/bjYi",
          "Marketing Logo");
  mutateOperations.addAll(createAndLinkBrandAssets);

  // Creates and links the image assets.

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