Aset dalam Kampanye Performa Maksimal

Kampanye Performa Maksimal memiliki beberapa karakteristik unik terkait aset.

  1. Jumlah aset yang diperlukan dari jenis yang berbeda sangat sedikit.
  2. Aset dikelompokkan bersama dalam koleksi yang disebut AssetGroup, yang unik untuk kampanye Performa Maksimal.
  3. Aset dibuat secara otomatis oleh machine learning.

Memastikan persyaratan aset minimum terpenuhi

Setiap kampanye Performa Maksimal memerlukan sekumpulan aset awal minimum. Ini mungkin adalah aset yang ada yang digunakan di kampanye lain atau aset baru yang khusus untuk kampanye Performa Maksimal.

Jenis aset Jenis kolom Spesifikasi Min Maks
TEXT JUDUL Maksimal 30 karakter; sertakan minimal satu karakter dengan 15 karakter atau kurang. 3 5
PANJANG_PANJANG Maksimal 90 karakter 1 5
DESKRIPSI Maksimal 90 karakter; sertakan minimal satu karakter dengan 60 karakter atau kurang. 2 5
BUSINESS_NAME Maks. 25 karakter 1 1
IMAGE PASAR_GAMBAR Lanskap (1,91:1) direkomendasikan 1200x628; 600x314 mnt; ukuran file maks 5120 KB 1 20
analisis (1:1) 1200x1200 disarankan; 300 x 300 mnt; ukuran file maks 5120 KB 1 20
GAMBAR_PENARIT_portIF (4:5) 960 x 1200 direkomendasikan; 480 x 600 mnt 0 20
LOGO (1:1) direkomendasikan 1200x1200; 128x128 mnt; ukuran file maks 5120 KB 1 5
Logo LANDSCAPE (4:1) direkomendasikan 1200x300; 512x128 mnt; ukuran file maks 5120 KB 0 5
YOUTUBE_VIDEO YOUTUBE_VIDEO horizontal, vertikal, atau persegi, >=10 detik 0 5
TELEPON_KE_TINDAKAN TELEPON_KE_TINDAKAN_PILIH Otomatis secara default, atau pilih dari daftar 0 1
KUNCI MEDIA KUNCI MEDIA < 150 KB 0 1

Aset berulang (HEADLINE, DESCRIPTION) harus dibuat dalam permintaan terpisah sebelum membuat kampanye.

Cuplikan kode berikut mengilustrasikan pembuatan aset berulang yang diperlukan dalam permintaan baru:

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.V11.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($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, customer_id, texts):
    """Creates multiple text assets and returns the list of resource names.

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

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

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

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

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

Grup aset

Setiap kampanye memerlukan setidaknya satu grup aset. Aset secara otomatis digabungkan dan dicocokkan berdasarkan saluran Google Ads (YouTube, Gmail, Penelusuran, dll.) yang digunakan untuk menayangkan iklan Anda.

Aset yang dibuat otomatis

Otomatisasi Google yang menggunakan machine learning menghasilkan aset tambahan yang diperlukan untuk mencakup semua saluran yang relevan.

Jika Anda tidak menambahkan video ke grup aset Performa Maksimal, satu atau beberapa aset video mungkin akan dibuat dari aset dalam grup aset Anda. Jika tidak ingin lagi menayangkan video yang dibuat secara otomatis di kampanye Performa Maksimal, Anda dapat mengupload video kustom Anda sendiri, dan video yang dibuat secara otomatis akan berhenti ditayangkan.