Asset in una campagna Performance Max

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

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

Suggerimento: se esegui l'upgrade ad altre campagne Performance Max, puoi riutilizzare gli asset esistenti nell'account Google Ads. Per informazioni dettagliate sugli asset aggiuntivi da aggiungere, consulta la guida all'upgrade.

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

Sebbene la maggior parte degli asset di una campagna Performance Max sia organizzata all'interno di gruppi di asset , gli asset chiave che rappresentano l'identità del tuo brand, in particolare nome dell'attività e logo dell'attività, vengono gestiti in modo diverso se le linee guida per il brand sono attivate per la 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 valore appropriato AssetFieldType:

• BUSINESS_NAME per l'asset Nome dell'attività (che è un asset di testo).
• LOGO per l'asset Logo dell'attività (che è un asset immagine).

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

Esempio di codice

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

curl

Nota:anche se qui non viene fornito un esempio di codice REST diretto per questo passaggio, puoi ottenerlo utilizzando una richiesta REST manuale.

Consulta la documentazione dell'interfaccia REST dell'API Google Ads e le pagine di riferimento specifiche per il metodo. Dovrai creare il payload JSON in base alle definizioni proto.

Risorse chiave:

• Utilizzo di REST
• Struttura dell'interfaccia REST
• Mappature dei campi JSON
• Consulta il Riferimento API REST per il servizio e il metodo specifici.

Automazione asset

L'automazione di Google che utilizza il machine learning genera asset aggiuntivi in base alle esigenze 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 Ricerca) su cui viene pubblicato l'annuncio. Per ulteriori dettagli sulla gestione di queste impostazioni, consulta la guida alle impostazioni di automazione degli asset.

Personalizzazione del testo

La personalizzazione del testo consente a Google AI di creare e personalizzare automaticamente gli asset di testo per gli annunci. Puoi ampliare questa funzionalità associando le inclusioni di URL (feed di pagine) nel tuo account a una campagna Performance Max per generare asset di testo.

Per collegare le inclusioni di URL a una campagna, segui la stessa procedura utilizzata per gli annunci dinamici della rete di ricerca:

1. Crea asset per ogni pagina del tuo sito web
2. Raggruppa le inclusioni di URL delle pagine in un AssetSet
3. Associa l'AssetSet a una campagna

Dopo aver associato le inclusioni di URL (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 questa impostazione su OPTED_IN.

Punto chiave: Sia CampaignAssetSet per AssetSet di tipo PAGE_FEED e TEXT_ASSET_AUTOMATION impostato su OPTED_IN (o nessun AssetAutomationSetting impostato per TEXT_ASSET_AUTOMATION) devono essere presenti insieme per il funzionamento di questa funzionalità. Se vuoi impostare TEXT_ASSET_AUTOMATION su OPTED_OUT, devi prima rimuovere CampaignAssetSet prima di modificare AssetAutomationSetting. Lo stesso vale al contrario: devi attivare TEXT_ASSET_AUTOMATION prima di creare un CampaignAssetSet. Se tenti di impostare uno di questi senza l'altro viene visualizzato un errore OPERATION_NOT_PERMITTED_FOR_CONTEXT.

Linee guida per il testo

Le linee guida per il testo ti consentono di perfezionare i messaggi del brand per gli asset di testo generati automaticamente specificando le esclusioni di termini e le limitazioni dei messaggi.

Per utilizzare le linee guida per il testo, compila il campo text_guidelines della Campaign risorsa:

• Esclusioni di termini: fornisci un elenco di parole o frasi esatte da escludere dagli asset di testo generati. Ogni esclusione può contenere fino a 30 caratteri, con un massimo di 25 esclusioni.
• Limitazioni dei messaggi: fornisci istruzioni in formato libero (fino a 300 caratteri ciascuna) per guidare la generazione di testo AI. Puoi fornire fino a 40 limitazioni. È supportato solo RESTRICTION_BASED_EXCLUSIONper il tipo di limitazione.

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 tua campagna Performance Max, puoi caricare il tuo video personalizzato e la pubblicazione dei video generati automaticamente verrà interrotta.

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

Google può anche trovare e utilizzare video pertinenti da fonti approvate, come la pagina di destinazione, il canale YouTube e i canali social organici collegati alla pagina di destinazione (video di origine). Questa funzionalità facoltativa è disattivata per impostazione predefinita. Per attivare la funzionalità, imposta AssetAutomationSetting di tipo AUTOMATED_VIDEO_CRAWL su OPTED_IN e configura automated_video_crawl_setting con gli URL e le piattaforme di origine approvati. Per ulteriori dettagli, consulta la guida alle impostazioni di automazione degli asset.