Gestion des conversions

Dans Google Ads, une conversion est une action intéressante effectuée par un utilisateur (par exemple, l'achat d'un produit, l'envoi d'un formulaire de lead, l'appel de votre entreprise ou la visite d'un magasin physique) après avoir interagi avec une annonce. Le suivi des conversions mesure ces interactions client pour vous permettre d'évaluer les performances de vos campagnes et d'optimiser les enchères automatiques.

L'API Google Ads vous permet de configurer de manière programmatique des actions de conversion, d'importer des événements de conversion hors connexion, d'améliorer ou d'ajuster les conversions enregistrées, de regrouper des actions en objectifs d'enchères et de cycle de vie, et de surveiller les diagnostics d'importation.

Choisissez votre workflow de conversion

Utilisez le tableau suivant pour identifier l'ConversionActionType, le service d'API et le guide d'implémentation correspondant à votre cas d'utilisation :

Tâche Type d'action de conversion Service ou ressource d'API Guide d'implémentation
Vérifier la configuration du compte et créer une action de conversion UPLOAD_CLICKS, WEBPAGE, UPLOAD_CALLS, AD_CALL, WEBSITE_CALL, GOOGLE_PLAY_DOWNLOAD, GOOGLE_PLAY_IN_APP_PURCHASE Customer (ConversionTrackingSetting), ConversionActionService Premiers pas et Catégories d'actions de conversion
Importer des conversions par clic hors connexion ou le suivi avancé des conversions pour les prospects UPLOAD_CLICKS ConversionUploadService.UploadClickConversions (ou l'API Data Manager pour les nouvelles intégrations) Importer des conversions par clic hors connexion
Améliorer les conversions en ligne (suivi avancé des conversions pour le Web) WEBPAGE ConversionAdjustmentUploadService.UploadConversionAdjustments (ENHANCEMENT) Importer des conversions par clic en ligne
Importer des conversions par appel téléphonique UPLOAD_CALLS ConversionUploadService.UploadCallConversions Importer des conversions par appel
Importer les transactions de ventes en magasin STORE_SALES, STORE_SALES_DIRECT_UPLOAD OfflineUserDataJobService (ou API Data Manager) Importer des conversions de vente en magasin
Retirer ou reformuler des conversions enregistrées UPLOAD_CLICKS, WEBPAGE, SALESFORCE (obsolète) ConversionAdjustmentUploadService.UploadConversionAdjustments (RETRACTION, RESTATEMENT) Ajuster les conversions après l'importation
Associer des métadonnées de tag personnalisé aux conversions UPLOAD_CLICKS, UPLOAD_CALLS, WEBPAGE ConversionCustomVariableService Variables de conversion personnalisées
Configurer les objectifs d'enchères, les objectifs de cycle de vie et les règles de valeur Objectifs de compte, de campagne et de cycle de vie CustomerConversionGoalService, CampaignConversionGoalService, CustomConversionGoalService, ConversionGoalCampaignConfigService, GoalService, CampaignGoalConfigService, ConversionValueRuleService Objectifs de conversion, objectifs de cycle de vie et règles de valeur de conversion
Surveiller l'état de l'importation et les diagnostics d'erreur UPLOAD_CLICKS, WEBPAGE, UPLOAD_CALLS offline_conversion_upload_client_summary, offline_conversion_upload_conversion_action_summary Surveiller les diagnostics des données hors connexion
Interroger les métriques de conversion et résoudre les erreurs Tous les types de conversion GoogleAdsService.SearchStream (customer, campaign, conversion_action) Récupérer les statistiques de conversion et Résoudre les problèmes d'importation des conversions

Cycle de vie des conversions de bout en bout

Une intégration complète de la gestion des conversions dans l'API Google Ads se déroule en quatre étapes :

  1. Vérifier la configuration du compte et créer des actions de conversion : interrogez Customer.conversion_tracking_setting pour confirmer le compte de conversion effectif (google_ads_conversion_customer), vérifiez que le suivi des conversions est actif, configurez le consentement utilisateur et créez un ConversionAction avec la cible ConversionActionType et ConversionActionCategory.
  2. Importer des événements de conversion : diffusez des conversions par clic ou par appel hors connexion à l'aide de ConversionUploadService avec partial_failure défini sur true, complétez les conversions sur le site Web avec des ajustements ENHANCEMENT à l'aide de ConversionAdjustmentUploadService ou importez de manière groupée les ventes en magasin à l'aide de OfflineUserDataJobService.
  3. Ajuster et optimiser les conversions : retirez ou reformulez les conversions enregistrées à l'aide de ConversionAdjustmentUploadService, associez des métadonnées ConversionCustomVariable, appliquez des règles de valeur de conversion et organisez les actions en objectifs de conversion et objectifs de cycle de vie pour contrôler l'optimisation des enchères.
  4. Surveiller les diagnostics et les performances des rapports : interrogez offline_conversion_upload_client_summary et offline_conversion_upload_conversion_action_summary pour inspecter l'état du traitement de l'importation et les alertes d'échec partiel. Interrogez les ressources customer ou campaign (éventuellement segmentées par segments.conversion_action) pour comparer les métriques metrics.conversions et metrics.all_conversions, ou interrogez la ressource conversion_action pour inspecter metrics.all_conversions et les codes temporels de la dernière conversion.

Guide de démarrage rapide : Vérifier la configuration, créer des actions et vérifier l'état

Les exemples suivants montrent les trois requêtes et mutations les plus courantes nécessaires pour initialiser et surveiller le suivi des conversions.

1. Vérifier les paramètres de suivi des conversions avec GAQL

Avant de créer un ConversionAction ou d'importer des événements, interrogez la ressource customer à l'aide de GoogleAdsService.SearchStream pour déterminer quel compte gère les conversions (google_ads_conversion_customer), si les conditions d'utilisation des données client sont acceptées et si le suivi avancé des conversions au niveau du compte est activé (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

Extrayez le {customer_id} du nom de ressource customers/{customer_id} renvoyé dans google_ads_conversion_customer, puis envoyez toutes les requêtes ConversionActionService et ConversionUploadService ultérieures à ce numéro client. Pour en savoir plus sur la configuration complète et la hiérarchie multicompte, consultez Premiers pas.

2. Créer une action de conversion

Utilisez ConversionActionService.MutateConversionActions pour créer un ConversionAction. L'exemple suivant crée une action de conversion UPLOAD_CLICKS avec des paramètres de valeur et de période d'analyse personnalisés :

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

Requête REST

Pour créer le même ConversionAction via REST, envoyez une requête POST à 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
        }
      }
    }
  ]
}

Une fois votre action de conversion ENABLED, importez des événements de conversion ou des améliorations à l'aide du workflow de votre source de conversion (voir Importer des événements de conversion).

3. Surveiller l'état de l'importation des conversions hors connexion

Après avoir importé des conversions par clic, des conversions par appel ou des ajustements de conversion, interrogez offline_conversion_upload_client_summary pour vérifier l'état global du job, les taux de réussite et d'attente, ainsi que la répartition des erreurs dans vos importations récentes :

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

Interrogez offline_conversion_upload_conversion_action_summary pour obtenir des diagnostics au niveau de l'action de conversion (consultez Surveiller les diagnostics des données hors connexion) et consultez Résoudre les problèmes d'importation de conversions pour résoudre des codes d'erreur spécifiques.

Répertoire des guides par étape du cycle de vie

Découvrez l'ensemble des guides de gestion des conversions, organisés par étape du cycle de vie :

1. Configuration du compte et actions de conversion

  • Catégories d'actions de conversion : sélectionnez la bonne source de conversion (site Web (WEBPAGE), appel téléphonique (UPLOAD_CALLS, AD_CALL, WEBSITE_CALL), application mobile (GOOGLE_PLAY_DOWNLOAD, GOOGLE_PLAY_IN_APP_PURCHASE, Firebase, SKAdNetwork), Google Analytics 4 (GOOGLE_ANALYTICS_4_CUSTOM, GOOGLE_ANALYTICS_4_PURCHASE), hors connexion (UPLOAD_CLICKS) ou magasin physique (STORE_SALES)) et mappez-la au ConversionActionType et au workflow d'API correspondants.
  • Premiers pas : configurez le consentement utilisateur, validez ConversionTrackingSetting, configurez le suivi des conversions multicomptes et créez des actions de conversion à l'aide des bibliothèques clientes ou de REST.

2. Importer des événements de conversion

3. Ajuster et optimiser les conversions

4. Surveiller, signaler et résoudre les problèmes

Suivant
Catégories d'actions de conversion