Assets in einer Performance Max-Kampagne

Performance Max-Kampagnen haben einige Besonderheiten in Bezug auf Assets.

1. Es gibt eine Mindestanzahl an Assets verschiedener Typen.
2. Assets werden in einer Sammlung namens AssetGroup zusammengefasst, die es nur in Performance Max-Kampagnen gibt.
3. Einige Assets können automatisch durch maschinelles Lernen generiert werden.

Tipp :Wenn Sie ein Upgrade von anderen Kampagnentypen auf Performance Max-Kampagnen durchführen, können Sie Ihre vorhandenen Assets im Google Ads-Konto wiederverwenden. Weitere Informationen zu den zusätzlichen Assets, die hinzugefügt werden müssen, finden Sie im Upgrade-Leitfaden.

Markenrichtlinien: Verknüpfung von Unternehmensname und ‑logo

Die meisten Assets in einer Performance Max-Kampagne werden in Asset-Gruppen organisiert. Wichtige Assets, die die Identität Ihrer Marke repräsentieren, insbesondere Name des Unternehmens und Logo des Unternehmens, werden jedoch anders behandelt, wenn Markenrichtlinien für Ihre Kampagne aktiviert sind.

Diese Assets für Markenrichtlinien sind direkt auf Kampagnenebene verknüpft, nicht auf Asset-Gruppenebene. Dazu wird die Ressource CampaignAsset verwendet. Sie verknüpfen das Asset mit der Kampagne und geben die entsprechende AssetFieldType an:

• BUSINESS_NAME für das Asset für den Namen des Unternehmens (ein Text-Asset).
• LOGO für das Asset „Firmenlogo“ (ein Bild-Asset).

Durch diese Verknüpfung auf Kampagnenebene wird eine einheitliche Markendarstellung in allen Asset-Gruppen der Performance Max-Kampagne gewährleistet.

Codebeispiel

Das folgende Code-Snippet veranschaulicht das Erstellen der erforderlichen wiederholten Assets in einer neuen Anfrage:

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

Hinweis:Für diesen Schritt ist kein direktes REST-Codebeispiel verfügbar. Sie können ihn jedoch mit einer manuellen REST-Anfrage ausführen.

Weitere Informationen finden Sie in der Dokumentation zur Google Ads API-REST-Schnittstelle und auf den methodenspezifischen Referenzseiten. Sie müssen die JSON-Nutzlast anhand der Proto-Definitionen erstellen.

Wichtige Ressourcen:

• REST verwenden
• REST-Schnittstellenstruktur
• JSON-Feldzuordnungen
• Weitere Informationen finden Sie in der REST API-Referenz für den jeweiligen Dienst und die jeweilige Methode.

Asset-Automatisierung

Bei der Automatisierung durch Google werden mithilfe von maschinellem Lernen nach Bedarf zusätzliche Assets generiert, um alle relevanten Kanäle abzudecken. Je nachdem, in welchem Google-Werbekanal Ihre Anzeige ausgeliefert wird (z. B. auf YouTube, in Gmail oder in der Google Suche), werden die Assets automatisch zusammengestellt und kombiniert. Weitere Informationen zum Verwalten dieser Einstellungen finden Sie im Leitfaden zu Einstellungen für die Asset-Automatisierung.

Textanpassung

Mit der Textanpassung kann Google AI automatisch Text-Assets für Ihre Anzeigen erstellen und anpassen. Sie können diese Funktion erweitern, indem Sie URL-Einschlüsse (Seitenfeeds) in Ihrem Konto mit einer Performance Max-Kampagne verknüpfen, um Text-Assets zu generieren.

Wenn Sie URL-Einschlüsse mit einer Kampagne verknüpfen möchten, gehen Sie genauso vor wie bei dynamischen Suchanzeigen:

1. Assets für jede Seite Ihrer Website erstellen
2. URL-Einschlüsse für die Paketseite in ein AssetSet einfügen
3. Asset-Gruppe mit einer Kampagne verknüpfen

Nachdem Sie URL-Einschlüsse (einen Seitenfeed) verknüpft haben, muss der AssetAutomationSetting vom Typ TEXT_ASSET_AUTOMATION auf OPTED_IN festgelegt sein.

Dies ist die Standardeinstellung, wenn Sie AssetAutomationSetting beim Erstellen der Kampagne nicht festgelegt haben.

Wenn Sie diese Einstellung verwenden, können für die Kampagne Inhalte Ihrer Landingpage, Ihrer Domain und bereitgestellte Assets verwendet werden, um Anzeigen anzupassen, wenn eine Leistungssteigerung wahrscheinlich ist. Wir empfehlen, diese Einstellung auf OPTED_IN zu belassen.

Wichtiger Hinweis :Sowohl die CampaignAssetSet für AssetSet vom Typ PAGE_FEED als auch TEXT_ASSET_AUTOMATION, die auf OPTED_IN festgelegt ist (oder keine AssetAutomationSetting für TEXT_ASSET_AUTOMATION festgelegt ist), müssen vorhanden sein, damit diese Funktion funktioniert. Wenn Sie TEXT_ASSET_AUTOMATION auf OPTED_OUT festlegen möchten, müssen Sie zuerst CampaignAssetSet entfernen, bevor Sie AssetAutomationSetting ändern. Das gilt auch umgekehrt: Sie müssen TEXT_ASSET_AUTOMATION aktivieren, bevor Sie eine CampaignAssetSet erstellen können. Wenn Sie versuchen, einen dieser Werte festzulegen, ohne den anderen festzulegen, wird ein OPERATION_NOT_PERMITTED_FOR_CONTEXT-Fehler ausgegeben.

Richtlinien für Text

Mit Richtlinien für Text können Sie Markenbotschaften für automatisch generierte Text-Assets optimieren, indem Sie Begriffsausschlüsse und Einschränkungen für Werbetexte festlegen.

Wenn Sie Richtlinien für Text verwenden möchten, füllen Sie das Feld text_guidelines der Ressource Campaign aus:

• Begriffsausschlüsse: Geben Sie eine Liste mit genauen Wörtern oder Wortgruppen an, die aus generierten Text-Assets ausgeschlossen werden sollen. Jeder Ausschluss kann bis zu 30 Zeichen lang sein. Es sind maximal 25 Ausschlüsse möglich.
• Einschränkungen für Werbetexte: Geben Sie Freiformanweisungen (bis zu 300 Zeichen) an, um die KI-Textgenerierung zu steuern. Sie können bis zu 40 Einschränkungen angeben. Nur RESTRICTION_BASED_EXCLUSION wird für den Einschränkungstyp unterstützt.

Video-Assets

Wenn Sie der Asset-Gruppe, die Sie für Ihre Performance Max-Kampagne verwenden, keine Videos hinzufügen, können sie automatisch aus Assets in der Gruppe erstellt werden. Wenn Sie nicht mehr möchten, dass automatisch erstellte Videos in Ihrer Performance Max-Kampagne ausgeliefert werden, können Sie ein eigenes benutzerdefiniertes Video hochladen. Die automatisch erstellten Videos werden dann nicht mehr ausgeliefert.

Mit intelligenter Automatisierung lassen sich YouTube-Video-Assets optimieren. Dazu wird die Ausrichtung von Videos angepasst und sie werden intelligent gekürzt, um wichtige Momente hervorzuheben. Wenn Sie Ihre ursprünglichen Video-Assets beibehalten möchten, legen Sie die AssetAutomationSetting vom Typ GENERATE_ENHANCED_YOUTUBE_VIDEOS auf OPTED_OUT fest.

Google kann auch relevante Videos aus genehmigten Quellen wie Ihrer Landingpage, Ihrem YouTube-Kanal und organischen Social-Media-Kanälen, die auf Ihrer Landingpage verlinkt sind, finden und verwenden (Videos aus Bezugsquellen). Diese optionale Funktion ist standardmäßig deaktiviert. Wenn Sie die Funktion aktivieren möchten, legen Sie AssetAutomationSetting vom Typ AUTOMATED_VIDEO_CRAWL auf OPTED_IN fest und konfigurieren Sie automated_video_crawl_setting mit Ihren genehmigten Quell-URLs und Plattformen. Weitere Informationen finden Sie in der Anleitung für die Einstellungen zur Asset-Automatisierung.