Assets in einer Performance Max-Kampagne

Performance Max-Kampagnen haben einige einzigartige Merkmale in Bezug auf Assets.

1. Es ist eine Mindestanzahl von Assets verschiedener Typen erforderlich.
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 von anderen Kampagnentypen auf Performance Max-Kampagnen umsteigen, können Sie Ihre vorhandenen Assets im Google Ads-Konto wiederverwenden. Weitere Informationen zu den zusätzlichen Assets, die Sie hinzufügen müssen, finden Sie im Leitfaden für das Upgrade.

Markenrichtlinien: Verknüpfung von Unternehmensname und ‑logo

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

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

• BUSINESS_NAME für das Asset für den Unternehmensnamen (ein Text-Asset)
• LOGO für das Asset für das Unternehmenslogo (ein Bild-Asset)

Diese Verknüpfung auf Kampagnenebene sorgt für eine einheitliche Darstellung der Marke in allen Asset-Gruppen innerhalb der Performance Max-Kampagne.

Codebeispiel

Das folgende Code-Snippet zeigt, 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.V24.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:Hier wird kein direktes REST-Codebeispiel für diesen Schritt bereitgestellt. Sie können dies jedoch mit einer manuellen REST-Anfrage erreichen.

Weitere Informationen finden Sie in der Dokumentation zur REST-Oberfläche 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-Oberfläche
• JSON-Feldzuordnungen
• Weitere Informationen finden Sie in der REST API-Referenz für den jeweiligen Dienst und die jeweilige Methode.

Automatisch erstellte Assets

Die Google-Automatisierung mit maschinellem Lernen generiert bei Bedarf zusätzliche Assets, um alle relevanten Kanäle abzudecken. Je nachdem, in welchem Kanal auf Google 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 den Asset automatisierungseinstellungen.

Text-Assets

Sie können einen Seitenfeed in Ihrem Konto mit einer Performance Max -Kampagne verknüpfen, um automatisch Assets zu generieren.

Wenn Sie einen Seitenfeed mit einer Kampagne verknüpfen möchten, gehen Sie so vor wie bei dynamischen Suchanzeigen:

1. Erstellen Sie Assets für jede Seite Ihrer Website.
2. Fassen Sie die Assets des Seitenfeeds in einem AssetSet zusammen.
3. Verknüpfen Sie das AssetSet mit einer Kampagne.

Nachdem Sie einen Seitenfeed verknüpft haben, muss die AssetAutomationSetting vom Typ TEXT_ASSET_AUTOMATION auf OPTED_IN gesetzt sein.

Dies ist die Standardeinstellung, wenn Sie beim Erstellen der Kampagne keine AssetAutomationSetting 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.

Wichtig: Sowohl die CampaignAssetSet für AssetSet vom Typ PAGE_FEED als auch TEXT_ASSET_AUTOMATION müssen auf OPTED_IN gesetzt sein (oder es muss keine AssetAutomationSetting für TEXT_ASSET_AUTOMATION festgelegt sein), damit diese Funktion funktioniert. Wenn Sie TEXT_ASSET_AUTOMATION auf OPTED_OUT setzen möchten, müssen Sie zuerst CampaignAssetSet entfernen, bevor Sie die AssetAutomationSetting ändern. Dasselbe gilt umgekehrt: Sie müssen TEXT_ASSET_AUTOMATION aktivieren, bevor Sie ein CampaignAssetSet erstellen. Wenn Sie versuchen, eine dieser Einstellungen ohne die andere festzulegen wird der Fehler OPERATION_NOT_PERMITTED_FOR_CONTEXT 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 angeben.

Wenn Sie Richtlinien für Text verwenden möchten, füllen Sie das text_guidelines Feld der Campaign Ressource 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 Freiform-Anweisungen (jeweils bis zu 300 Zeichen) an, 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 möchten, dass automatisch generierte Videos in Ihrer Performance Max-Kampagne ausgeliefert werden, können Sie ein eigenes benutzerdefiniertes Video hochladen. Die automatisch generierten Videos werden dann nicht mehr ausgeliefert.

Die intelligente Automatisierung kann Ihre YouTube-Video-Assets verbessern, indem sie die Video ausrichtung anpasst und sie intelligent kürzt, um wichtige Momente hervorzuheben. Wenn Sie Ihre ursprünglichen Video-Assets beibehalten möchten, setzen Sie die AssetAutomationSetting vom Typ GENERATE_ENHANCED_YOUTUBE_VIDEOS auf OPTED_OUT.