Maksimum performans kampanyası oluşturun

Gerekli öğeler ve bütçe ile kampanya artık oluşturulabilir.

Maksimum Performans kampanyalarının AdvertisingChannelType PERFORMANCE_MAX. AdvertisingChannelSubType ayarlanmamalıdır.

Desteklenen tek teklif stratejileri şunlardır:

• Değerleri izlemiyorsanız ve tüm dönüşümleriniz sizin için eşit değerdeyse MaximizeConversions teklif stratejisini kullanın. İsteğe bağlı bir hedef EBM (işlem başına maliyet) ayarlanabilir. Daha fazla bilgi
• Dönüşümlerinizle elde ettiğiniz değerleri izliyorsanız MaximizeConversionValue teklif stratejisini ayarlayın. İsteğe bağlı bir hedef ROAS (reklam harcamalarından elde edilen gelir) ayarlanabilir. Daha fazla bilgi

Portföy teklifi stratejileri, BiddingStrategyService kullanılarak oluşturulduğunda Maksimum Performans kampanyaları tarafından desteklenmez. Portföy teklifi stratejisinde birden çok kampanya oluşturmak yerine daha az kampanya ve daha fazla öğe grubu kullanın.

Java

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

C#

/// Creates a MutateOperation that creates a new Performance Max campaign.
/// <param name="campaignResourceName">The campaign resource name.</param>
/// <param name="campaignBudgetResourceName">The campaign budget resource name.</param>
/// <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
      

PHP

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
      

Python

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
      

Ruby

# Creates a MutateOperation that creates a new Performance Max campaign.
#
# A temporary ID will be assigned to this campaign so that it can
# be referenced by other objects being created in the same Mutate request.
def create_performance_max_campaign_operation(
    client,
    customer_id,
    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
      

Perl

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
      

Teklif önerileri

Google Ads API, Maksimum Performans kampanyası tekliflerinizi optimize etmenize yardımcı olmak için iki tür öneri sunar:

• MAXIMIZE_CONVERSION_VALUE_OPT_IN kampanyalarınız için dönüşüm değerini artırma teklif stratejisini kullanmanızı önerir.
• MAXIMIZE_CONVERSIONS_OPT_IN kampanyalarınızda dönüşümleri artırma teklif stratejisinin kullanılmasını önerir ve önerilen bir bütçe tutarı sağlar.

Önerileri kullanma hakkında daha fazla bilgi için Optimizasyon puanı ve öneriler kılavuzunu ziyaret edin.

Markalama kuralları

Marka kuralları, markanızın Maksimum Performans kampanyası otomatik öğelerinde veya biçimlerinde nasıl temsil edileceğini kontrol eder. Google Ads API v21'den itibaren Maksimum Performans kampanyaları, online satış veya potansiyel müşteri kazanma için tüm yeni Maksimum Performans (standart) ve ürün feed'i olan online satışlar için Maksimum Performans (perakende) kampanyalarında marka kurallarını otomatik olarak etkinleştirir. Yeni kampanyalarınızda marka kurallarını etkinleştirmek istemiyorsanız yeni Maksimum Performans kampanyanızı oluştururken Campaign.brand_guidelines_enabled seçeneğini false olarak ayarlayın.

Önemli: Seyahat hedefleri için Maksimum Performans, marka yönergelerini desteklemez.

Marka kurallarının etkin olduğu Maksimum Performans kampanyalarında, marka öğesi alan türleri için kampanya düzeyinde öğeler kullanılır ( BUSINESS_NAME, LOGO ve LANDSCAPE_LOGO). Marka öğelerini CampaignAsset kullanarak kampanyaya bağlamanız gerekir ve kampanyada şunlar bulunmalıdır:

• Tam olarak bir BUSINESS_NAME öğesi
• En az bir LOGO öğesi ve LOGO veya LANDSCAPE_LOGO türünde en fazla dört isteğe bağlı ek logo öğesi

Önemli: Bu marka öğelerinin tümü kampanya düzeyinde bağlanmalı ve kısmi hata kullanılmadan tek bir kampanya oluşturma isteğine dahil edilmelidir. Gerekli marka öğeleri eklenmezse marka kurallarının etkinleştirildiği kampanya oluşturma isteği başarısız olur. Ürün feed'i kullanan online satış kampanyaları, yalnızca AssetGroupAsset içermemeleri durumunda bu koşullardan muaftır.

Kampanya için isteğe bağlı renk ve yazı tipi yönergeleri, Campaign.brand_guidelines alanı kullanılarak ayarlanabilir:

• main_color, birincil rengi ayarlar. Renk, onaltılık kod dizesi olarak sağlanmalıdır (ör. #00ff00).
• accent_color ikincil rengi ayarlar. Renk, onaltılık kod dizesi olarak sağlanmalıdır (ör. #00ff00).
• Yazı tipini ayarlamak için predefined_font_family simgesini kullanın. Değer, aşağıdaki Google Yazı Tiplerinden biri olmalıdır (büyük/küçük harfe duyarlıdır): Open Sans, Roboto, Montserrat, Poppins, Lato, Oswald, Playfair Display, Roboto Slab.

Önemli: Bir main_color belirtirseniz accent_color de belirtmeniz gerekir. Aksine, bir accent_color belirtirseniz main_color de belirtmeniz gerekir.

Aşağıdaki örnekte, marka kuralları etkinse BUSINESS_NAME ve LOGO öğelerinin nasıl oluşturulacağı ve kampanyaya nasıl ekleneceği, marka kuralları devre dışıysa AssetGroup öğesine nasıl ekleneceği gösterilmektedir. Öğe grupları hakkında daha fazla bilgi için Öğe grubu oluşturma kılavuzu'na bakın.

Java

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

C#

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
      

PHP

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

Python

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
      

Ruby

# 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
      

Perl

# 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
      

Otomatik taşıma

1 Haziran 2025'ten itibaren, tüm öğe gruplarında aynı marka öğelerini (BUSINESS_NAME, LOGO ve LANDSCAPE_LOGO) kullanan Maksimum Performans kampanyaları için marka yönergelerini otomatik olarak etkinleştirmeye başlayacağız. Otomatik olarak taşınabilen tüm kampanyalar 30 Ekim 2025'e kadar taşınacak.

• Otomatik taşıma yalnızca her öğe grubunda tutarlı bir işletme adı ve logo kullanan kampanyalar için gerçekleştirilir. Kampanyanızda bu öğelerde varyasyonlar varsa kampanya otomatik olarak taşınmaz.
• Bir müşteri kimliği altındaki tüm uygun Maksimum Performans kampanyaları aynı anda taşınır.
• Taşıma işleminden sonra, taşınan her kampanyanın CampaignAsset kullanılarak kampanya düzeyinde depolanan kendi marka öğeleri grubu olur.

Bir kampanyanın taşınıp taşınmadığını Campaign.brand_guidelines_enabled alanını kontrol ederek anlayabilirsiniz.

Manuel Taşıma

Otomatik taşıma için uygun olmayan kampanyalarda markalama kurallarının etkinleştirilmesi için manuel taşıma yapılması gerekir.

Campaign.brand_guidelines_enabled Mevcut bir kampanyanın marka kuralları için etkinleştirilip etkinleştirilmediğini gösterir. Mevcut bir kampanyada marka kurallarını manuel olarak etkinleştirmek için brand_guidelines_enabled alanını doğrudan güncellemek yerine CampaignService.EnablePMaxBrandGuidelines simgesini kullanın. Bu alan değiştirilemez. Kampanyayı en iyi performansı gösteren marka öğeleriyle otomatik olarak doldurmak için auto_populate_brand_assets'ı true olarak ayarlayın. Aksi takdirde, işlemdeki öğeleri brand_assets ile manuel olarak sağlamanız gerekir. Bir kampanya için marka yönergelerinin devre dışı bırakılması desteklenmez.

Not: Kampanyalar taşınırken tek bir EnableOperation isteğinde 10 CampaignService.EnablePMaxBrandGuidelines sınırı vardır.