Asset in una campagna Performance Max

Le campagne Performance Max hanno alcune caratteristiche uniche per quanto riguarda gli asset.

  1. È richiesto un numero minimo di asset di diversi tipi.
  2. Gli asset sono raggruppati in una raccolta chiamata AssetGroup, che è unica per le campagne Performance Max.
  3. Alcuni asset possono essere generati automaticamente dal machine learning.

Linee guida per il brand: collegamento del nome e del logo dell'attività

Mentre la maggior parte degli asset di una campagna Performance Max è organizzata all'interno dei gruppi di asset, gli asset chiave che rappresentano l'identità del tuo brand, in particolare il nome dell'attività e il logo dell'attività, vengono gestiti in modo diverso se le linee guida per il brand sono attive per la tua campagna.

Questi asset delle linee guida per il brand sono collegati direttamente a livello di campagna, non a livello di gruppo di asset. Questa operazione viene eseguita utilizzando la risorsa CampaignAsset. Collega l'asset alla campagna specificando il AssetFieldType appropriato:

*   `BUSINESS_NAME` for the Business Name asset (which is a Text Asset).
*   `LOGO` for the Business Logo asset (which is an Image Asset).

Questo collegamento a livello di campagna garantisce una rappresentazione coerente del brand in tutti i gruppi di asset all'interno della campagna Performance Max.

Codice di esempio

Il seguente snippet di codice illustra la creazione degli asset ripetuti necessari in una nuova richiesta:

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;
}

AddPerformanceMaxCampaign.java

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.V22.GoogleAdsService);

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

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

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

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

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

    PrintResponseDetails(response);

    return assetResourceNames;
}

AddPerformanceMaxCampaign.cs

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;
}
AddPerformanceMaxCampaign.php

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
add_performance_max_campaign.py

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
add_performance_max_campaign.rb

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

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

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

  return $asset_resource_names;
}
add_performance_max_campaign.pl

Asset creati automaticamente

L'automazione di Google che utilizza il machine learning genera asset aggiuntivi in base alle necessità per coprire tutti i canali pertinenti. Gli asset vengono combinati e abbinati automaticamente in base al canale pubblicitario di Google (ad esempio YouTube, Gmail o la Ricerca) su cui viene pubblicato l'annuncio. Per ulteriori dettagli sulla gestione di queste impostazioni, consulta la guida alle impostazioni di automazione degli asset.

Asset di testo

Puoi associare un feed di pagine nel tuo account a una campagna Performance Max per generare automaticamente asset.

Per collegare un feed di pagine a una campagna, utilizza la stessa procedura usata per gli annunci dinamici della rete di ricerca:

  1. Creare asset per ogni pagina del sito web
  2. Raggruppare gli asset dei feed di pagine in un AssetSet
  3. Associare l'AssetSet a una campagna

Dopo aver associato un feed di pagine, assicurati che AssetAutomationSetting di tipo TEXT_ASSET_AUTOMATION sia impostato su OPTED_IN. Questa è l'impostazione predefinita se non hai impostato AssetAutomationSetting durante la creazione della campagna.

Se utilizzi questa impostazione, la tua campagna può utilizzare i contenuti della pagina di destinazione, del dominio e degli asset forniti per personalizzare gli annunci quando si prevede che possano migliorare il rendimento. Ti consigliamo di lasciare questo valore su OPTED-IN.

.

Asset video

Se non aggiungi un video al gruppo di asset Performance Max, potrebbero essere generati uno o più asset video a partire dagli asset presenti nel gruppo. Se non vuoi più che i video generati automaticamente vengano pubblicati nella campagna Performance Max, puoi caricare il tuo video personalizzato e la pubblicazione dei video generati automaticamente verrà interrotta.

L'automazione intelligente può migliorare le risorse video di YouTube regolando l'orientamento del video e accorciandolo in modo intelligente per mettere in evidenza i momenti chiave. Se preferisci mantenere gli asset video originali, imposta AssetAutomationSetting del tipo GENERATE_ENHANCED_YOUTUBE_VIDEOS su OPTED_OUT.

Indietro
Parametri ValueTrack
Avanti
Requisiti per gli asset