Wynik optymalizacji i rekomendacje

ondemand_video Wideo: szczegółowa analiza

Rekomendacje mogą zwiększać skuteczność kampanii na kilka sposobów:

• Wprowadzanie nowych i przydatnych funkcji
• Lepiej wykorzystaj budżet dzięki ulepszonym stawkom, słowom kluczowym i reklamom
• Zwiększanie ogólnej skuteczności i skuteczności kampanii

Aby zwiększyć wyniki optymalizacji, możesz za pomocą metody RecommendationService pobierać rekomendacje, a potem je stosować lub odrzucać. Od wersji 15 interfejsu Google Ads API możesz też zasubskrybować automatyczne stosowanie rekomendacji za pomocą interfejsu RecommendationSubscriptionService.

Wynik optymalizacji

ondemand_video Wideo: wynik optymalizacji

Wynik optymalizacji to prognoza skuteczności Twojego konta Google Ads. Jest on dostępny na poziomach Customer i Campaign.

Kolumna Customer.optimization_score_weight jest dostępna tylko na kontach innych niż menedżera i służy do obliczania ogólnego wyniku optymalizacji wielu kont. Pobierz wartości wyniku optymalizacji i wyniku optymalizacji kont oraz pomnóż przez siebie (Customer.optimization_score * Customer.optimization_score_weight), aby obliczyć ogólny wynik optymalizacji.

W raportach customer i campaign dostępne są dane dotyczące optymalizacji:

1. metrics.optimization_score_url zawiera precyzyjny link do konta, który pozwala wyświetlać informacje o powiązanych rekomendacjach w interfejsie Google Ads.
2. metrics.optimization_score_uplift informuje, o ile zwiększyłby się wynik optymalizacji po zastosowaniu wszystkich powiązanych rekomendacji. Jest to szacunkowa wartość obliczona na podstawie wszystkich dostępnych rekomendacji, a nie tylko sumy wyników wzrostu każdej rekomendacji.

Aby pogrupować i uporządkować zwrócone rekomendacje, możesz podzielić je na segmenty według typu rekomendacji, korzystając w zapytaniu z funkcji segments.recommendation_type.

Typy rekomendacji

Pobieranie rekomendacji

ondemand_video Wideo: kodowanie na żywo

Podobnie jak większość innych elementów w interfejsie Google Ads API, obiekty Recommendation są pobierane za pomocą metody GoogleAdsService.SearchStream w połączeniu z zapytaniem w języku Google Ads Query Language.

Szczegółowe informacje o poszczególnych typach rekomendacji są podane w odpowiednich polach. Na przykład szczegóły rekomendacji CAMPAIGN_BUDGET znajdują się w polu campaign_budget_recommendation i są umieszczone w obiekcie CampaignBudgetRecommendation.

Wszystkie pola dotyczące rekomendacji znajdziesz w polu sumy recommendation.

Wpływ rekomendacji

Niektóre typy rekomendacji wypełniają pole impact. Pole RecommendationImpact zawiera szacowany wpływ zastosowania rekomendacji na skuteczność konta. W polach impact.base_metrics i impact.potential_metrics dostępne są te dane rekomendacji:

• impressions

• clicks

• cost_micros

• conversions

• all_conversions (dostępny od wersji 16 interfejsu Google Ads API)

• video_views

Przykładowy kod

Ten przykładowy kod pobiera z konta wszystkie dostępne i odrzucone rekomendacje typu KEYWORD i wyświetla niektóre ich szczegóły:

try (GoogleAdsServiceClient googleAdsServiceClient =
        googleAdsClient.getLatestVersion().createGoogleAdsServiceClient();
    RecommendationServiceClient recommendationServiceClient =
        googleAdsClient.getLatestVersion().createRecommendationServiceClient()) {
  // Creates a query that retrieves keyword recommendations.
  String query =
      "SELECT recommendation.resource_name, "
          + "  recommendation.campaign, "
          + "  recommendation.keyword_recommendation "
          + "FROM recommendation "
          + "WHERE recommendation.type = KEYWORD";
  // Constructs the SearchGoogleAdsStreamRequest.
  SearchGoogleAdsStreamRequest request =
      SearchGoogleAdsStreamRequest.newBuilder()
          .setCustomerId(Long.toString(customerId))
          .setQuery(query)
          .build();

  // Issues the search stream request to detect keyword recommendations that exist for the
  // customer account.
  ServerStream<SearchGoogleAdsStreamResponse> stream =
      googleAdsServiceClient.searchStreamCallable().call(request);

  // Creates apply operations for all the recommendations found.
  List<ApplyRecommendationOperation> applyRecommendationOperations = new ArrayList<>();
  for (SearchGoogleAdsStreamResponse response : stream) {
    for (GoogleAdsRow googleAdsRow : response.getResultsList()) {
      Recommendation recommendation = googleAdsRow.getRecommendation();
      System.out.printf(
          "Keyword recommendation '%s' was found for campaign '%s'%n",
          recommendation.getResourceName(), recommendation.getCampaign());
      KeywordInfo keyword = recommendation.getKeywordRecommendation().getKeyword();
      System.out.printf("\tKeyword = '%s'%n", keyword.getText());
      System.out.printf("\tMatch type = '%s'%n", keyword.getMatchType());

      // Creates an ApplyRecommendationOperation that will apply this recommendation, and adds
      // it to the list of operations.
      applyRecommendationOperations.add(buildRecommendationOperation(recommendation));
    }
  }
DetectAndApplyRecommendations.java
      

// Get the GoogleAdsServiceClient.
GoogleAdsServiceClient googleAdsService = client.GetService(
    Services.V16.GoogleAdsService);

// Creates a query that retrieves keyword recommendations.
string query = "SELECT recommendation.resource_name, " +
    "recommendation.campaign, recommendation.keyword_recommendation " +
    "FROM recommendation WHERE " +
    $"recommendation.type = KEYWORD";

List<ApplyRecommendationOperation> operations =
    new List<ApplyRecommendationOperation>();

try
{
    // Issue a search request.
    googleAdsService.SearchStream(customerId.ToString(), query,
        delegate (SearchGoogleAdsStreamResponse resp)
        {
            Console.WriteLine($"Found {resp.Results.Count} recommendations.");
            foreach (GoogleAdsRow googleAdsRow in resp.Results)
            {
                Recommendation recommendation = googleAdsRow.Recommendation;
                Console.WriteLine("Keyword recommendation " +
                    $"{recommendation.ResourceName} was found for campaign " +
                    $"{recommendation.Campaign}.");

                if (recommendation.KeywordRecommendation != null)
                {
                    KeywordInfo keyword =
                        recommendation.KeywordRecommendation.Keyword;
                    Console.WriteLine($"Keyword = {keyword.Text}, type = " +
                        "{keyword.MatchType}");
                }

                operations.Add(
                    BuildApplyRecommendationOperation(recommendation.ResourceName)
                );
            }
        }
    );
}
catch (GoogleAdsException e)
{
    Console.WriteLine("Failure:");
    Console.WriteLine($"Message: {e.Message}");
    Console.WriteLine($"Failure: {e.Failure}");
    Console.WriteLine($"Request ID: {e.RequestId}");
    throw;
}
DetectAndApplyRecommendations.cs
      

$googleAdsServiceClient = $googleAdsClient->getGoogleAdsServiceClient();
// Creates a query that retrieves keyword recommendations.
$query = 'SELECT recommendation.resource_name, recommendation.campaign, '
    . 'recommendation.keyword_recommendation '
    . 'FROM recommendation '
    . 'WHERE recommendation.type = KEYWORD ';
// Issues a search request to detect keyword recommendations that exist for the
// customer account.
$response =
    $googleAdsServiceClient->search(SearchGoogleAdsRequest::build($customerId, $query));

$operations = [];
// Iterates over all rows in all pages and prints the requested field values for
// the recommendation in each row.
foreach ($response->iterateAllElements() as $googleAdsRow) {
    /** @var GoogleAdsRow $googleAdsRow */
    $recommendation = $googleAdsRow->getRecommendation();
    printf(
        "Keyword recommendation with resource name '%s' was found for campaign "
        . "with resource name '%s':%s",
        $recommendation->getResourceName(),
        $recommendation->getCampaign(),
        PHP_EOL
    );
    if (!is_null($recommendation->getKeywordRecommendation())) {
        $keyword = $recommendation->getKeywordRecommendation()->getKeyword();
        printf(
            "\tKeyword = '%s'%s\ttype = '%s'%s",
            $keyword->getText(),
            PHP_EOL,
            KeywordMatchType::name($keyword->getMatchType()),
            PHP_EOL
        );
    }
    // Creates an ApplyRecommendationOperation that will be used to apply this
    // recommendation, and adds it to the list of operations.
    $operations[] = self::buildRecommendationOperation($recommendation->getResourceName());
}
DetectAndApplyRecommendations.php
      

googleads_service = client.get_service("GoogleAdsService")
query = f"""
    SELECT
      recommendation.campaign,
      recommendation.keyword_recommendation
    FROM recommendation
    WHERE
      recommendation.type = KEYWORD"""

# Detects keyword recommendations that exist for the customer account.
response = googleads_service.search(customer_id=customer_id, query=query)

operations = []
for row in response.results:
    recommendation = row.recommendation
    print(
        f"Keyword recommendation ('{recommendation.resource_name}') "
        f"was found for campaign '{recommendation.campaign}."
    )

    keyword = recommendation.keyword_recommendation.keyword
    print(
        f"\tKeyword = '{keyword.text}'\n" f"\tType = '{keyword.match_type}'"
    )

    # Create an ApplyRecommendationOperation that will be used to apply
    # this recommendation, and add it to the list of operations.
    operations.append(
        build_recommendation_operation(client, recommendation.resource_name)
    )
detect_and_apply_recommendations.py
      

query = <<~QUERY
  SELECT recommendation.resource_name, recommendation.campaign,
      recommendation.keyword_recommendation
  FROM recommendation
  WHERE recommendation.type = KEYWORD
QUERY

google_ads_service = client.service.google_ads

response = google_ads_service.search(
  customer_id: customer_id,
  query: query,
)

operations = response.each do |row|
  recommendation = row.recommendation

  puts "Keyword recommendation ('#{recommendation.resource_name}') was found for "\
    "campaign '#{recommendation.campaign}'."

  if recommendation.keyword_recommendation
    keyword = recommendation.keyword_recommendation.keyword
    puts "\tKeyword = '#{keyword.text}'"
    puts "\ttype = '#{keyword.match_type}'"
  end

  build_recommendation_operation(client, recommendation.resource_name)
end
detect_and_apply_recommendations.rb
      

# Create the search query.
my $search_query =
  "SELECT recommendation.resource_name, " .
  "recommendation.campaign, recommendation.keyword_recommendation " .
  "FROM recommendation " .
  "WHERE recommendation.type = KEYWORD";

# Get the GoogleAdsService.
my $google_ads_service = $api_client->GoogleAdsService();

my $search_stream_handler =
  Google::Ads::GoogleAds::Utils::SearchStreamHandler->new({
    service => $google_ads_service,
    request => {
      customerId => $customer_id,
      query      => $search_query
    }});

# Create apply operations for all the recommendations found.
my $apply_recommendation_operations = ();
$search_stream_handler->process_contents(
  sub {
    my $google_ads_row = shift;
    my $recommendation = $google_ads_row->{recommendation};
    printf "Keyword recommendation '%s' was found for campaign '%s'.\n",
      $recommendation->{resourceName}, $recommendation->{campaign};
    my $keyword = $recommendation->{keywordRecommendation}{keyword};
    printf "\tKeyword = '%s'\n",    $keyword->{text};
    printf "\tMatch type = '%s'\n", $keyword->{matchType};
    # Creates an ApplyRecommendationOperation that will apply this recommendation, and adds
    # it to the list of operations.
    push @$apply_recommendation_operations,
      build_recommendation_operation($recommendation);
  });
detect_and_apply_recommendations.pl
      

Podejmij działanie

Każdą pobraną rekomendację można zastosować lub odrzucić.

W zależności od typu rekomendacji mogą się one zmieniać codziennie lub nawet kilka razy dziennie. W takim przypadku resource_name obiektu rekomendacji może stać się przestarzały po pobraniu rekomendacji.

Warto podjąć działania związane z rekomendacjami tuż po ich pobraniu.

Zastosuj rekomendacje

ondemand_video Wideo: stosowanie rekomendacji

Aktywne lub odrzucone rekomendacje możesz stosować za pomocą metody ApplyRecommendation RecommendationService.

Typy rekomendacji mogą mieć parametry obowiązkowe lub opcjonalne. Większość rekomendacji ma zalecane wartości, które są używane domyślnie.

Ustawianie kont na potrzeby automatycznego stosowania rekomendacji nie jest obsługiwane w przypadku niektórych typów rekomendacji. Możesz jednak wdrożyć podobne działanie w przypadku typów rekomendacji, które są w pełni obsługiwane przez interfejs Google Ads API. Więcej informacji znajdziesz w przykładzie kodu DetectAndApplyRecommendations.

Aby stosować rekomendacje z określonymi wartościami parametrów, użyj pola sumy apply_parameters wartości ApplyRecommendationOperation. Każdy odpowiedni typ rekomendacji ma własne pole. Żaden typ rekomendacji niewymieniony w polu apply_parameters nie korzysta z tych wartości parametrów.

Przykładowy kod

Poniższy kod pokazuje, jak utworzyć ApplyRecommendationOperation i jak zastąpić zalecane wartości, jeśli chcesz je zastąpić własnymi.

/** Creates and returns an ApplyRecommendationOperation to apply the given recommendation. */
private ApplyRecommendationOperation buildRecommendationOperation(Recommendation recommendation) {
  // If you have a recommendation ID instead of a resource name, you can create a resource name
  // like this:
  // String resourceName = ResourceNames.recommendation(customerId, recommendationId);

  // Creates a builder to construct the operation.
  Builder operationBuilder = ApplyRecommendationOperation.newBuilder();

  // Each recommendation type has optional parameters to override the recommended values. Below is
  // an example showing how to override a recommended ad when a TextAdRecommendation is applied.
  // operationBuilder.getTextAdBuilder().getAdBuilder().setResourceName("INSERT_AD_RESOURCE_NAME");

  // Sets the operation's resource name to the resource name of the recommendation to apply.
  operationBuilder.setResourceName(recommendation.getResourceName());
  return operationBuilder.build();
}
DetectAndApplyRecommendations.java
      

private ApplyRecommendationOperation BuildApplyRecommendationOperation(
    string recommendationResourceName
)
{
    // If you have a recommendation_id instead of the resource_name you can create a
    // resource name from it like this:
    // string recommendationResourceName =
    //    ResourceNames.Recommendation(customerId, recommendationId)

    // Each recommendation type has optional parameters to override the recommended values.
    // This is an example to override a recommended ad when a TextAdRecommendation is
    // applied.
    // For details, please read
    // https://developers.google.com/google-ads/api/reference/rpc/latest/ApplyRecommendationOperation.
    /*
    Ad overridingAd = new Ad()
    {
        Id = "INSERT_AD_ID_AS_LONG_HERE"
    };
    applyRecommendationOperation.TextAd = new TextAdParameters()
    {
        Ad = overridingAd
    };
    */

    ApplyRecommendationOperation applyRecommendationOperation =
    new ApplyRecommendationOperation()
    {
        ResourceName = recommendationResourceName
    };

    return applyRecommendationOperation;
}
DetectAndApplyRecommendations.cs
      

private static function buildRecommendationOperation(
    string $recommendationResourceName
): ApplyRecommendationOperation {
    // If you have a recommendation_id instead of the resource name, you can create a resource
    // name from it like this:
    /*
    $recommendationResourceName =
        ResourceNames::forRecommendation($customerId, $recommendationId);
    */

    // Each recommendation type has optional parameters to override the recommended values.
    // This is an example to override a recommended ad when a TextAdRecommendation is applied.
    // For details, please read
    // https://developers.google.com/google-ads/api/reference/rpc/latest/ApplyRecommendationOperation.
    /*
    $overridingAd = new Ad([
        'id' => 'INSERT_AD_ID_AS_INTEGER_HERE'
    ]);
    $applyRecommendationOperation->setTextAd(new TextAdParameters(['ad' => $overridingAd]));
    */

    // Issues a mutate request to apply the recommendation.
    $applyRecommendationOperation = new ApplyRecommendationOperation();
    $applyRecommendationOperation->setResourceName($recommendationResourceName);
    return $applyRecommendationOperation;
}
DetectAndApplyRecommendations.php
      

def build_recommendation_operation(client, recommendation):
    """Creates a ApplyRecommendationOperation to apply the given recommendation.

    Args:
        client: an initialized GoogleAdsClient instance.
        customer_id: a client customer ID.
        recommendation: a resource name for the recommendation to be applied.
    """
    # If you have a recommendation ID instead of a resource name, you can create
    # a resource name like this:
    #
    # googleads_service = client.get_service("GoogleAdsService")
    # resource_name = googleads_service.recommendation_path(
    #   customer_id, recommendation.id
    # )

    operation = client.get_type("ApplyRecommendationOperation")

    # Each recommendation type has optional parameters to override the
    # recommended values. Below is an example showing how to override a
    # recommended ad when a TextAdRecommendation is applied.
    #
    # operation.text_ad.ad.resource_name = "INSERT_AD_RESOURCE_NAME"
    #
    # For more details, see:
    # https://developers.google.com/google-ads/api/reference/rpc/latest/ApplyRecommendationOperation#apply_parameters

    operation.resource_name = recommendation
    return operation
detect_and_apply_recommendations.py
      

def build_recommendation_operation(client, recommendation)
  # If you have a recommendation_id instead of the resource_name
  # you can create a resource name from it like this:
  # recommendation_resource =
  #    client.path.recommendation(customer_id, recommendation_id)

  operations = client.operation.apply_recommendation
  operations.resource_name = recommendation_resource

  # Each recommendation type has optional parameters to override the recommended
  # values. This is an example to override a recommended ad when a
  # TextAdRecommendation is applied.
  #
  # text_ad_parameters = client.resource.text_ad_parameters do |tap|
  #   tap.ad = client.resource.ad do |ad|
  #     ad.id = "INSERT_AD_ID_AS_INTEGER_HERE"
  #   end
  # end
  # operation.text_ad = text_ad_parameters
  #
  # For more details, see:
  # https://developers.google.com/google-ads/api/reference/rpc/latest/ApplyRecommendationOperation#apply_parameters

  return operation
end
detect_and_apply_recommendations.rb
      

sub build_recommendation_operation {
  my ($recommendation) = @_;

  # If you have a recommendation ID instead of a resource name, you can create a resource
  # name like this:
  # my $recommendation_resource_name =
  #   Google::Ads::GoogleAds::V16::Utils::ResourceNames::recommendation(
  #   $customer_id, $recommendation_id);

  # Each recommendation type has optional parameters to override the recommended values.
  # Below is an example showing how to override a recommended ad when a TextAdRecommendation
  # is applied.
  # my $overriding_ad = Google::Ads::GoogleAds::V16::Resources::Ad->new({
  #   id => "INSERT_AD_ID_AS_INTEGER_HERE"
  # });
  # my $text_ad_parameters =
  #   Google::Ads::GoogleAds::V16::Services::RecommendationService::TextAdParameters
  #   ->new({ad => $overriding_ad});
  # $apply_recommendation_operation->{textAd} = $text_ad_parameters;

  # Create an apply recommendation operation.
  my $apply_recommendation_operation =
    Google::Ads::GoogleAds::V16::Services::RecommendationService::ApplyRecommendationOperation
    ->new({
      resourceName => $recommendation->{resourceName}});

  return $apply_recommendation_operation;
}
detect_and_apply_recommendations.pl
      

Następny przykład wywołuje funkcję ApplyRecommendation, wysyłając operacje stosowania rekomendacji, które zostały utworzone w poprzednim kodzie.

// Issues a mutate request to apply the recommendations.
ApplyRecommendationResponse applyRecommendationsResponse =
    recommendationServiceClient.applyRecommendation(
        Long.toString(customerId), applyRecommendationOperations);
for (ApplyRecommendationResult applyRecommendationResult :
    applyRecommendationsResponse.getResultsList()) {
  System.out.printf(
      "Applied recommendation with resource name: '%s'.%n",
      applyRecommendationResult.getResourceName());
}
DetectAndApplyRecommendations.java
      

private void ApplyRecommendation(GoogleAdsClient client, long customerId,
    List<ApplyRecommendationOperation> operations)
{
    // Get the RecommendationServiceClient.
    RecommendationServiceClient recommendationService = client.GetService(
        Services.V16.RecommendationService);

    ApplyRecommendationRequest applyRecommendationRequest = new ApplyRecommendationRequest()
    {
        CustomerId = customerId.ToString(),
    };

    applyRecommendationRequest.Operations.AddRange(operations);

    ApplyRecommendationResponse response =
        recommendationService.ApplyRecommendation(applyRecommendationRequest);
    foreach (ApplyRecommendationResult result in response.Results)
    {
        Console.WriteLine("Applied a recommendation with resource name: " +
            result.ResourceName);
    }
}
DetectAndApplyRecommendations.cs
      

private static function applyRecommendations(
    GoogleAdsClient $googleAdsClient,
    int $customerId,
    array $operations
): void {
    // Issues a mutate request to apply the recommendations.
    $recommendationServiceClient = $googleAdsClient->getRecommendationServiceClient();
    $response = $recommendationServiceClient->applyRecommendation(
        ApplyRecommendationRequest::build($customerId, $operations)
    );
    foreach ($response->getResults() as $appliedRecommendation) {
        /** @var Recommendation $appliedRecommendation */
        printf(
            "Applied a recommendation with resource name: '%s'.%s",
            $appliedRecommendation->getResourceName(),
            PHP_EOL
        );
    }
}
DetectAndApplyRecommendations.php
      

def apply_recommendations(client, customer_id, operations):
    """Applies a batch of recommendations.

    Args:
        client: an initialized GoogleAdsClient instance.
        customer_id: a client customer ID.
        operations: a list of ApplyRecommendationOperation messages.
    """
    # Issues a mutate request to apply the recommendations.
    recommendation_service = client.get_service("RecommendationService")
    response = recommendation_service.apply_recommendation(
        customer_id=customer_id, operations=operations
    )

    for result in response.results:
        print(
            "Applied a recommendation with resource name: "
            f"'{result[0].resource_name}'."
        )
detect_and_apply_recommendations.py
      

def apply_recommendations(client, customer_id, operations)
  # Issues a mutate request to apply the recommendation.
  recommendation_service = client.service.recommendation

  response = recommendation_service.apply_recommendation(
    customer_id: customer_id,
    operations: [operations],
  )

  response.results.each do |applied_recommendation|
    puts "Applied recommendation with resource name: '#{applied_recommendation.resource_name}'."
  end
end
detect_and_apply_recommendations.rb
      

# Issue a mutate request to apply the recommendations.
my $apply_recommendation_response =
  $api_client->RecommendationService()->apply({
    customerId => $customer_id,
    operations => $apply_recommendation_operations
  });

foreach my $result (@{$apply_recommendation_response->{results}}) {
  printf "Applied recommendation with resource name: '%s'.\n",
    $result->{resourceName};
}
detect_and_apply_recommendations.pl
      

Odrzucanie rekomendacji

ondemand_video Film: odrzucanie rekomendacji

Rekomendacje możesz odrzucać za pomocą RecommendationService. Struktura kodu jest podobna do stosowania rekomendacji, ale zamiast tego używasz DismissRecommendationOperation i RecommendationService.DismissRecommendation.

Włącz automatyczne stosowanie rekomendacji

Począwszy od wersji 15 interfejsu Google Ads API, możesz używać interfejsu RecommendationSubscriptionService do automatycznego stosowania rekomendacji określonego typu.

Aby zasubskrybować konkretny typ rekomendacji, utwórz obiekt RecommendationSubscription, w polu type wybierz jeden z obsługiwanych typów rekomendacji, a w polu status ustaw wartość ENABLED.

Pobierz subskrypcje

Aby uzyskać informacje o subskrypcjach rekomendacji na koncie, wyślij zapytanie do zasobu recommendation_subscription.

Aby wyświetlić zmiany zastosowane automatycznie, wyślij zapytanie do zasobu change_event, filtrując change_client_type według wartości GOOGLE_ADS_RECOMMENDATIONS_SUBSCRIPTION.

Rekomendacje dotyczące tworzenia kampanii

Począwszy od wersji 16 interfejsu Google Ads API, możesz używać narzędzia RecommendationService.GenerateRecommendationsRequest do generowania rekomendacji podczas tworzenia kampanii dla określonego zestawu typów rekomendacji.

GenerateRecommendations akceptuje jako dane wejściowe identyfikator klienta, typ kanału reklamowego SEARCH lub PERFORMANCE_MAX, listę typów rekomendacji do wygenerowania oraz różne punkty danych zależne od określonych typów. Na podstawie podanych przez Ciebie danych generuje listę obiektów Recommendation. Jeśli nie ma wystarczającej ilości danych do wygenerowania rekomendacji dotyczącej żądanego elementu recommendation_types lub jeśli kampania jest już w stanie zalecanym, zestaw wyników nie będzie zawierał rekomendacji dotyczącej tego typu. Upewnij się, że aplikacja obsługuje przypadek, w którym nie są zwracane żadne rekomendacje dotyczące żądanych typów rekomendacji.

W tabeli poniżej opisujemy typy rekomendacji obsługiwane przez GenerateRecommendations oraz pola, które musisz podać, aby otrzymywać rekomendacje tego typu. Sprawdzoną metodą jest wysłanie żądania GenerateRecommendations po zgromadzeniu wszystkich informacji związanych z żądanymi typami rekomendacji. Więcej informacji na temat pól wymaganych i opcjonalnych, w tym pól zagnieżdżonych, znajdziesz w dokumentacji referencyjnej.

Przykładowy przepływ wykorzystania

Załóżmy, że Twoja firma jest agencją reklamową, która zajmuje się tworzeniem kampanii dla użytkowników i chcesz oferować użytkownikom sugestie podczas tego procesu. Za pomocą narzędzia GenerateRecommendationsRequest możesz generować rekomendacje na żądanie i stosować je w interfejsie tworzenia kampanii.

Proces korzystania może wyglądać tak:

1. Użytkownik otwiera aplikację, aby utworzyć kampanię Performance Max.

2. Użytkownik podaje wstępne informacje w trakcie tworzenia kampanii. Podaje na przykład szczegóły potrzebne do utworzenia pojedynczego elementu SitelinkAsset i jako strategię inteligentnego określania stawek wybiera TARGET_SPEND.

3. Wysyłasz GenerateRecommendationsRequest, który ustawia te pola:

   • campaign_sitelink_count: ustaw wartość 1, czyli liczbę komponentów z linkami do podstron w trwającej kampanii.

   • bidding_info: ustaw zagnieżdżone pole bidding_strategy_type na TARGET_SPEND.

   • conversion_tracking_status: ustaw wartość ConversionTrackingStatus tego klienta. Wskazówki, jak pobrać to pole, znajdziesz w przewodniku zarządzania konwersjami dla początkujących.

   • recommendation_types: ustaw wartość [SITELINK_ASSET, MAXIMIZE_CLICKS_OPT_IN].

   • advertising_channel_type: ustaw wartość PERFORMANCE_MAX.

   • customer_id: ustaw identyfikator klienta tworzącego kampanię.

4. Możesz skorzystać z rekomendacji dostępnych w interfejsie GenerateRecommendationsResponse (w tym przypadku w językach SitelinkAssetRecommendation i MaximizeClicksOptInRecommendation), a potem zaproponować je użytkownikowi, wyświetlając je w interfejsie tworzenia kampanii. Jeśli użytkownik zaakceptuje sugestię, możesz ją uwzględnić w prośbie o utworzenie kampanii, gdy tylko zakończy proces tworzenia kampanii.