Assets in einer Performance Max-Kampagne

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

• Asset-Gruppen müssen die Mindestanforderungen für Assets für alle Asset-Typen erfüllen. Ausnahmen gelten für Einzelhandels- und Lokale Dienstleistungen-Kampagnen.
• Assets werden in einer AssetGroup gruppiert, die nur in Performance Max-Kampagnen verwendet wird.
• Mithilfe von maschinellem Lernen können automatisch zusätzliche Assets generiert werden.

Tipp: Wenn Sie von anderen Kampagnentypen auf Performance Max-Kampagnen umstellen, 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 Name und Logo des Unternehmens

Die meisten Assets in einer Performance Max-Kampagne sind in Asset-Gruppen organisiert. Wichtige Assets, die die Identität Ihrer Marke repräsentieren, insbesondere Name des Unternehmens und Firmenlogo, 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 dabei den entsprechenden AssetFieldType an:

• BUSINESS_NAME für das Asset mit dem 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, wie die erforderlichen wiederholten Assets in einer neuen Anfrage erstellt werden:

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

Hinweis: Für diesen Schritt wird hier kein direktes REST-Codebeispiel bereitgestellt. Sie können dies jedoch mit einer manuellen REST-Anfrage erreichen.

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

Wichtige Ressourcen:

• REST verwenden
• Struktur der REST-Schnittstelle
• JSON-Feldzuordnungen
• Informationen zum jeweiligen Dienst und zur Methode finden Sie in der REST API-Referenz.

Asset-Automatisierung

Mithilfe von maschinellem Lernen werden bei der Google-Automatisierung nach Bedarf zusätzliche Assets generiert, um alle relevanten Kanäle abzudecken. Je nachdem, in welchem Google Ads-Kanal Ihre Google 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 den 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 Paketseiten in ein AssetSet packen
3. AssetSet 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 beim Erstellen der Kampagne nicht AssetAutomationSetting festgelegt haben.

Wenn Sie diese Einstellung verwenden, kann Ihre Kampagne Inhalte Ihrer Landingpage, Ihrer Domain und bereitgestellte Assets verwenden, um interessenspezifische Anzeigen anzupassen, wenn eine Leistungssteigerung wahrscheinlich ist. Wir empfehlen, diesen Wert auf OPTED_IN zu belassen.

Wichtiger Hinweis: Damit dieses Feature funktioniert, müssen sowohl CampaignAssetSet für AssetSet vom Typ PAGE_FEED als auch TEXT_ASSET_AUTOMATION auf OPTED_IN festgelegt sein (oder kein AssetAutomationSetting für TEXT_ASSET_AUTOMATION festgelegt sein). Wenn Sie TEXT_ASSET_AUTOMATION auf OPTED_OUT setzen möchten, müssen Sie zuerst CampaignAssetSet entfernen, bevor Sie AssetAutomationSetting ändern. Das Gleiche gilt umgekehrt: Sie müssen TEXT_ASSET_AUTOMATION aktivieren, bevor Sie eine CampaignAssetSet erstellen. Wenn Sie versuchen, einen dieser Werte 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 die Markenbotschaft 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:

• Auszuschließende Begriffe: Geben Sie eine Liste mit genauen Wörtern oder Wortgruppen an, die aus generierten Text-Assets ausgeschlossen werden sollen. Jeder Ausschluss darf maximal 30 Zeichen lang sein. Es sind maximal 25 Ausschlüsse zulässig.
• Einschränkungen für Werbetexte: Geben Sie Anweisungen im Freiformat (jeweils bis zu 300 Zeichen) ein, um die KI-Textgenerierung zu steuern. Sie können bis zu 40 Einschränkungen angeben. Für den Einschränkungstyp wird nur RESTRICTION_BASED_EXCLUSION 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 generierte Videos in Ihrer Performance Max-Kampagne ausgeliefert werden, können Sie ein eigenes Video hochladen. Die automatisch generierten Videos werden dann nicht mehr ausgeliefert.

Achtung: Verknüpfen Sie in einer Performance Max-Kampagne für den Einzelhandel, deren Asset-Gruppe keine benutzerdefinierten Assets enthält, kein benutzerdefiniertes YOUTUBE_VIDEO-Asset, ohne auch alle erforderlichen Text-, Bild- und Marken-Assets in derselben Anfrage zu verknüpfen. Wenn Sie nur optionale benutzerdefinierte Assets verknüpfen, befindet sich die Asset-Gruppe in einem nicht unterstützten Zustand, der Änderungen in der Google Ads-Benutzeroberfläche verhindert.

Mithilfe von intelligenter Automatisierung können Ihre YouTube-Video-Assets optimiert werden. Dabei wird die Ausrichtung des Videos angepasst und es wird auf intelligente Weise gekürzt, um wichtige Momente hervorzuheben. Wenn Sie Ihre ursprünglichen Video-Assets beibehalten möchten, setzen Sie AssetAutomationSetting vom Typ GENERATE_ENHANCED_YOUTUBE_VIDEOS auf OPTED_OUT.

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