Performance Max-Kampagne für Onlineverkäufe mit einem Produktfeed (Einzelhandel)

Performance Max-Kampagnen für den Einzelhandel helfen Ihnen, Ihre Reichweite und Ihre Zielvorhaben zu erweitern, da Sie Anzeigen auf zusätzlichem Inventar schalten können.

Möglicherweise müssen Sie neue Assets wie Text, Bilder oder Videos erstellen, damit Anzeigen in neuen Formaten und auf neuen Plattformen ausgeliefert werden können, z. B. als Textanzeigen, in Discover, als In-Stream-Anzeigen auf YouTube und im Displaynetzwerk.

Wenn Sie wissen, bei welchen Nutzersegmenten die Wahrscheinlichkeit einer Conversion besonders hoch ist, können Sie das jetzt mithilfe von Zielgruppensignalen bei Google angeben.

Performance Max-Kampagnen bieten im Vergleich zu Standard-Shopping-Kampagnen noch weitere Vorteile:

• Sprach-Targeting basierend auf dem Merchant Center-Feed oder Kampagnenkriterien
• Erweiterung der finalen URL
• Alle Geschäfte werden als Zielvorhaben festgelegt, wenn das Ziel „Ladenbesuche“ ausgewählt ist.
• Conversion-Zielvorhaben können pro Kunde oder pro Kampagne festgelegt werden.

Merchant Center-Konto mit Google Ads-Konto verknüpfen

Wenn Sie Performance Max-Kampagnen für den Einzelhandel verwenden möchten, muss das Google Ads-Konto mit einem vorhandenen Merchant Center-Konto verknüpft sein. Durch die Verknüpfung mit dem Merchant Center können Assets automatisch für die Kampagne generiert werden. Reichweite und Leistung sind dann jedoch begrenzt.

Asset-Gruppen hinzufügen

Wenn Sie eine Asset-Gruppe hinzufügen, werden Shopping- und dynamische Remarketing Kanäle aktiviert. Wenn Sie die URL-Erweiterung festlegen, werden dynamische Suchanzeigen aktiviert. Je mehr Assets Sie zur Verfügung stellen, desto mehr Anzeigenformate können im System erstellt werden, um zusätzliches Inventar zu nutzen.

Wir empfehlen, jede Asset-Gruppe auf unterschiedliche Produkte auszurichten. Beachten Sie, dass es Beschränkungen für Eintrags gruppen gibt. Als Best Practice sollten Sie nur eine bestimmte Gruppe von Produkten aus einer Asset-Gruppe auswählen. Zum Beispiel könnten die Produkte A–L in Asset-Gruppe 1 und die Produkte M–Z in Asset-Gruppe 2 enthalten sein.

Wenn Sie die Botschaft Ihrer Assets an die Zielgruppe anpassen möchten, können Sie mehrere Asset-Gruppen pro Kampagne erstellen. So können Sie verschiedene Asset-Gruppen für dieselbe finale URL erstellen.

Weitere Optimierungs tipps finden Sie unter Performance Max-Kampagnen einrichten.

Performance Max-Kampagne für den Einzelhandel erstellen

**Wichtiger Hinweis** :Sie müssen auch mindestens eine Eintrags gruppe erstellen.

Legen Sie wie bei anderen Shopping-Kampagnen die Felder ShoppingSetting der Kampagne fest.

Erforderlich

merchant_id

Die Merchant Center-ID des Kontos, das die zu bewerbenden Produkte enthält.

Optional

feed_label

Eine String für das Feedlabel, wie im Merchant Center definiert. Dieses Feld sollte verwendet werden, wenn Sie Produkte aus einem bestimmten Merchant Center-Feedauswählen müssen. Wenn es nicht angegeben ist, werden in der Kampagne alle verfügbaren Feeds im Merchant Center verwendet.

Wenn Sie zuvor sales_country im Format des zweistelligen Ländercodes (XX) verwendet haben, sollten Sie stattdessen feed_label verwenden. Weitere Informationen finden Sie im Hilfeartikel Feedlabels.

Wenn Sie einen Ländercode in einem feed_label angeben, werden Anzeigen nicht automatisch in diesem Land ausgeliefert. Sie müssen zuerst das geografischeTargeting einrichten.

campaign_priority

Die Priorität der Shopping-Kampagne. Kampagnen mit einer numerisch höheren Priorität haben Vorrang vor Kampagnen mit einer niedrigeren Priorität.

enable_local

Die Option, Anzeigen für Produkte zu aktivieren, die in Geschäften vor Ort verkauft werden.

Lokale Produkte sind standardmäßig aktiviert, wenn Inventar vorhanden ist. Sie können mithilfe von Eintragsgruppen gefiltert werden.

language

Sie können mehrere Sprachen auswählen, um Ihre Anzeigen bestimmten Kundengruppen zu präsentieren.

Conversion-Zielvorhaben

Sie können Conversion-Zielvorhaben auf Kundenebene überschreiben, indem Sie Conversion-Zielvorhaben auf Kampagnenebene aktualisieren, wie in diesem Beispiel gezeigt:

Java

/** Retrieves the list of customer conversion goals. */
private static List<CustomerConversionGoal> getCustomerConversionGoals(
    GoogleAdsClient googleAdsClient, long customerId) {
  String query =
      "SELECT customer_conversion_goal.category, customer_conversion_goal.origin "
          + "FROM customer_conversion_goal";

  List<CustomerConversionGoal> customerConversionGoals = new ArrayList<>();
  try (GoogleAdsServiceClient googleAdsServiceClient =
      googleAdsClient.getLatestVersion().createGoogleAdsServiceClient()) {
    // The number of conversion goals is typically less than 50, so we use
    // GoogleAdsService.search instead of search_stream.
    SearchPagedResponse response =
        googleAdsServiceClient.search(Long.toString(customerId), query);
    for (GoogleAdsRow googleAdsRow : response.iterateAll()) {
      customerConversionGoals.add(googleAdsRow.getCustomerConversionGoal());
    }
  }

  return customerConversionGoals;
}

/** Creates a list of MutateOperations that override customer conversion goals. */
private static List<MutateOperation> createConversionGoalOperations(
    long customerId, List<CustomerConversionGoal> customerConversionGoals) {
  List<MutateOperation> mutateOperations = new ArrayList<>();
  // To override the customer conversion goals, we will change the
  // biddability of each of the customer conversion goals so that only
  // the desired conversion goal is biddable in this campaign.
  for (CustomerConversionGoal customerConversionGoal : customerConversionGoals) {
    ConversionActionCategory category = customerConversionGoal.getCategory();
    ConversionOrigin origin = customerConversionGoal.getOrigin();
    String campaignConversionGoalResourceName =
        ResourceNames.campaignConversionGoal(
            customerId, PERFORMANCE_MAX_CAMPAIGN_TEMPORARY_ID, category, origin);
    CampaignConversionGoal.Builder campaignConversionGoalBuilder =
        CampaignConversionGoal.newBuilder().setResourceName(campaignConversionGoalResourceName);
    // Change the biddability for the campaign conversion goal.
    // Set biddability to True for the desired (category, origin).
    // Set biddability to False for all other conversion goals.
    // Note:
    //  1- It is assumed that this Conversion Action
    //     (category=PURCHASE, origin=WEBSITE) exists in this account.
    //  2- More than one goal can be biddable if desired. This example
    //     shows only one.
    if (category == ConversionActionCategory.PURCHASE && origin == ConversionOrigin.WEBSITE) {
      campaignConversionGoalBuilder.setBiddable(true);
    } else {
      campaignConversionGoalBuilder.setBiddable(false);
    }
    CampaignConversionGoal campaignConversionGoal = campaignConversionGoalBuilder.build();
    CampaignConversionGoalOperation campaignConversionGoalOperation =
        CampaignConversionGoalOperation.newBuilder()
            .setUpdate(campaignConversionGoal)
            .setUpdateMask(FieldMasks.allSetFieldsOf(campaignConversionGoal))
            .build();
    mutateOperations.add(
        MutateOperation.newBuilder()
            .setCampaignConversionGoalOperation(campaignConversionGoalOperation)
            .build());
  }
  return mutateOperations;
}
AddPerformanceMaxRetailCampaign.java
      

C#

/// <summary>
/// Creates a MutateOperation that links an asset to an asset group.
/// </summary>
/// <param name="fieldType">The field type of the asset to be linked.</param>
/// <param name="linkedEntityResourceName">The resource name of the entity (asset group or
/// campaign) to link the asset to.</param>
/// <param name="assetResourceName">The resource name of the text asset to be
/// linked.</param>
/// <param name="brandGuidelinesEnabled">Whether or not to enable brand guidelines.</param>
/// <returns>A MutateOperation that links an asset to an asset group.</returns>
private MutateOperation CreateLinkAssetOperation(
    AssetFieldType fieldType,
    string linkedEntityResourceName,
    string assetResourceName,
    bool brandGuidelinesEnabled = false)
{ if (brandGuidelinesEnabled)
    {
        return new MutateOperation()
        {
            CampaignAssetOperation = new CampaignAssetOperation()
            {
                Create = new CampaignAsset()
                {
                    FieldType = fieldType,
                    Campaign = linkedEntityResourceName,
                    Asset = assetResourceName
                }
            }
        };
    } else
    {   return new MutateOperation()
        {
            AssetGroupAssetOperation = new AssetGroupAssetOperation()
            {
                Create = new AssetGroupAsset()
                {
                    FieldType = fieldType,
                    AssetGroup = linkedEntityResourceName,
                    Asset = assetResourceName
                }
            }
        };
    }
}
AddPerformanceMaxRetailCampaign.cs
      

PHP

private static function getCustomerConversionGoals(
    GoogleAdsClient $googleAdsClient,
    int $customerId
): array {
    $customerConversionGoals = [];
    $googleAdsServiceClient = $googleAdsClient->getGoogleAdsServiceClient();
    // Creates a query that retrieves all customer conversion goals.
    $query = 'SELECT customer_conversion_goal.category, customer_conversion_goal.origin ' .
        'FROM customer_conversion_goal';
    // The number of conversion goals is typically less than 50 so we use a search request
    // instead of search stream.
    $response =
        $googleAdsServiceClient->search(SearchGoogleAdsRequest::build($customerId, $query));

    // Iterates over all rows in all pages and builds the list of conversion goals.
    foreach ($response->iterateAllElements() as $googleAdsRow) {
        /** @var GoogleAdsRow $googleAdsRow */
        $customerConversionGoals[] = [
            'category' => $googleAdsRow->getCustomerConversionGoal()->getCategory(),
            'origin' => $googleAdsRow->getCustomerConversionGoal()->getOrigin()
        ];
    }

    return $customerConversionGoals;
}

/**
 * Creates a list of MutateOperations that override customer conversion goals.
 *
 * @param int $customerId the customer ID
 * @param array $customerConversionGoals the list of customer conversion goals that will be
 *      overridden
 * @return MutateOperation[] a list of MutateOperations that update campaign conversion goals
 */
private static function createConversionGoalOperations(
    int $customerId,
    array $customerConversionGoals
): array {
    $operations = [];

    // To override the customer conversion goals, we will change the biddability of each of the
    // customer conversion goals so that only the desired conversion goal is biddable in this
    // campaign.
    foreach ($customerConversionGoals as $customerConversionGoal) {
        $campaignConversionGoal = new CampaignConversionGoal([
            'resource_name' => ResourceNames::forCampaignConversionGoal(
                $customerId,
                self::PERFORMANCE_MAX_CAMPAIGN_TEMPORARY_ID,
                ConversionActionCategory::name($customerConversionGoal['category']),
                ConversionOrigin::name($customerConversionGoal['origin'])
            )
        ]);
        // Changes the biddability for the campaign conversion goal.
        // Sets biddability to true for the desired (category, origin).
        // Sets biddability to false for all other conversion goals.
        // Note:
        //  1- It is assumed that this Conversion Action
        //     (category=PURCHASE, origin=WEBSITE) exists in this account.
        //  2- More than one goal can be biddable if desired. This example
        //     shows only one.
        if (
            $customerConversionGoal["category"] === ConversionActionCategory::PURCHASE
            && $customerConversionGoal["origin"] === ConversionOrigin::WEBSITE
        ) {
            $campaignConversionGoal->setBiddable(true);
        } else {
            $campaignConversionGoal->setBiddable(false);
        }

        $operations[] = new MutateOperation([
            'campaign_conversion_goal_operation' => new CampaignConversionGoalOperation([
                'update' => $campaignConversionGoal,
                // Sets the update mask on the operation. Here the update mask will be a list
                // of all the fields that were set on the update object.
                'update_mask' => FieldMasks::allSetFieldsOf($campaignConversionGoal)
            ])
        ]);
    }

    return $operations;
}
AddPerformanceMaxRetailCampaign.php
      

Python

def get_customer_conversion_goals(
    client: GoogleAdsClient, customer_id: str
) -> List[
    Dict[
        str,
        Union[
            ConversionActionCategoryEnum.ConversionActionCategory,
            ConversionOriginEnum.ConversionOrigin,
        ],
    ]
]:
    """Retrieves the list of customer conversion goals.

    Args:
        client: an initialized GoogleAdsClient instance.
        customer_id: a client customer ID.

    Returns:
        a list of dicts containing the category and origin of customer
        conversion goals.
    """
    ga_service: GoogleAdsServiceClient = client.get_service("GoogleAdsService")
    customer_conversion_goals: List[
        Dict[
            str,
            Union[
                ConversionActionCategoryEnum.ConversionActionCategory,
                ConversionOriginEnum.ConversionOrigin,
            ],
        ]
    ] = []
    query: str = """
            SELECT
              customer_conversion_goal.category,
              customer_conversion_goal.origin
            FROM customer_conversion_goal
            """
    # The number of conversion goals is typically less than 50 so we use
    # GoogleAdsService.search instead of search_stream.
    search_request: SearchGoogleAdsRequest = client.get_type(
        "SearchGoogleAdsRequest"
    )
    search_request.customer_id = customer_id
    search_request.query = query
    results: SearchGoogleAdsResponse = ga_service.search(request=search_request)

    # Iterate over the results and build the list of conversion goals.
    for row in results:
        customer_conversion_goals.append(
            {
                "category": row.customer_conversion_goal.category,
                "origin": row.customer_conversion_goal.origin,
            }
        )
    return customer_conversion_goals


def create_conversion_goal_operations(
    client: GoogleAdsClient,
    customer_id: str,
    customer_conversion_goals: List[
        Dict[
            str,
            Union[
                ConversionActionCategoryEnum.ConversionActionCategory,
                ConversionOriginEnum.ConversionOrigin,
            ],
        ]
    ],
) -> List[MutateOperation]:
    """Creates a list of MutateOperations that override customer conversion goals.

    Args:
        client: an initialized GoogleAdsClient instance.
        customer_id: a client customer ID.
        customer_conversion_goals: the list of customer conversion goals that
          will be overridden.

    Returns:
        MutateOperations that update campaign conversion goals.
    """
    campaign_conversion_goal_service: CampaignConversionGoalServiceClient = (
        client.get_service("CampaignConversionGoalService")
    )
    operations: List[MutateOperation] = []

    # To override the customer conversion goals, we will change the
    # biddability of each of the customer conversion goals so that only
    # the desired conversion goal is biddable in this campaign.
    for customer_goal_dict in customer_conversion_goals:
        mutate_operation: MutateOperation = client.get_type("MutateOperation")
        campaign_conversion_goal: CampaignConversionGoal = (
            mutate_operation.campaign_conversion_goal_operation.update
        )

        category_enum_value: (
            ConversionActionCategoryEnum.ConversionActionCategory
        ) = customer_goal_dict["category"]
        origin_enum_value: ConversionOriginEnum.ConversionOrigin = (
            customer_goal_dict["origin"]
        )

        campaign_conversion_goal.resource_name = (
            campaign_conversion_goal_service.campaign_conversion_goal_path(
                customer_id,
                _PERFORMANCE_MAX_CAMPAIGN_TEMPORARY_ID,
                category_enum_value.name,
                origin_enum_value.name,
            )
        )
        # Change the biddability for the campaign conversion goal.
        # Set biddability to True for the desired (category, origin).
        # Set biddability to False for all other conversion goals.
        # Note:
        #  1- It is assumed that this Conversion Action
        #     (category=PURCHASE, origin=WEBSITE) exists in this account.
        #  2- More than one goal can be biddable if desired. This example
        #     shows only one.
        if (
            category_enum_value
            == client.enums.ConversionActionCategoryEnum.PURCHASE
            and origin_enum_value == client.enums.ConversionOriginEnum.WEBSITE
        ):
            biddable = True
        else:
            biddable = False
        campaign_conversion_goal.biddable = biddable
        field_mask = protobuf_helpers.field_mask(
            None, campaign_conversion_goal._pb
        )
        client.copy_from(
            mutate_operation.campaign_conversion_goal_operation.update_mask,
            field_mask,
        )
        operations.append(mutate_operation)

    return operations
add_performance_max_retail_campaign.py
      

Ruby

def _get_customer_conversion_goals(client, customer_id)
  query = <<~EOD
    SELECT
        customer_conversion_goal.category,
        customer_conversion_goal.origin
    FROM customer_conversion_goal
  EOD

  customer_conversion_goals = []

  ga_service = client.service.google_ads
  # The number of conversion goals is typically less than 50 so we use
  # GoogleAdsService.search instead of search_stream.
  response = ga_service.search(
      customer_id: customer_id,
      query: query,
  )

  # Iterate over the results and build the list of conversion goals.
  response.each do |row|
    customer_conversion_goals << {
        "category" => row.customer_conversion_goal.category,
        "origin" => row.customer_conversion_goal.origin
    }
  end

  customer_conversion_goals
end

def create_conversion_goal_operations(client, customer_id, customer_conversion_goals)
  campaign_conversion_goal_service = client.service.campaign_conversion_goal

  operations = []

  # To override the customer conversion goals, we will change the
  # biddability of each of the customer conversion goals so that only
  # the desired conversion goal is biddable in this campaign.
  customer_conversion_goals.each do |customer_conversion_goal|
    operations << client.operation.mutate do |m|
        m.campaign_conversion_goal_operation = client.operation.campaign_conversion_goal do |op|
          op.update = client.resource.campaign_conversion_goal do |ccg|
              ccg.resource_name = client.path.campaign_conversion_goal(
                  customer_id,
                  PERFORMANCE_MAX_CAMPAIGN_TEMPORARY_ID,
                  customer_conversion_goal["category"].to_s,
                  customer_conversion_goal["origin"].to_s)
              # Change the biddability for the campaign conversion goal.
              # Set biddability to True for the desired (category, origin).
              # Set biddability to False for all other conversion goals.
              # Note:
              #  1- It is assumed that this Conversion Action
              #     (category=PURCHASE, origin=WEBSITE) exists in this account.
              #  2- More than one goal can be biddable if desired. This example
              #     shows only one.
              ccg.biddable = (customer_conversion_goal["category"] == :PURCHASE &&
                  customer_conversion_goal["origin"] == :WEBSITE)
          end
          op.update_mask = Google::Ads::GoogleAds::FieldMaskUtil.all_set_fields_of(op.update)
        end
    end
  end

  operations
end
add_performance_max_retail_campaign.rb
      

Perl

sub get_customer_conversion_goals {
  my ($api_client, $customer_id) = @_;

  my $customer_conversion_goals = [];
  # Create a query that retrieves all customer conversion goals.
  my $query =
    "SELECT customer_conversion_goal.category, customer_conversion_goal.origin "
    . "FROM customer_conversion_goal";
  # The number of conversion goals is typically less than 50 so we use
  # GoogleAdsService->search() method instead of search_stream().
  my $search_response = $api_client->GoogleAdsService()->search({
    customerId => $customer_id,
    query      => $query
  });

  # Iterate over the results and build the list of conversion goals.
  foreach my $google_ads_row (@{$search_response->{results}}) {
    push @$customer_conversion_goals,
      {
      category => $google_ads_row->{customerConversionGoal}{category},
      origin   => $google_ads_row->{customerConversionGoal}{origin}};
  }

  return $customer_conversion_goals;
}

# Creates a list of MutateOperations that override customer conversion goals.
sub create_conversion_goal_operations {
  my ($customer_id, $customer_conversion_goals) = @_;

  my $operations = [];
  # To override the customer conversion goals, we will change the biddability of
  # each of the customer conversion goals so that only the desired conversion goal
  # is biddable in this campaign.
  foreach my $customer_conversion_goal (@$customer_conversion_goals) {
    my $campaign_conversion_goal =
      Google::Ads::GoogleAds::V24::Resources::CampaignConversionGoal->new({
        resourceName =>
          Google::Ads::GoogleAds::V24::Utils::ResourceNames::campaign_conversion_goal(
          $customer_id,
          PERFORMANCE_MAX_CAMPAIGN_TEMPORARY_ID,
          $customer_conversion_goal->{category},
          $customer_conversion_goal->{origin})});
    # Change the biddability for the campaign conversion goal.
    # Set biddability to true for the desired (category, origin).
    # Set biddability to false for all other conversion goals.
    # Note:
    #  1- It is assumed that this Conversion Action
    #     (category=PURCHASE, origin=WEBSITE) exists in this account.
    #  2- More than one goal can be biddable if desired. This example
    #     shows only one.
    if ( $customer_conversion_goal->{category} eq PURCHASE
      && $customer_conversion_goal->{origin} eq WEBSITE)
    {
      $campaign_conversion_goal->{biddable} = "true";
    } else {
      $campaign_conversion_goal->{biddable} = "false";
    }

    push @$operations,
      Google::Ads::GoogleAds::V24::Services::GoogleAdsService::MutateOperation
      ->new({
        campaignConversionGoalOperation =>
          Google::Ads::GoogleAds::V24::Services::CampaignConversionGoalService::CampaignConversionGoalOperation
          ->new({
            update => $campaign_conversion_goal,
            # Set the update mask on the operation. Here the update mask will be
            # a list of all the fields that were set on the update object.
            updateMask => all_set_fields_of($campaign_conversion_goal)})});
  }

  return $operations;
}
add_performance_max_retail_campaign.pl
      

curl

Hinweis:Ein direktes REST-Codebeispiel für diesen Schritt ist hier nicht verfügbar. 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.

Berichte zu Shopping-Kampagnen

Verwenden Sie shopping_performance_view, um Messwerte abzurufen, die nach Produktsegmenten wie segments.product_item_id zusammengefasst sind.

SELECT
  segments.product_item_id,
  metrics.clicks,
  metrics.cost_micros,
  metrics.impressions,
  metrics.search_budget_lost_impression_share,
  metrics.search_rank_lost_impression_share,
  metrics.search_budget_lost_absolute_top_impression_share,
  metrics.search_rank_lost_absolute_top_impression_share,
  metrics.conversions,
  metrics.all_conversions,
  campaign.advertising_channel_type
FROM shopping_performance_view
WHERE
  campaign.advertising_channel_type = 'PERFORMANCE_MAX'
  AND segments.date DURING LAST_30_DAYS
  AND metrics.clicks > 0
ORDER BY
  metrics.all_conversions DESC,
  metrics.conversions DESC,
  metrics.clicks DESC,
  metrics.cost_micros DESC,
  metrics.impressions DESC

Mit asset_group_product_group_view können Sie Messwerte wie Klicks, Conversions und Impressionen der Eintragsgruppeabrufen, die mit dieser Asset-Gruppe verknüpft ist.

Fahrzeuganzeigen

Hinweis: Fahrzeuganzeigen sind nur in ausgewählten Ländern verfügbar. Weitere Informationen zur Verfügbarkeit finden Sie im Hilfeartikel Fahrzeuganzeigen.

Werbetreibende können Fahrzeuganzeigen verwenden, um ihr Fahrzeuginventar zu bewerben. Dazu laden sie einen Fahrzeugdatenfeed in das Merchant Center hoch und verwalten Anzeigen dann mit Performance Max-Kampagnen mit Fahrzeugfeeds.

Wenn Sie mit der Google Ads API eine Performance Max-Kampagne mit einem Fahrzeugfeed erstellen möchten, folgen Sie der Anleitung unter Performance Max-Kampagne für den Einzelhandel erstellen, und legen Sie für listing_type der Kampagne VEHICLES fest.