Zarządzanie konwersjami

W Google Ads konwersja to wartościowe działanie użytkownika, np. zakup produktu, przesłanie formularza kontaktowego, zadzwonienie do firmy lub wizyta w sklepie stacjonarnym, które następuje po interakcji z reklamą. Śledzenie konwersji mierzy te interakcje klientów, dzięki czemu możesz oceniać skuteczność kampanii i optymalizować automatyczne określanie stawek.

Interfejs Google Ads API umożliwia programowe konfigurowanie działań powodujących konwersję, importowanie zdarzeń konwersji offline, ulepszanie i dostosowywanie zarejestrowanych konwersji, grupowanie działań w cele związane z określaniem stawek i cyklem życia oraz monitorowanie diagnostyki przesyłania.

Wybieranie procesu konwersji

Na podstawie poniższej tabeli określ ConversionActionType, usługę interfejsu API i przewodnik po implementacji dla Twojego przypadku użycia:

Zadanie Typ działania powodującego konwersję Usługa lub zasób interfejsu API Przewodnik po implementacji
Sprawdzanie zakładania konta i tworzenie działania powodującego konwersję UPLOAD_CLICKS, WEBPAGE, UPLOAD_CALLS, AD_CALL, WEBSITE_CALL, GOOGLE_PLAY_DOWNLOAD, GOOGLE_PLAY_IN_APP_PURCHASE Customer (ConversionTrackingSetting), ConversionActionService Pierwsze kroki i Kategorie działań powodujących konwersję
Importowanie konwersji offline po kliknięciu lub konwersji rozszerzonych dotyczących potencjalnych klientów UPLOAD_CLICKS ConversionUploadService.UploadClickConversions (lub Data Manager API w przypadku nowych integracji) Importowanie konwersji offline po kliknięciu
Ulepszanie konwersji online (konwersje rozszerzone w kampaniach internetowych) WEBPAGE ConversionAdjustmentUploadService.UploadConversionAdjustments (ENHANCEMENT) Importowanie konwersji po kliknięciu online
Importowanie konwersji telefonicznych UPLOAD_CALLS ConversionUploadService.UploadCallConversions Importowanie konwersji telefonicznych
Importowanie transakcji sprzedaży w sklepie STORE_SALES, STORE_SALES_DIRECT_UPLOAD OfflineUserDataJobService (lub interfejs Data Manager API) Importowanie konwersji polegających na sprzedaży w sklepie stacjonarnym
Wycofywanie i ponowne określanie zarejestrowanych konwersji UPLOAD_CLICKS, WEBPAGE, SALESFORCE (wycofany) ConversionAdjustmentUploadService.UploadConversionAdjustments (RETRACTION, RESTATEMENT) Dostosowywanie konwersji po zaimportowaniu
Dołączanie do konwersji metadanych tagów niestandardowych UPLOAD_CLICKS, UPLOAD_CALLS, WEBPAGE ConversionCustomVariableService Niestandardowe zmienne konwersji
Konfigurowanie celów określania stawek, celów związanych z cyklem życia i reguł wartości Cele na poziomie konta, kampanii i cyklu życia CustomerConversionGoalService, CampaignConversionGoalService, CustomConversionGoalService, ConversionGoalCampaignConfigService, GoalService, CampaignGoalConfigService, ConversionValueRuleService Cele konwersji, cele związane z cyklem życia i reguły wartości konwersji
Monitorowanie stanu importu i diagnostyka błędów UPLOAD_CLICKS, WEBPAGE, UPLOAD_CALLS offline_conversion_upload_client_summary, offline_conversion_upload_conversion_action_summary Monitorowanie diagnostyki danych offline
Wykonywanie zapytań o dane konwersji i rozwiązywanie problemów z błędami Wszystkie typy konwersji GoogleAdsService.SearchStream (customer, campaign, conversion_action) Pobieranie statystyk konwersji i rozwiązywanie problemów z importowaniem konwersji

Pełny cykl życia konwersji

Pełna integracja zarządzania konwersjami w interfejsie Google Ads API składa się z 4 etapów:

  1. Sprawdź zakładanie konta i utwórz działania powodujące konwersję: prześlij zapytanie Customer.conversion_tracking_setting, aby potwierdzić efektywne konto konwersji (google_ads_conversion_customer), sprawdzić, czy śledzenie konwersji jest aktywne, skonfigurować zgodę użytkownika i utworzyć ConversionAction z docelowym ConversionActionType i ConversionActionCategory.
  2. Importowanie zdarzeń konwersji: przesyłaj strumieniowo konwersje offline polegające na kliknięciu lub konwersje telefoniczne, korzystając z zasobu ConversionUploadService z polem partial_failure ustawionym na true, uzupełniaj konwersje w witrynie o korekty ENHANCEMENT, korzystając z zasobu ConversionAdjustmentUploadService, lub przesyłaj zbiorczo dane o sprzedaży w sklepie, korzystając z zasobu OfflineUserDataJobService.
  3. Dostosowywanie i optymalizowanie konwersji: wycofuj lub ponownie podawaj zarejestrowane konwersje za pomocą ConversionAdjustmentUploadService, dołączaj metadane ConversionCustomVariable, stosuj reguły wartości konwersji oraz porządkuj działania według celów konwersji i celów związanych z cyklem życia, aby kontrolować optymalizację określania stawek.
  4. Monitorowanie danych diagnostycznych i raportowanie skuteczności: wysyłaj zapytania do offline_conversion_upload_client_summary i offline_conversion_upload_conversion_action_summary, aby sprawdzać stan przetwarzania przesłanych danych i alerty o częściowych niepowodzeniach. Wyślij zapytanie do zasobów customer lub campaign (opcjonalnie posegmentowanych według pola segments.conversion_action), aby porównać dane metrics.conversions i metrics.all_conversions, albo wyślij zapytanie do zasobu conversion_action, aby sprawdzić dane metrics.all_conversions i sygnatury czasowe ostatniej konwersji.

Krótki przewodnik: sprawdzanie konfiguracji, tworzenie działań i sprawdzanie stanu

Poniższe przykłady pokazują 3 najczęstsze zapytania i mutacje potrzebne do inicjowania i monitorowania śledzenia konwersji.

1. Weryfikowanie ustawień śledzenia konwersji za pomocą GAQL

Zanim utworzysz ConversionAction lub prześlesz zdarzenia, wyślij zapytanie do zasobu customer, używając GoogleAdsService.SearchStream, aby określić, które konto zarządza konwersjami (google_ads_conversion_customer), czy zaakceptowano warunki dotyczące danych klientów i czy konwersje rozszerzone na poziomie konta są włączone (EnhancedConversionsConfig):

SELECT
  customer.conversion_tracking_setting.conversion_tracking_id,
  customer.conversion_tracking_setting.conversion_tracking_status,
  customer.conversion_tracking_setting.cross_account_conversion_tracking_id,
  customer.conversion_tracking_setting.google_ads_conversion_customer,
  customer.conversion_tracking_setting.accepted_customer_data_terms,
  customer.conversion_tracking_setting.enablement_setting,
  customer.conversion_tracking_setting.effective_enablement_setting
FROM customer

Wyodrębnij {customer_id} z nazwy zasobu customers/{customer_id} zwróconej w google_ads_conversion_customer i wyślij wszystkie kolejne żądania ConversionActionService i ConversionUploadService do tego identyfikatora klienta. Szczegółowe informacje o konfiguracji i hierarchii kont znajdziesz w artykule Pierwsze kroki.

2. Utwórz działanie powodujące konwersję

Użyj ConversionActionService.MutateConversionActions, aby utworzyć ConversionAction. Ten przykład tworzy działanie powodujące konwersję UPLOAD_CLICKS z niestandardową wartością i ustawieniami okresu ważności:

Java

private void runExample(GoogleAdsClient googleAdsClient, long customerId) {

  // Creates a ConversionAction.
  ConversionAction conversionAction =
      ConversionAction.newBuilder()
          // Note that conversion action names must be unique. If a conversion action already
          // exists with the specified conversion_action_name the create operation will fail with
          // a ConversionActionError.DUPLICATE_NAME error.
          .setName("Earth to Mars Cruises Conversion #" + getPrintableDateTime())
          .setCategory(ConversionActionCategory.DEFAULT)
          .setType(ConversionActionType.WEBPAGE)
          .setStatus(ConversionActionStatus.ENABLED)
          .setViewThroughLookbackWindowDays(15L)
          .setValueSettings(
              ValueSettings.newBuilder()
                  .setDefaultValue(23.41)
                  .setAlwaysUseDefaultValue(true)
                  .build())
          .build();

  // Creates the operation.
  ConversionActionOperation operation =
      ConversionActionOperation.newBuilder().setCreate(conversionAction).build();

  try (ConversionActionServiceClient conversionActionServiceClient =
      googleAdsClient.getLatestVersion().createConversionActionServiceClient()) {
    MutateConversionActionsResponse response =
        conversionActionServiceClient.mutateConversionActions(
            Long.toString(customerId), Collections.singletonList(operation));
    System.out.printf("Added %d conversion actions:%n", response.getResultsCount());
    for (MutateConversionActionResult result : response.getResultsList()) {
      System.out.printf(
          "New conversion action added with resource name: '%s'%n", result.getResourceName());
    }
  }
}

C#

public void Run(GoogleAdsClient client, long customerId)
{
    // Get the ConversionActionService.
    ConversionActionServiceClient conversionActionService =
        client.GetService(Services.V26.ConversionActionService);

    // Note that conversion action names must be unique.
    // If a conversion action already exists with the specified name the create operation
    // will fail with a ConversionAction.DUPLICATE_NAME error.
    string ConversionActionName = "Earth to Mars Cruises Conversion #"
        + ExampleUtilities.GetRandomString();

    // Add a conversion action.
    ConversionAction conversionAction = new ConversionAction()
    {
        Name = ConversionActionName,
        Category = ConversionActionCategory.Default,
        Type = ConversionActionType.Webpage,
        Status = ConversionActionStatus.Enabled,
        ViewThroughLookbackWindowDays = 15,
        ValueSettings = new ConversionAction.Types.ValueSettings()
        {
            DefaultValue = 23.41,
            AlwaysUseDefaultValue = true
        }
    };

    // Create the operation.
    ConversionActionOperation operation = new ConversionActionOperation()
    {
        Create = conversionAction
    };

    try
    {
        // Create the conversion action.
        MutateConversionActionsResponse response =
            conversionActionService.MutateConversionActions(customerId.ToString(),
                    new ConversionActionOperation[] { operation });

        // Display the results.
        foreach (MutateConversionActionResult newConversionAction in response.Results)
        {
            Console.WriteLine($"New conversion action with resource name = " +
                $"'{newConversionAction.ResourceName}' was added.");
        }
    }
    catch (GoogleAdsException e)
    {
        Console.WriteLine("Failure:");
        Console.WriteLine($"Message: {e.Message}");
        Console.WriteLine($"Failure: {e.Failure}");
        Console.WriteLine($"Request ID: {e.RequestId}");
        throw;
    }
}

PHP

    public static function runExample(GoogleAdsClient $googleAdsClient, int $customerId)
    {
        // Creates a conversion action.
        $conversionAction = new ConversionAction(
            [
            // Note that conversion action names must be unique.
            // If a conversion action already exists with the specified conversion_action_name
            // the create operation will fail with a ConversionActionError.DUPLICATE_NAME error.
            'name' => 'Earth to Mars Cruises Conversion #' . Helper::getPrintableDatetime(),
            'category' => ConversionActionCategory::PBDEFAULT,
            'type' => ConversionActionType::WEBPAGE,
            'status' => ConversionActionStatus::ENABLED,
            'view_through_lookback_window_days' => 15,
            'value_settings' => new ValueSettings(
                [
                'default_value' => 23.41,
                'always_use_default_value' => true
                ]
            )
            ]
        );

        // Creates a conversion action operation.
        $conversionActionOperation = new ConversionActionOperation();
        $conversionActionOperation->setCreate($conversionAction);

        // Issues a mutate request to add the conversion action.
        $conversionActionServiceClient = $googleAdsClient->getConversionActionServiceClient();
        $response = $conversionActionServiceClient->mutateConversionActions(
            MutateConversionActionsRequest::build($customerId, [$conversionActionOperation])
        );

        printf("Added %d conversion actions:%s", $response->getResults()->count(), PHP_EOL);

        foreach ($response->getResults() as $addedConversionAction) {
            /**
 * @var ConversionAction $addedConversionAction
*/
            printf(
                "New conversion action added with resource name: '%s'%s",
                $addedConversionAction->getResourceName(),
                PHP_EOL
            );
        }
    }

Python

def main(client: GoogleAdsClient, customer_id: str) -> None:
    conversion_action_service: ConversionActionServiceClient = (
        client.get_service("ConversionActionService")
    )

    # Create the operation.
    conversion_action_operation: ConversionActionOperation = client.get_type(
        "ConversionActionOperation"
    )

    # Create conversion action.
    conversion_action: ConversionAction = conversion_action_operation.create

    # Note that conversion action names must be unique. If a conversion action
    # already exists with the specified conversion_action_name, the create
    # operation will fail with a ConversionActionError.DUPLICATE_NAME error.
    conversion_action.name = f"Earth to Mars Cruises Conversion {uuid.uuid4()}"
    conversion_action.type_ = (
        client.enums.ConversionActionTypeEnum.UPLOAD_CLICKS
    )
    conversion_action.category = (
        client.enums.ConversionActionCategoryEnum.DEFAULT
    )
    conversion_action.status = client.enums.ConversionActionStatusEnum.ENABLED
    conversion_action.view_through_lookback_window_days = 15

    # Create a value settings object.
    value_settings: ConversionAction.ValueSettings = (
        conversion_action.value_settings
    )
    value_settings.default_value = 15.0
    value_settings.always_use_default_value = True

    # Add the conversion action.
    conversion_action_response: MutateConversionActionsResponse = (
        conversion_action_service.mutate_conversion_actions(
            customer_id=customer_id,
            operations=[conversion_action_operation],
        )
    )

    print(
        "Created conversion action "
        f'"{conversion_action_response.results[0].resource_name}".'
    )

Ruby

def add_conversion_action(customer_id)
  # GoogleAdsClient will read a config file from
  # ENV['HOME']/google_ads_config.rb when called without parameters
  client = Google::Ads::GoogleAds::GoogleAdsClient.new


  # Add a conversion action.
  conversion_action = client.resource.conversion_action do |ca|
    ca.name = "Earth to Mars Cruises Conversion #{(Time.new.to_f * 100).to_i}"
    ca.type = :UPLOAD_CLICKS
    ca.category = :DEFAULT
    ca.status = :ENABLED
    ca.view_through_lookback_window_days = 15

    # Create a value settings object.
    ca.value_settings = client.resource.value_settings do |vs|
      vs.default_value = 15
      vs.always_use_default_value = true
    end
  end

  # Create the operation.
  conversion_action_operation = client.operation.create_resource.conversion_action(conversion_action)

  # Add the ad group ad.
  response = client.service.conversion_action.mutate_conversion_actions(
    customer_id: customer_id,
    operations: [conversion_action_operation],
  )

  puts "New conversion action with resource name = #{response.results.first.resource_name}."
end

Perl

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

  # Note that conversion action names must be unique.
  # If a conversion action already exists with the specified conversion_action_name,
  # the create operation fails with error ConversionActionError.DUPLICATE_NAME.
  my $conversion_action_name = "Earth to Mars Cruises Conversion #" . uniqid();

  # Create a conversion action.
  my $conversion_action =
    Google::Ads::GoogleAds::V26::Resources::ConversionAction->new({
      name                          => $conversion_action_name,
      category                      => DEFAULT,
      type                          => WEBPAGE,
      status                        => ENABLED,
      viewThroughLookbackWindowDays => 15,
      valueSettings                 =>
        Google::Ads::GoogleAds::V26::Resources::ValueSettings->new({
          defaultValue          => 23.41,
          alwaysUseDefaultValue => "true"
        })});

  # Create a conversion action operation.
  my $conversion_action_operation =
    Google::Ads::GoogleAds::V26::Services::ConversionActionService::ConversionActionOperation
    ->new({create => $conversion_action});

  # Add the conversion action.
  my $conversion_actions_response =
    $api_client->ConversionActionService()->mutate({
      customerId => $customer_id,
      operations => [$conversion_action_operation]});

  printf "New conversion action added with resource name: '%s'.\n",
    $conversion_actions_response->{results}[0]{resourceName};

  return 1;
}

curl

Żądanie REST

Aby utworzyć ten sam zasób ConversionAction za pomocą REST, wyślij żądanie POST do ConversionActionService.MutateConversionActions:

POST https://googleads.googleapis.com/v26/customers/{customer_id}/conversionActions:mutate

{
  "operations": [
    {
      "create": {
        "name": "Earth to Mars Cruise Conversion",
        "type": "UPLOAD_CLICKS",
        "category": "DEFAULT",
        "status": "ENABLED",
        "primaryForGoal": true,
        "countingType": "ONE_PER_CLICK",
        "clickThroughLookbackWindowDays": "60",
        "valueSettings": {
          "defaultValue": 23.41,
          "defaultCurrencyCode": "USD",
          "alwaysUseDefaultValue": true
        }
      }
    }
  ]
}

Gdy działanie powodujące konwersję ma stan ENABLED, zaimportuj zdarzenia konwersji lub ulepszenia, korzystając z procesu odpowiedniego dla źródła konwersji (patrz Importowanie zdarzeń konwersji).

3. Monitorowanie stanu przesyłania konwersji offline

Po przesłaniu konwersji po kliknięciu, konwersji telefonicznych lub korekt konwersji wyślij zapytanie offline_conversion_upload_client_summary, aby sprawdzić ogólny stan zadania, wskaźniki powodzenia i oczekiwania oraz zestawienia błędów w ostatnich przesłanych plikach:

SELECT
  offline_conversion_upload_client_summary.client,
  offline_conversion_upload_client_summary.status,
  offline_conversion_upload_client_summary.total_event_count,
  offline_conversion_upload_client_summary.successful_event_count,
  offline_conversion_upload_client_summary.success_rate,
  offline_conversion_upload_client_summary.pending_event_count,
  offline_conversion_upload_client_summary.pending_rate,
  offline_conversion_upload_client_summary.last_upload_date_time,
  offline_conversion_upload_client_summary.alerts
FROM offline_conversion_upload_client_summary

Aby uzyskać diagnostykę na poziomie działania powodującego konwersję, wyślij zapytanie do offline_conversion_upload_conversion_action_summary (zobacz Monitorowanie diagnostyki danych offline). Aby rozwiązać problemy z konkretnymi kodami błędów, zapoznaj się z artykułem Rozwiązywanie problemów z importowaniem konwersji.

Katalog przewodników według etapu cyklu życia

Zapoznaj się z pełnym zestawem przewodników po zarządzaniu konwersjami uporządkowanych według etapu cyklu życia:

1. Zakładanie konta i działania powodujące konwersję

  • Kategorie działań powodujących konwersję: wybierz odpowiednie źródło konwersji – witrynę (WEBPAGE), połączenie telefoniczne (UPLOAD_CALLS, AD_CALL, WEBSITE_CALL), aplikację mobilną (GOOGLE_PLAY_DOWNLOAD, GOOGLE_PLAY_IN_APP_PURCHASE, Firebase, SKAdNetwork), Google Analytics 4 (GOOGLE_ANALYTICS_4_CUSTOM, GOOGLE_ANALYTICS_4_PURCHASE), offline (UPLOAD_CLICKS) lub sklep stacjonarny (STORE_SALES) – i przypisz je do odpowiedniego ConversionActionType i procesu API.
  • Pierwsze kroki: skonfiguruj zgodę użytkownika, zweryfikuj ConversionTrackingSetting, skonfiguruj śledzenie konwersji dla wielu kont i utwórz działania powodujące konwersję za pomocą bibliotek klienta lub interfejsu REST.

2. Importowanie zdarzeń konwersji

3. Dostosowywanie i optymalizowanie konwersji

4. Monitorowanie, raportowanie i rozwiązywanie problemów

Dalej
Kategorie działań powodujących konwersję