Asset in una campagna Performance Max

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

• I gruppi di asset devono soddisfare i requisiti minimi degli asset per tutti i tipi di asset, ad eccezione delle campagne per la vendita al dettaglio e di Servizi locali.
• Gli asset sono raggruppati in un AssetGroup, che è esclusivo delle campagne Performance Max.
• Il machine learning può generare automaticamente asset aggiuntivi.

Suggerimento: se esegui l'upgrade alle campagne Performance Max da altri tipi di campagne, 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 in 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 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. Per farlo, utilizza la risorsa CampaignAsset. Collega l'asset alla campagna, specificando il valore AssetFieldType appropriato:

• BUSINESS_NAME per l'asset Nome dell'attività (che è un asset di testo).
• LOGO per l'asset del 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.

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.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;
}
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::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;
}
add_performance_max_campaign.pl
      

curl

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

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

Risorse principali:

• 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 la Ricerca) su cui viene pubblicato l'annuncio. Per maggiori 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 i tuoi annunci. Puoi migliorare 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, utilizza la stessa procedura degli annunci dinamici della rete di ricerca:

1. Crea asset per ogni pagina del tuo sito web
2. Crea un pacchetto di 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 questo valore su OPTED_IN.

Punto chiave: affinché questa funzionalità funzioni, devono essere presenti contemporaneamente CampaignAssetSet per AssetSet di tipo PAGE_FEED e TEXT_ASSET_AUTOMATION impostato su OPTED_IN (o nessun AssetAutomationSetting impostato per TEXT_ASSET_AUTOMATION). Se vuoi impostare TEXT_ASSET_AUTOMATION su OPTED_OUT, devi prima rimuovere CampaignAssetSet prima di modificare AssetAutomationSetting. Lo stesso vale per il contrario: devi attivare TEXT_ASSET_AUTOMATION prima di creare un CampaignAssetSet. Il tentativo di impostare uno di questi valori senza l'altro genera 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 risorsa Campaign:

• 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 con l'AI. Puoi fornire fino a 40 limitazioni. Per il tipo di limitazione è supportato solo RESTRICTION_BASED_EXCLUSION.

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ù pubblicare video generati automaticamente nella tua campagna Performance Max, puoi caricare un video personalizzato e i video generati automaticamente non verranno più pubblicati.

Attenzione: in una campagna per la vendita al dettaglio Performance Max il cui gruppo di asset non contiene asset personalizzati, non collegare un asset YOUTUBE_VIDEO personalizzato senza collegare anche tutti gli asset di testo, immagine e brand minimi richiesti nella stessa richiesta. Il collegamento di soli asset personalizzati facoltativi lascia il gruppo di asset in uno stato non supportato che blocca le modifiche nell'interfaccia utente di Google Ads.

L'automazione intelligente può migliorare gli asset video di YouTube regolando l'orientamento dei video e accorciandoli in modo intelligente per evidenziare 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 tua pagina di destinazione, il tuo canale YouTube e i canali social organici collegati alla tua pagina di destinazione (video da fonti approvate). Questa funzionalità facoltativa è disattivata per impostazione predefinita. Per attivare questa 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 maggiori dettagli, consulta la guida alle impostazioni di automazione degli asset.