Zasoby w kampanii Performance Max

Zadbaj o dobrą organizację dzięki kolekcji Zapisuj i kategoryzuj treści zgodnie ze swoimi preferencjami.

Kampanie Performance Max mają wyjątkowe cechy zasobów.

  1. Minimalna wymagana liczba zasobów różnych typów
  2. Zasoby są grupowane w kolekcję AssetGroup, która jest unikalna dla kampanii Performance Max.
  3. Zasoby są generowane automatycznie przez systemy uczące się.

Zadbaj o spełnienie minimalnych wymagań dotyczących zasobów

Każda kampania Performance Max wymaga początkowego początkowego zestawu zasobów. Mogą to być istniejące zasoby używane w innych kampaniach lub nowe zasoby przeznaczone specjalnie do kampanii Performance Max.

Typ zasobu Typ pola Specyfikacja Minimum Maksimum
TEKST HEADLINE Maksymalnie 30 znaków; wpisz co najmniej 15 znaków. 3 5
DŁUGI_NAGŁÓWEK Maks. 90 znaków 1 5
OPIS Maksymalnie 90 znaków; dodaj co najmniej 6 znaków. 2 5
BUSINESS_NAME Maks. 120 znaków 1 1
OBRAZ MARKETING_IMAGE Orientacja pozioma (1,91:1) – zalecane wymiary to 1200 x 628 pikseli, maks. 600 x 314 pikseli i maks. 5120 KB 1 20
Kwadratowy_MARKETING_IMAGE (1:1) zalecany rozmiar 1200 x 1200; 300 x 300 min, maksymalny rozmiar pliku to 5120 KB 1 20
PORTRAIT_MARKETING_IMAGE (4:5) Zalecane wymiary: 960 x 1200; 480 x 600 min 0 20
LOGO (1:1) zalecany rozmiar 1200 x 1200; 128 x 128 min; maksymalny rozmiar pliku 5120 KB 1 5
LANDSCAPE_LOGO, (4:1) Zalecane wymiary: 1200 x 300; 512 x 128 min; maksymalny rozmiar pliku: 5120 KB 0 5
YOUTUBE_VIDEO YOUTUBE_VIDEO pozioma, pionowa lub kwadratowa; >==10 sekund 0 5
ZADZWOŃ_CZYNNOŚĆ CALL_TO_ACTION_SELECTION Automatyczne lub wybierz je z listy 0 1
MEDIA_BUDLE MEDIA_BUDLE < 150 KB 0 1

Powtarzające się zasoby (HEADLINE, DESCRIPTION) należy utworzyć w osobnym żądaniu przed utworzeniem kampanii.

Poniższy fragment kodu ilustruje tworzenie niezbędnych kolejnych zasobów w nowym żądaniu:

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;
}
      

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.V12.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;
}

      

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($customerId, $operations);

    $assetResourceNames = [];
    foreach ($mutateGoogleAdsResponse->getMutateOperationResponses() as $response) {
        /** @var MutateOperationResponse $response */
        $assetResourceNames[] = $response->getAssetResult()->getResourceName();
    }
    self::printResponseDetails($mutateGoogleAdsResponse);

    return $assetResourceNames;
}
      

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
      

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
      

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::V12::Services::GoogleAdsService::MutateOperation
      ->new({
        assetOperation =>
          Google::Ads::GoogleAds::V12::Services::AssetService::AssetOperation->
          new({
            create => Google::Ads::GoogleAds::V12::Resources::Asset->new({
                textAsset =>
                  Google::Ads::GoogleAds::V12::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;
}
      

grupy zasobów,

Każda kampania wymaga co najmniej 1 grupy zasobów. Zasoby są automatycznie łączone ze sobą i dopasowywane zależnie od tego, w którym kanale Google Ads (m.in. w YouTube, Gmailu lub wyszukiwarce) wyświetla się Twoja reklama.

Zasoby wygenerowane przez automatyzację

Automatyzacja Google przy użyciu systemów uczących się generuje w razie potrzeby dodatkowe zasoby obejmujące wszystkie odpowiednie kanały.

Jeśli do grupy zasobów kampanii Maksymalizacja skuteczności nie dodasz żadnego filmu, możliwe, że wygenerujemy co najmniej jeden zasób wideo na podstawie zasobów należących do grupy. Jeśli nie chcesz, aby w Twojej kampanii Maksymalizacja skuteczności wyświetlały się filmy generowane automatycznie, możesz przesłać własny film. Spowoduje to przerwanie wyświetlania filmów generowanych automatycznie.