실적 최대화 캠페인 만들기

/** Creates a MutateOperation that creates a new Performance Max campaign. */
private MutateOperation createPerformanceMaxCampaignOperation(
    long customerId, boolean brandGuidelinesEnabled) {
  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)
          // 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.
          .setStartDate(new DateTime().plusDays(1).toString("yyyyMMdd"))
          .setEndDate(new DateTime().plusDays(365).toString("yyyyMMdd"))
          // 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 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,

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

    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' => date('Ymd', strtotime('+1 day')),
                'end_date' => date('Ymd', 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 = (datetime.now() + timedelta(1)).strftime("%Y%m%d")
    campaign.end_date = (datetime.now() + timedelta(365)).strftime("%Y%m%d")

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

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::V22::Resources::AssetAutomationSetting->new({
        assetAutomationStatus => OPTED_IN,
        assetAutomationType   => $asset_automation_type
      });
  }

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

              # Optional fields.
              startDate => strftime("%Y%m%d", localtime(time + 60 * 60 * 24)),
              endDate   =>
                strftime("%Y%m%d", 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
      

/** Creates a list of MutateOperations that create linked brand assets. */
List<MutateOperation> createAndLinkBrandAssets(
    long customerId,
    boolean brandGuidelinesEnabled,
    String businessName,
    String logoUrl,
    String logoName)
    throws IOException {
  List<MutateOperation> mutateOperations = new ArrayList<>();

  // Creates the brand name text asset.
  String businessNameAssetResourceName = ResourceNames.asset(customerId, getNextTemporaryId());
  Asset businessNameAsset =
      Asset.newBuilder()
          .setResourceName(businessNameAssetResourceName)
          .setTextAsset(TextAsset.newBuilder().setText(businessName).build())
          .build();
  AssetOperation businessNameAssetOperation =
      AssetOperation.newBuilder().setCreate(businessNameAsset).build();
  mutateOperations.add(
      MutateOperation.newBuilder().setAssetOperation(businessNameAssetOperation).build());

  // Creates the logo image asset.
  String logoAssetResourceName = ResourceNames.asset(customerId, getNextTemporaryId());
  // Creates a media file.
  byte[] logoBytes = ByteStreams.toByteArray(new URL(logoUrl).openStream());
  Asset logoAsset =
      Asset.newBuilder()
          .setResourceName(logoAssetResourceName)
          .setImageAsset(ImageAsset.newBuilder().setData(ByteString.copyFrom(logoBytes)).build())
          // Provides a unique friendly name to identify your asset. When there is an existing
          // image asset with the same content but a different name, the new name will be dropped
          // silently.
          .setName(logoName)
          .build();
  AssetOperation logoImageAssetOperation =
      AssetOperation.newBuilder().setCreate(logoAsset).build();
  mutateOperations.add(
      MutateOperation.newBuilder().setAssetOperation(logoImageAssetOperation).build());

  if (brandGuidelinesEnabled) {
    // Creates CampaignAsset resources to link the Asset resources to the Campaign.
    mutateOperations.add(
        createCampaignAssetMutateOperation(
            customerId, AssetFieldType.BUSINESS_NAME, businessNameAssetResourceName));
    mutateOperations.add(
        createCampaignAssetMutateOperation(
            customerId, AssetFieldType.LOGO, logoAssetResourceName));
  } else {
    // Creates an AssetGroupAsset to link the Asset to the AssetGroup.
    mutateOperations.add(
        createAssetGroupAssetMutateOperation(
            AssetFieldType.BUSINESS_NAME,
            businessNameAssetResourceName,
            ResourceNames.assetGroup(customerId, ASSET_GROUP_TEMPORARY_ID)));
    mutateOperations.add(
        createAssetGroupAssetMutateOperation(
            AssetFieldType.LOGO,
            logoAssetResourceName,
            ResourceNames.assetGroup(customerId, ASSET_GROUP_TEMPORARY_ID)));
  }

  return mutateOperations;
}

/** Creates a MutateOperation to add an AssetGroupAsset. */
MutateOperation createAssetGroupAssetMutateOperation(
    AssetFieldType fieldType, String assetResourceName, String assetGroupResourceName) {
  AssetGroupAsset assetGroupAsset =
      AssetGroupAsset.newBuilder()
          .setFieldType(fieldType)
          .setAssetGroup(assetGroupResourceName)
          .setAsset(assetResourceName)
          .build();
  AssetGroupAssetOperation assetGroupAssetOperation =
      AssetGroupAssetOperation.newBuilder().setCreate(assetGroupAsset).build();
  return MutateOperation.newBuilder()
      .setAssetGroupAssetOperation(assetGroupAssetOperation)
      .build();
}

/** Creates a MutateOperation to add a CampaignAsset. */
MutateOperation createCampaignAssetMutateOperation(
    long customerId, AssetFieldType fieldType, String assetResourceName) {
  CampaignAsset campaignAsset =
      CampaignAsset.newBuilder()
          .setFieldType(fieldType)
          .setCampaign(ResourceNames.campaign(customerId, PERFORMANCE_MAX_CAMPAIGN_TEMPORARY_ID))
          .setAsset(assetResourceName)
          .build();
  CampaignAssetOperation campaignAssetOperation =
      CampaignAssetOperation.newBuilder().setCreate(campaignAsset).build();
  return MutateOperation.newBuilder().setCampaignAssetOperation(campaignAssetOperation).build();
}
AddPerformanceMaxCampaign.java
      

private List<MutateOperation> CreateAndLinkBrandAssets(
    string assetGroupResourceName,
    string campaignResourceName,
    AssetTemporaryResourceNameGenerator assetResourceNameGenerator,
    string businessName,
    string logoUrl,
    string logoName,
    GoogleAdsConfig config,
    bool brandGuidelinesEnabled)
{
    List<MutateOperation> operations = new List<MutateOperation>();

    string logoAssetResourceName = assetResourceNameGenerator.Next();
    string businessNameAssetResourceName = assetResourceNameGenerator.Next();

    // Create the Image Asset.
    operations.Add(
        new MutateOperation()
        {
            AssetOperation = new AssetOperation()
            {
                Create = new Asset()
                {
                    ResourceName = logoAssetResourceName,
                    ImageAsset = new ImageAsset()
                    {
                        Data =
                            ByteString.CopyFrom(
                                MediaUtilities.GetAssetDataFromUrl(logoUrl, config)
                            )
                    },
                    // Provide a unique friendly name to identify your asset.
                    // When there is an existing image asset with the same content but a
                    // different name, the new name will be dropped silently.
                    Name = logoName
                }
            }
        }
    );

    // Create the business name asset.
    operations.Add(
        new MutateOperation()
        {
            AssetOperation = new AssetOperation()
            {
                Create = new Asset()
                {
                    ResourceName = businessNameAssetResourceName,
                    TextAsset = new TextAsset()
                    {
                        Text = businessName,
                    }
                }
            }
        }
    );

    if (brandGuidelinesEnabled)
    {
        // Create CampaignAssets to link the Assets to the Campaign.
        operations.Add(
            new MutateOperation()
            {
                CampaignAssetOperation = new CampaignAssetOperation()
                {
                    Create = new CampaignAsset()
                    {
                        FieldType = AssetFieldType.Logo,
                        Campaign = campaignResourceName,
                        Asset = logoAssetResourceName
                    }
                }
            }
        );

        operations.Add(
            new MutateOperation()
            {
                CampaignAssetOperation = new CampaignAssetOperation()
                {
                    Create = new CampaignAsset()
                    {
                        FieldType = AssetFieldType.BusinessName,
                        Campaign = campaignResourceName,
                        Asset = businessNameAssetResourceName
                    }
                }
            }
        );
    } else {
        // Create AssetGroupAssets to link the Assets to the AssetGroup.
        operations.Add(
            new MutateOperation()
            {
                AssetGroupAssetOperation = new AssetGroupAssetOperation()
                {
                    Create = new AssetGroupAsset()
                    {
                        FieldType = AssetFieldType.Logo,
                        AssetGroup = assetGroupResourceName,
                        Asset = logoAssetResourceName
                    }
                }
            }
        );

        operations.Add(
            new MutateOperation()
            {
                AssetGroupAssetOperation = new AssetGroupAssetOperation()
                {
                    Create = new AssetGroupAsset()
                    {
                        FieldType = AssetFieldType.BusinessName,
                        AssetGroup = assetGroupResourceName,
                        Asset = businessNameAssetResourceName
                    }
                }
            }
        );

    }


    return operations;
}
AddPerformanceMaxCampaign.cs
      

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

def create_and_link_brand_assets(
    client: GoogleAdsClient,
    customer_id: str,
    brand_guidelines_enabled: bool,
    business_name: str,
    logo_url: str,
    logo_name: str,
) -> List[MutateOperation]:
    """Creates a list of MutateOperations that create linked brand assets.

    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.
        business_name: the business name text to be put into an asset.
        logo_url: the url of the logo to be retrieved and put into an asset.
        logo_name: the asset name of the logo.

    Returns:
        MutateOperations that create linked brand assets.
    """
    global next_temp_id
    operations: List[MutateOperation] = []
    asset_service: AssetServiceClient = client.get_service("AssetService")

    # Create the Text Asset.
    text_asset_temp_id = next_temp_id
    next_temp_id -= 1

    text_mutate_operation = client.get_type("MutateOperation")
    text_asset: Asset = text_mutate_operation.asset_operation.create
    text_asset.resource_name = asset_service.asset_path(
        customer_id, text_asset_temp_id
    )
    text_asset.text_asset.text = business_name
    operations.append(text_mutate_operation)

    # Create the Image Asset.
    image_asset_temp_id = next_temp_id
    next_temp_id -= 1

    image_mutate_operation = client.get_type("MutateOperation")
    image_asset: Asset = image_mutate_operation.asset_operation.create
    image_asset.resource_name = asset_service.asset_path(
        customer_id, image_asset_temp_id
    )
    # Provide a unique friendly name to identify your asset.
    # When there is an existing image asset with the same content but a different
    # name, the new name will be dropped silently.
    image_asset.name = logo_name
    image_asset.type_ = client.enums.AssetTypeEnum.IMAGE
    image_asset.image_asset.data = get_image_bytes_from_url(logo_url)
    operations.append(image_mutate_operation)

    if brand_guidelines_enabled:
        # Create CampaignAsset resources to link the Asset resources to the Campaign.
        campaign_service: CampaignServiceClient = client.get_service(
            "CampaignService"
        )

        business_name_mutate_operation: MutateOperation = client.get_type(
            "MutateOperation"
        )
        business_name_campaign_asset: CampaignAsset = (
            business_name_mutate_operation.campaign_asset_operation.create
        )
        business_name_campaign_asset.field_type = (
            client.enums.AssetFieldTypeEnum.BUSINESS_NAME
        )
        business_name_campaign_asset.campaign = campaign_service.campaign_path(
            customer_id, _PERFORMANCE_MAX_CAMPAIGN_TEMPORARY_ID
        )
        business_name_campaign_asset.asset = asset_service.asset_path(
            customer_id, text_asset_temp_id
        )
        operations.append(business_name_mutate_operation)

        logo_mutate_operation: MutateOperation = client.get_type(
            "MutateOperation"
        )
        logo_campaign_asset: CampaignAsset = (
            logo_mutate_operation.campaign_asset_operation.create
        )
        logo_campaign_asset.field_type = client.enums.AssetFieldTypeEnum.LOGO
        logo_campaign_asset.campaign = campaign_service.campaign_path(
            customer_id, _PERFORMANCE_MAX_CAMPAIGN_TEMPORARY_ID
        )
        logo_campaign_asset.asset = asset_service.asset_path(
            customer_id, image_asset_temp_id
        )
        operations.append(logo_mutate_operation)

    else:
        # Create AssetGroupAsset resources to link the Asset resources to the AssetGroup.
        asset_group_service: AssetGroupServiceClient = client.get_service(
            "AssetGroupService"
        )

        business_name_mutate_operation: MutateOperation = client.get_type(
            "MutateOperation"
        )
        business_name_asset_group_asset: AssetGroupAsset = (
            business_name_mutate_operation.asset_group_asset_operation.create
        )
        business_name_asset_group_asset.field_type = (
            client.enums.AssetFieldTypeEnum.BUSINESS_NAME
        )
        business_name_asset_group_asset.asset_group = (
            asset_group_service.asset_group_path(
                customer_id,
                _ASSET_GROUP_TEMPORARY_ID,
            )
        )
        business_name_asset_group_asset.asset = asset_service.asset_path(
            customer_id, text_asset_temp_id
        )
        operations.append(business_name_mutate_operation)

        logo_mutate_operation: MutateOperation = client.get_type(
            "MutateOperation"
        )
        logo_asset_group_asset: AssetGroupAsset = (
            logo_mutate_operation.asset_group_asset_operation.create
        )
        logo_asset_group_asset.field_type = client.enums.AssetFieldTypeEnum.LOGO
        logo_asset_group_asset.asset_group = (
            asset_group_service.asset_group_path(
                customer_id,
                _ASSET_GROUP_TEMPORARY_ID,
            )
        )
        logo_asset_group_asset.asset = asset_service.asset_path(
            customer_id, image_asset_temp_id
        )
        operations.append(logo_mutate_operation)

    return operations
add_performance_max_campaign.py
      

# Creates a list of MutateOperations that create linked brand assets.
def create_and_link_brand_assets(
    client,
    customer_id,
    brand_guidelines_enabled,
    business_name,
    logo_url,
    logo_name)
  operations = []

  # Create the Text Asset.
  text_asset_temp_id = next_temp_id
  operations << client.operation.mutate do |m|
    m.asset_operation = client.operation.create_resource.asset do |a|
      a.resource_name = client.path.asset(customer_id, text_asset_temp_id)
      a.text_asset = client.resource.text_asset do |text_asset|
        text_asset.text = business_name
      end
    end
  end

  # Create the Image Asset.
  image_asset_temp_id = next_temp_id
  operations << client.operation.mutate do |m|
    m.asset_operation = client.operation.create_resource.asset do |a|
      a.resource_name = client.path.asset(customer_id, image_asset_temp_id)
      # Provide a unique friendly name to identify your asset.
      # When there is an existing image asset with the same content but a different
      # name, the new name will be dropped silently.
      a.name = logo_name
      a.type = :IMAGE
      a.image_asset = client.resource.image_asset do |image_asset|
        image_asset.data = get_image_bytes(logo_url)
      end
    end
  end

  if brand_guidelines_enabled
    # Create CampaignAsset resources to link the Asset resources to the Campaign.
    operations << client.operation.mutate do |m|
      m.campaign_asset_operation = client.operation.create_resource.
          campaign_asset do |ca|
        ca.field_type = :BUSINESS_NAME
        ca.campaign = client.path.campaign(
          customer_id,
          PERFORMANCE_MAX_CAMPAIGN_TEMPORARY_ID,
        )
        ca.asset = client.path.asset(customer_id, text_asset_temp_id)
      end
    end

    operations << client.operation.mutate do |m|
      m.campaign_asset_operation = client.operation.create_resource.
          campaign_asset do |ca|
        ca.field_type = :LOGO
        ca.campaign = client.path.campaign(
          customer_id,
          PERFORMANCE_MAX_CAMPAIGN_TEMPORARY_ID,
        )
        ca.asset = client.path.asset(customer_id, image_asset_temp_id)
      end
    end
  else
    # Create AssetGroupAsset resources to link the Asset resources to the AssetGroup.
    operations << client.operation.mutate do |m|
      m.asset_group_asset_operation = client.operation.create_resource.
          asset_group_asset do |aga|
        aga.field_type = :BUSINESS_NAME
        aga.asset_group = client.path.asset_group(
          customer_id,
          ASSET_GROUP_TEMPORARY_ID,
        )
        aga.asset = client.path.asset(customer_id, text_asset_temp_id)
      end
    end

    operations << client.operation.mutate do |m|
      m.asset_group_asset_operation = client.operation.create_resource.
          asset_group_asset do |aga|
        aga.field_type = :LOGO
        aga.asset_group = client.path.asset_group(
          customer_id,
          ASSET_GROUP_TEMPORARY_ID,
        )
        aga.asset = client.path.asset(customer_id, image_asset_temp_id)
      end
    end
  end

  operations
end
add_performance_max_campaign.rb
      

# Creates a list of MutateOperations that create linked brand assets.
sub create_and_link_brand_assets {
  my ($customer_id, $brand_guidelines_enabled, $business_name, $logo_url,
    $logo_name)
    = @_;

  my $operations = [];

  # Create the text asset.
  my $text_asset_temp_id = $next_temp_id--;
  push @$operations,
    Google::Ads::GoogleAds::V22::Services::GoogleAdsService::MutateOperation->
    new({
      assetOperation =>
        Google::Ads::GoogleAds::V22::Services::AssetService::AssetOperation->
        new({
          create => Google::Ads::GoogleAds::V22::Resources::Asset->new({
              resourceName =>
                Google::Ads::GoogleAds::V22::Utils::ResourceNames::asset(
                $customer_id, $text_asset_temp_id
                ),
              textAsset => Google::Ads::GoogleAds::V22::Common::TextAsset->new({
                  text => $business_name
                })})})});

  # Create the image asset.
  my $image_asset_temp_id = $next_temp_id--;
  push @$operations,
    Google::Ads::GoogleAds::V22::Services::GoogleAdsService::MutateOperation->
    new({
      assetOperation =>
        Google::Ads::GoogleAds::V22::Services::AssetService::AssetOperation->
        new({
          create => Google::Ads::GoogleAds::V22::Resources::Asset->new({
              resourceName =>
                Google::Ads::GoogleAds::V22::Utils::ResourceNames::asset(
                $customer_id, $image_asset_temp_id
                ),
              # Provide a unique friendly name to identify your asset.
              # When there is an existing image asset with the same content but a different
              # name, the new name will be dropped silently.
              name       => $logo_name,
              imageAsset =>
                Google::Ads::GoogleAds::V22::Common::ImageAsset->new({
                  data => get_base64_data_from_url($logo_url)})})})});

  if ($brand_guidelines_enabled) {
    # Create CampaignAsset resources to link the Asset resources to the Campaign.
    push @$operations,
      Google::Ads::GoogleAds::V22::Services::GoogleAdsService::MutateOperation
      ->new({
        campaignAssetOperation =>
          Google::Ads::GoogleAds::V22::Services::CampaignAssetService::CampaignAssetOperation
          ->new({
            create =>
              Google::Ads::GoogleAds::V22::Resources::CampaignAsset->new({
                fieldType => BUSINESS_NAME,
                campaign  =>
                  Google::Ads::GoogleAds::V22::Utils::ResourceNames::campaign(
                  $customer_id, PERFORMANCE_MAX_CAMPAIGN_TEMPORARY_ID
                  ),
                asset =>
                  Google::Ads::GoogleAds::V22::Utils::ResourceNames::asset(
                  $customer_id, $text_asset_temp_id
                  )})})});

    push @$operations,
      Google::Ads::GoogleAds::V22::Services::GoogleAdsService::MutateOperation
      ->new({
        campaignAssetOperation =>
          Google::Ads::GoogleAds::V22::Services::CampaignAssetService::CampaignAssetOperation
          ->new({
            create =>
              Google::Ads::GoogleAds::V22::Resources::CampaignAsset->new({
                fieldType => LOGO,
                campaign  =>
                  Google::Ads::GoogleAds::V22::Utils::ResourceNames::campaign(
                  $customer_id, PERFORMANCE_MAX_CAMPAIGN_TEMPORARY_ID
                  ),
                asset =>
                  Google::Ads::GoogleAds::V22::Utils::ResourceNames::asset(
                  $customer_id, $image_asset_temp_id
                  )})})});
  } else {
    # Create AssetGroupAsset resources to link the Asset resources to the AssetGroup.
    push @$operations,
      Google::Ads::GoogleAds::V22::Services::GoogleAdsService::MutateOperation
      ->new({
        assetGroupAssetOperation =>
          Google::Ads::GoogleAds::V22::Services::AssetGroupAssetService::AssetGroupAssetOperation
          ->new({
            create =>
              Google::Ads::GoogleAds::V22::Resources::AssetGroupAsset->new({
                asset =>
                  Google::Ads::GoogleAds::V22::Utils::ResourceNames::asset(
                  $customer_id, $text_asset_temp_id
                  ),
                assetGroup =>
                  Google::Ads::GoogleAds::V22::Utils::ResourceNames::asset_group(
                  $customer_id, ASSET_GROUP_TEMPORARY_ID
                  ),
                fieldType => BUSINESS_NAME
              })})});

    push @$operations,
      Google::Ads::GoogleAds::V22::Services::GoogleAdsService::MutateOperation
      ->new({
        assetGroupAssetOperation =>
          Google::Ads::GoogleAds::V22::Services::AssetGroupAssetService::AssetGroupAssetOperation
          ->new({
            create =>
              Google::Ads::GoogleAds::V22::Resources::AssetGroupAsset->new({
                asset =>
                  Google::Ads::GoogleAds::V22::Utils::ResourceNames::asset(
                  $customer_id, $image_asset_temp_id
                  ),
                assetGroup =>
                  Google::Ads::GoogleAds::V22::Utils::ResourceNames::asset_group(
                  $customer_id, ASSET_GROUP_TEMPORARY_ID
                  ),
                fieldType => LOGO
              })})});
  }

  return $operations;
}
add_performance_max_campaign.pl