Assets d'une campagne Performance Max

Les campagnes Performance Max présentent certaines caractéristiques uniques concernant les composants.

1. Un nombre minimal de composants de différents types est requis.
2. Les composants sont regroupés dans une collection appelée AssetGroup, qui est propre aux campagnes Performance Max.
3. Certains composants peuvent être générés automatiquement par le machine learning.

Conseil : Si vous passez à des campagnes Performance Max à partir d'autres types de campagnes, vous pouvez réutiliser vos composants existants dans votre compte Google Ads. Pour en savoir plus sur les composants supplémentaires à ajouter, consultez le guide de mise à niveau.

Consignes relatives à la marque : association du nom et du logo de l'entreprise

Bien que la plupart des composants d'une campagne Performance Max soient organisés en groupes de composants, les composants clés représentant l'identité de votre marque (en particulier le nom de l'entreprise et le logo de l'entreprise) sont gérés différemment si les consignes relatives à la marque sont activées pour votre campagne.

Ces composants de consignes relatives à la marque sont associés directement au niveau de la campagne, et non au niveau du groupe de composants. Pour ce faire, utilisez la CampaignAsset ressource. Associez le composant à la campagne en spécifiant le AssetFieldType approprié :

• BUSINESS_NAME pour le composant Nom de l'entreprise (qui est un composant Texte)
• LOGO pour le composant Logo de l'entreprise (qui est un composant Image)

Cette association au niveau de la campagne garantit une représentation cohérente de la marque dans tous les groupes de composants de la campagne Performance Max.

Exemple de code

L'extrait de code suivant illustre la création des composants répétés nécessaires dans une nouvelle requête :

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

Remarque : Bien qu'aucun exemple de code REST direct ne soit fourni pour cette étape, vous pouvez y parvenir à l'aide d'une requête REST manuelle.

Consultez la documentation de l'interface REST de l'API Google Ads et les pages de référence spécifiques à la méthode. Vous devrez créer la charge utile JSON en fonction des définitions proto.

Key Resources Ressources clés

• Utiliser REST
• Structure de l'interface REST
• Mappages des champs JSON
• Consultez la documentation de référence de l'API REST pour le service et la méthode spécifiques.

Composants créés automatiquement

L'automatisation de Google à l'aide du machine learning génère des composants supplémentaires si nécessaire pour couvrir tous les canaux pertinents. Les composants sont automatiquement combinés et mis en correspondance en fonction du canal Google Ads (YouTube, Gmail ou Réseau de Recherche, par exemple) sur lequel votre annonce est diffusée. Pour en savoir plus sur la gestion de ces paramètres, consultez le guide sur les paramètres d'automatisation des composants.

Composants Texte

Vous pouvez associer un flux de pages dans votre compte à une campagne Performance Max pour générer automatiquement des composants.

Pour associer un flux de pages à une campagne, suivez la même procédure que pour les annonces dynamiques du Réseau de Recherche :

1. Créez des composants pour chaque page de votre site Web.
2. Regroupez les composants du flux de pages dans un AssetSet.
3. Associez l'AssetSet à une campagne.

Une fois que vous avez associé un flux de pages, assurez-vous que le AssetAutomationSetting de type TEXT_ASSET_AUTOMATION est défini sur OPTED_IN.

Il s'agit du paramètre par défaut si vous n'avez pas défini le AssetAutomationSetting lors de la création de la campagne.

Grâce à ce paramètre, votre campagne pourra utiliser le contenu de votre page de destination, de votre domaine et des composants que vous avez fournis pour personnaliser vos annonces, si cela est susceptible d'améliorer vos performances. Nous vous recommandons de laisser ce paramètre sur OPTED-IN.

Point important : Pour que cette fonctionnalité fonctionne, le CampaignAssetSet pour AssetSet de type PAGE_FEED et TEXT_ASSET_AUTOMATION doivent être définis sur OPTED_IN (ou aucun AssetAutomationSetting ne doit être défini pour TEXT_ASSET_AUTOMATION). Si vous souhaitez définir TEXT_ASSET_AUTOMATION sur OPTED_OUT, vous devez d'abord supprimer le CampaignAssetSet avant de modifier le AssetAutomationSetting. Il en va de même dans l'autre sens : vous devez activer TEXT_ASSET_AUTOMATION avant de créer un CampaignAssetSet. Si vous essayez de définir l'un de ces éléments sans l'autre une erreur OPERATION_NOT_PERMITTED_FOR_CONTEXT se produit.

Consignes de rédaction

Les consignes de rédaction vous permettent d'affiner les messages de la marque pour les composants Texte générés automatiquement en spécifiant des exclusions de termes et des restrictions relatives aux messages.

Pour utiliser les consignes de rédaction, renseignez le text_guidelines champ de la Campaign ressource :

• Exclusions de termes : fournissez une liste de mots ou expressions exacts à exclure des composants Texte générés. Chaque exclusion peut comporter jusqu'à 30 caractères, avec un maximum de 25 exclusions.
• Restrictions relatives aux messages : fournissez des instructions de forme libre (jusqu'à 300 caractères chacune) pour guider la génération de texte par l'IA. Vous pouvez fournir jusqu'à 40 restrictions. Seul RESTRICTION_BASED_EXCLUSION est compatible avec le type de restriction.

Composants Vidéo

Si vous n'ajoutez pas de vidéo à votre groupe de composants Performance Max, un ou plusieurs composants vidéo peuvent être générés à partir des composants du groupe. Si vous ne souhaitez plus que votre campagne Performance Max diffuse des vidéos générées automatiquement, vous pouvez importer votre propre vidéo personnalisée. Les vidéos générées automatiquement cesseront alors d'apparaître.

L'automatisation intelligente peut améliorer vos composants vidéo YouTube en ajustant l'orientation de la vidéo et en la raccourcissant de manière intelligente pour mettre en évidence les moments clés. Si vous préférez conserver vos composants vidéo d'origine, définissez le AssetAutomationSetting de type GENERATE_ENHANCED_YOUTUBE_VIDEOS sur OPTED_OUT.