Assets in einer Performance Max-Kampagne

Performance Max-Kampagnen haben einige Besonderheiten im Hinblick auf Assets.

1. Es ist eine Mindestanzahl an Assets verschiedener Typen erforderlich.
2. Assets werden in einer Sammlung namens AssetGroup gruppiert, die nur für Performance Max-Kampagnen verwendet wird.
3. Einige Assets können automatisch mithilfe von maschinellem Lernen erstellt werden.

Wichtig:In unserem interaktiven Leitfaden für Performance Max-Kampagnen erfahren Sie, wie Sie Assets erstellen.

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 finden Sie im Leitfaden zur Umstellung.

Codebeispiel

Im folgenden Code-Snippet wird 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.V19.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, customer_id, texts):
    """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 = client.get_service("GoogleAdsService")

    operations = []
    for text in texts:
        mutate_operation = client.get_type("MutateOperation")
        asset = mutate_operation.asset_operation.create
        asset.text_asset.text = text
        operations.append(mutate_operation)

    # Send the operations in a single Mutate request.
    response = googleads_service.mutate(
        customer_id=customer_id,
        mutate_operations=operations,
    )
    asset_resource_names = []
    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::V19::Services::GoogleAdsService::MutateOperation
      ->new({
        assetOperation =>
          Google::Ads::GoogleAds::V19::Services::AssetService::AssetOperation->
          new({
            create => Google::Ads::GoogleAds::V19::Resources::Asset->new({
                textAsset =>
                  Google::Ads::GoogleAds::V19::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
      

Automatisch erstellte Assets

Bei der Automatisierung von Google mithilfe von maschinellem Lernen werden bei Bedarf zusätzliche Assets generiert, um alle relevanten Kanäle abzudecken. Je nachdem, in welchem Google Ads-Kanal Ihre Anzeige ausgeliefert wird (z. B. auf YouTube, in Gmail oder in der Google Suche), werden die Assets automatisch kombiniert.

Text-Assets

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

Verknüpfen Sie einen Seitenfeed mit einer Kampagne wie bei dynamischen Suchanzeigen:

1. Assets für jede Seite Ihrer Website erstellen
2. Seitenfeed-Assets in einem Asset-Set verpacken
3. Asset-Set mit einer Kampagne verknüpfen

Nachdem Sie einen Seitenfeed verknüpft haben, muss die AssetAutomationSetting vom Typ TEXT_ASSET_AUTOMATION auf OPTED_IN gesetzt sein. Das ist die Standardeinstellung, wenn Sie die AssetAutomationSetting beim Erstellen der Kampagne nicht festgelegt haben.

Wenn Sie diese Einstellung verwenden, werden für die Kampagne eventuell Inhalte Ihrer Landingpage, Ihrer Domain und bereitgestellte Assets verwendet, um Anzeigen anzupassen, wenn eine Leistungssteigerung wahrscheinlich ist. Wir empfehlen, diesen Wert bei OPTED-IN zu belassen.

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

Video-Assets

Wenn Sie der Asset-Gruppe, die Sie für Ihre Performance Max-Kampagne verwenden, keine Videos hinzufügen, können sie aus Assets in der Gruppe generiert werden. Wenn Sie für Ihre Kampagne jedoch kein automatisch generiertes Video verwenden möchten, haben Sie die Möglichkeit, ein benutzerdefiniertes Video hochzuladen. Es wird dann anstelle der automatisch generierten Videos ausgeliefert.

Mithilfe der intelligenten Automatisierung können Sie Ihre YouTube-Video-Assets optimieren, indem Sie die Videoausrichtung anpassen und sie intelligent kürzen, um wichtige Momente hervorzuheben. Wenn du deine ursprünglichen Video-Assets beibehalten möchtest, setze das AssetAutomationSetting des Typs GENERATE_ENHANCED_YOUTUBE_VIDEOS auf OPTED_OUT.