ชิ้นงานในแคมเปญ Performance Max

แคมเปญ Performance Max มีลักษณะเฉพาะบางอย่างเกี่ยวกับชิ้นงาน

หลักเกณฑ์การใช้แบรนด์: การลิงก์ชื่อและโลโก้ธุรกิจ

แม้ว่าชิ้นงานส่วนใหญ่ในแคมเปญ Performance Max จะจัดระเบียบอยู่ภายในกลุ่มชิ้นงาน แต่ชิ้นงานหลักที่แสดงถึงเอกลักษณ์ของแบรนด์ โดยเฉพาะชื่อธุรกิจและโลโก้ธุรกิจ จะได้รับการจัดการแตกต่างออกไปหากเปิดใช้หลักเกณฑ์การใช้แบรนด์ในแคมเปญ

ชิ้นงานหลักเกณฑ์การใช้แบรนด์เหล่านี้ลิงก์โดยตรงที่ระดับแคมเปญ ไม่ใช่ที่ระดับกลุ่มชิ้นงาน ซึ่งทำได้โดยใช้ทรัพยากร CampaignAsset คุณลิงก์ชิ้นงานกับแคมเปญโดยระบุ AssetFieldType ที่เหมาะสม ดังนี้

  • BUSINESS_NAME สำหรับชิ้นงานชื่อธุรกิจ (ซึ่งเป็นชิ้นงานข้อความ)
  • LOGO สำหรับชิ้นงานโลโก้ธุรกิจ (ซึ่งเป็นชิ้นงานรูปภาพ)

การลิงก์ระดับแคมเปญนี้ช่วยให้มั่นใจได้ว่าการแสดงแบรนด์จะสอดคล้องกันในกลุ่มชิ้นงานทั้งหมดภายในแคมเปญ Performance Max

ตัวอย่างโค้ด

ข้อมูลโค้ดต่อไปนี้แสดงการสร้างชิ้นงานที่ซ้ำกันที่จำเป็นในคำขอใหม่

Java

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

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

C#

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

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

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

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

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

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

    PrintResponseDetails(response);

    return assetResourceNames;
}

PHP

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

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

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

        return $assetResourceNames;
    }

Python

def create_multiple_text_assets(
    client: GoogleAdsClient, customer_id: str, texts: List[str]
) -> List[str]:
    """Creates multiple text assets and returns the list of resource names.

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

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

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

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

Ruby

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

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

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

Perl

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

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

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

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

  return $asset_resource_names;
}

curl

การจัดการชิ้นงานโดยอัตโนมัติ

ระบบอัตโนมัติของ Google ที่ใช้แมชชีนเลิร์นนิงจะสร้างชิ้นงานเพิ่มเติมตามความจำเป็นเพื่อให้ครอบคลุมช่องทางที่เกี่ยวข้องทั้งหมด ระบบจะผสมและจับคู่ชิ้นงานโดยอัตโนมัติตามช่องทางโฆษณาของ Google (เช่น YouTube, Gmail หรือ Search) ที่แสดงโฆษณา ดูรายละเอียดเพิ่มเติมเกี่ยวกับการจัดการการตั้งค่าเหล่านี้ได้ในคู่มือการตั้งค่าการทำงานอัตโนมัติของชิ้นงาน

การปรับแต่งข้อความ

การปรับแต่งข้อความช่วยให้ AI ของ Google สร้างและปรับแต่งชิ้นงานข้อความสำหรับโฆษณาได้โดยอัตโนมัติ คุณสามารถเพิ่มประสิทธิภาพฟีเจอร์นี้ได้โดยเชื่อมโยงการรวม URL (ฟีดหน้าเว็บ) ในบัญชีกับแคมเปญ Performance Max เพื่อสร้างชิ้นงานข้อความที่สร้างขึ้น

หากต้องการลิงก์การรวม URL กับแคมเปญ ให้ใช้กระบวนการเดียวกับที่ใช้สำหรับโฆษณา Search แบบไดนามิก ดังนี้

  1. สร้างชิ้นงานสำหรับแต่ละหน้าของเว็บไซต์
  2. การรวม URL ของหน้าแพ็กเกจไว้ใน AssetSet
  3. เชื่อมโยง AssetSet กับแคมเปญ

หลังจากเชื่อมโยงการรวม URL (ฟีดหน้าเว็บ) แล้ว ให้ตรวจสอบว่าได้ตั้งค่า AssetAutomationSetting ของประเภท TEXT_ASSET_AUTOMATION เป็น OPTED_IN แล้ว

ซึ่งเป็นการตั้งค่าเริ่มต้นหากคุณไม่ได้ตั้งค่า AssetAutomationSetting เมื่อสร้างแคมเปญ

การใช้การตั้งค่านี้หมายความว่าแคมเปญของคุณสามารถใช้เนื้อหาจากหน้า Landing Page, โดเมน และชิ้นงานที่ให้ไว้เพื่อปรับแต่งโฆษณา เมื่อระบบคาดการณ์แล้วว่าจะช่วยปรับปรุงประสิทธิภาพได้ เราขอแนะนำให้คงค่านี้ไว้ที่ OPTED_IN

หลักเกณฑ์เกี่ยวกับข้อความ

หลักเกณฑ์เกี่ยวกับข้อความช่วยให้คุณปรับแต่งข้อความจากแบรนด์สำหรับชิ้นงานข้อความที่สร้างขึ้นโดยอัตโนมัติได้โดยการระบุการยกเว้นคำและข้อจำกัดเกี่ยวกับข้อความ

หากต้องการใช้หลักเกณฑ์เกี่ยวกับข้อความ ให้ป้อนข้อมูลในช่อง text_guidelines ของทรัพยากร Campaign ดังนี้

  • การยกเว้นคำ: ระบุรายการคำหรือวลีที่ตรงกันทั้งหมดที่จะยกเว้นจากชิ้นงานข้อความที่สร้างขึ้น การยกเว้นแต่ละรายการมีความยาวได้สูงสุด 30 อักขระ และยกเว้นได้สูงสุด 25 รายการ
  • ข้อจำกัดเกี่ยวกับข้อความ: ระบุคำสั่งรูปแบบอิสระ (สูงสุด 300 อักขระต่อคำสั่ง) เพื่อเป็นแนวทางในการสร้างข้อความด้วย AI คุณระบุข้อจำกัดได้สูงสุด 40 รายการ รองรับเฉพาะ RESTRICTION_BASED_EXCLUSION สำหรับประเภทข้อจำกัด

ชิ้นงานวิดีโอ

หากคุณไม่เพิ่มวิดีโอลงในกลุ่มชิ้นงาน Performance Max ระบบอาจสร้างชิ้นงานวิดีโออย่างน้อย 1 รายการจากชิ้นงานในกลุ่มชิ้นงาน หากไม่ต้องการให้วิดีโอที่สร้างขึ้นโดยอัตโนมัติแสดงในแคมเปญ Performance Max อีกต่อไป คุณสามารถอัปโหลดวิดีโอที่กำหนดเอง แล้ววิดีโอที่สร้างขึ้นโดยอัตโนมัติจะหยุดแสดง

การทำงานอัตโนมัติอันชาญฉลาดอาจปรับปรุงชิ้นงานวิดีโอ YouTube โดยการปรับการวางแนววิดีโอและตัดให้สั้นลงอย่างชาญฉลาดเพื่อไฮไลต์ช่วงสำคัญ หากต้องการคงชิ้นงานวิดีโอเดิมไว้ ให้ตั้งค่า AssetAutomationSetting ประเภท GENERATE_ENHANCED_YOUTUBE_VIDEOS เป็น OPTED_OUT

นอกจากนี้ Google ยังค้นหาและใช้วิดีโอที่เกี่ยวข้องจากแหล่งที่มาที่ได้รับอนุมัติ เช่น หน้า Landing Page, ช่อง YouTube และช่องทางโซเชียลแบบทั่วไปที่ลิงก์ในหน้า Landing Page (วิดีโอที่ AI จัดหามา) ได้ด้วย ฟีเจอร์เสริมนี้จะปิดใช้อยู่โดยค่าเริ่มต้น หากต้องการเลือกใช้ ให้ตั้งค่า AssetAutomationSetting ของประเภท AUTOMATED_VIDEO_CRAWL เป็น OPTED_IN และกำหนดค่า automated_video_crawl_setting ด้วย URL แหล่งที่มาและแพลตฟอร์มที่ได้รับอนุมัติ ดูรายละเอียดได้จากคู่มือการตั้งค่าการทำงานอัตโนมัติของชิ้นงาน

ก่อนหน้า
พารามิเตอร์ ValueTrack
ถัดไป
ข้อกำหนดด้านชิ้นงาน