4.1.5 Suivi des conversions

Valeur et impact commercial

Afin de fournir efficacement les puissants outils d'analyse et de machine learning de l'écosystème Google pour les campagnes publicitaires de vos clients marchands, vous devez placer des balises de suivi des conversions et de remarketing sur les sites Web de vos clients.

Une conversion dans Google Ads se produit lorsqu'un utilisateur effectue une action spécifique après avoir cliqué sur une annonce (par exemple, acheter un produit, installer une application mobile ou s'inscrire à une liste de diffusion). Le suivi des conversions fournit des informations clés sur les actions des utilisateurs après avoir vu une annonce ou cliqué dessus, y compris des informations permettant de calculer et de comparer le retour sur investissement (ROI) afin d'aider vos clients à décider où concentrer leurs dépenses publicitaires. Le suivi permet également de s'assurer que les données sont disponibles pour le rapprochement. Les commandes varient selon le produit ou la catégorie. Le suivi des conversions peut donc également vous aider à déterminer comment des groupes de fiches spécifiques génèrent des ventes.

Un objectif de conversion est un groupe d'actions de conversion ayant le même objectif sous-jacent. Par exemple, "Achat" peut être un objectif de conversion avec des actions de conversion "Achats sur le site Web" et "Ventes en magasin".

Les actions de conversion sont toujours utilisées pour suivre les conversions et optimiser la campagne. Vous créez des actions de conversion, puis Google les regroupe dans les objectifs de conversion.

Action de conversion d'achat

La mise en œuvre du suivi des conversions décrit ici permet au compte Google Ads de votre marchand de mesurer le nombre de conversions d'achat et leur valeur. Sans le suivi des conversions, vous ne pouvez pas mesurer la valeur commerciale générée par la campagne en termes de ROAS (retour sur les dépenses publicitaires). Il envoie également des signaux de données supplémentaires qui permettent à la campagne d'optimiser les performances.

Autres actions de conversion

Bien que l'action de conversion d'achat ne soit requise que, le suivi d'actions de conversion supplémentaires peut fournir des insights supplémentaires à vos marchands. Nous vous recommandons de consigner autant que possible, tout en implémentant un maximum d'actions de conversion principales. La liste complète des actions de conversion recommandées est décrite dans la section "Tech API Guidelines".

En général, nous vous recommandons de recueillir les informations suivantes:

  • Tout événement réussi directement associé à la valeur
  • Événements de réussite qui contribuent aux conversions principales, tels que add_to_cart et sign_up.
  • Engagements et interactions des utilisateurs qui aident les annonceurs à comprendre comment ils s'engagent auprès de leurs utilisateurs finaux

Les actions de conversion secondaires ne sont utilisées que pour l'observation et le reporting.Elles ont une incidence sur les enchères.En savoir plus sur les actions de conversion principales et secondaires

Conseils sur l'expérience utilisateur

Pour réduire le risque d'erreurs, nous vous recommandons d'implémenter le suivi des conversions de façon programmatique, sans intervention du marchand. Toutefois, vous devez vous assurer que vos marchands savent que le suivi des conversions a été configuré.

Lorsque les marchands associent un compte Ads existant, nous vous recommandons d'afficher une notification indiquant que le suivi des conversions est peut-être déjà configuré pour ce compte, car il peut y avoir des conflits à résoudre. Vous trouverez un exemple ci-dessous.

connect_your_google_ads_account

Conseils techniques

Voici comment fonctionne le suivi des conversions. Cette section détaille chaque étape:

  1. Vous créez une ConversionAction dans le compte Ads de votre marchand pour suivre les achats (et éventuellement d'autres actions des clients) effectués sur son site Web.

  2. Vous ajoutez la balise (ou extrait de code) de cette action de conversion à un site Web ou à une application mobile. Pour en savoir plus, consultez Configurer le suivi des conversions pour votre site Web.

  3. Lorsqu'un client clique sur l'annonce, un cookie temporaire est placé sur son ordinateur ou appareil mobile.

  4. Lorsque l'utilisateur effectue l'action définie pour l'annonceur, Google reconnaît le cookie (grâce à l'extrait de code ajouté) et enregistre une conversion avec d'autres paramètres tels que "value", le cas échéant.

Prérequis

Avant de commencer, assurez-vous de disposer d'un ID de développeur de balise Google. Si vous ne disposez pas d'un ID de développeur de balise Google, remplissez le formulaire de demande d'ID de développeur de balise Google. Votre ID de développeur est différent des autres ID, tels que l'ID de mesure ou l'ID de conversion, que vos utilisateurs finaux ajoutent au code de mesure de leur site Web.

Créer et configurer des actions de conversion

Les exemples suivants montrent comment créer une action de conversion et l'ajouter à un compte Ads. Chaque exemple gère pour vous toutes les tâches d'authentification en arrière-plan et vous explique comment créer une action de conversion:

Java

// Copyright 2018 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package com.google.ads.googleads.examples.remarketing;

import static com.google.ads.googleads.examples.utils.CodeSampleHelper.getPrintableDateTime;

import com.beust.jcommander.Parameter;
import com.google.ads.googleads.examples.utils.ArgumentNames;
import com.google.ads.googleads.examples.utils.CodeSampleParams;
import com.google.ads.googleads.lib.GoogleAdsClient;
import com.google.ads.googleads.v17.enums.ConversionActionCategoryEnum.ConversionActionCategory;
import com.google.ads.googleads.v17.enums.ConversionActionStatusEnum.ConversionActionStatus;
import com.google.ads.googleads.v17.enums.ConversionActionTypeEnum.ConversionActionType;
import com.google.ads.googleads.v17.errors.GoogleAdsError;
import com.google.ads.googleads.v17.errors.GoogleAdsException;
import com.google.ads.googleads.v17.resources.ConversionAction;
import com.google.ads.googleads.v17.resources.ConversionAction.ValueSettings;
import com.google.ads.googleads.v17.services.ConversionActionOperation;
import com.google.ads.googleads.v17.services.ConversionActionServiceClient;
import com.google.ads.googleads.v17.services.MutateConversionActionResult;
import com.google.ads.googleads.v17.services.MutateConversionActionsResponse;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Collections;

/** Adds a conversion action. */
public class AddConversionAction {

  private static class AddConversionActionParams extends CodeSampleParams {

    @Parameter(names = ArgumentNames.CUSTOMER_ID, required = true)
    private Long customerId;
  }

  public static void main(String[] args) {
    AddConversionActionParams params = new AddConversionActionParams();
    if (!params.parseArguments(args)) {

      // Either pass the required parameters for this example on the command line, or insert them
      // into the code here. See the parameter class definition above for descriptions.
      params.customerId = Long.parseLong("INSERT_CUSTOMER_ID_HERE");
    }

    GoogleAdsClient googleAdsClient = null;
    try {
      googleAdsClient = GoogleAdsClient.newBuilder().fromPropertiesFile().build();
    } catch (FileNotFoundException fnfe) {
      System.err.printf(
          "Failed to load GoogleAdsClient configuration from file. Exception: %s%n", fnfe);
      System.exit(1);
    } catch (IOException ioe) {
      System.err.printf("Failed to create GoogleAdsClient. Exception: %s%n", ioe);
      System.exit(1);
    }

    try {
      new AddConversionAction().runExample(googleAdsClient, params.customerId);
    } catch (GoogleAdsException gae) {
      // GoogleAdsException is the base class for most exceptions thrown by an API request.
      // Instances of this exception have a message and a GoogleAdsFailure that contains a
      // collection of GoogleAdsErrors that indicate the underlying causes of the
      // GoogleAdsException.
      System.err.printf(
          "Request ID %s failed due to GoogleAdsException. Underlying errors:%n",
          gae.getRequestId());
      int i = 0;
      for (GoogleAdsError googleAdsError : gae.getGoogleAdsFailure().getErrorsList()) {
        System.err.printf("  Error %d: %s%n", i++, googleAdsError);
      }
      System.exit(1);
    }
  }

  /**
   * Runs the example.
   *
   * @param googleAdsClient the Google Ads API client.
   * @param customerId the client customer ID.
   * @throws GoogleAdsException if an API request failed with one or more service errors.
   */
  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());
      }
    }
  }
}

AddConversionAction.java

C#

// Copyright 2019 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

using CommandLine;
using Google.Ads.Gax.Examples;
using Google.Ads.GoogleAds.Lib;
using Google.Ads.GoogleAds.V17.Errors;
using Google.Ads.GoogleAds.V17.Resources;
using Google.Ads.GoogleAds.V17.Services;
using System;
using static Google.Ads.GoogleAds.V17.Enums.ConversionActionCategoryEnum.Types;
using static Google.Ads.GoogleAds.V17.Enums.ConversionActionStatusEnum.Types;
using static Google.Ads.GoogleAds.V17.Enums.ConversionActionTypeEnum.Types;

namespace Google.Ads.GoogleAds.Examples.V17
{
    /// <summary>
    /// This code example illustrates adding a conversion action.
    /// </summary>
    public class AddConversionAction : ExampleBase
    {
        /// <summary>
        /// Command line options for running the <see cref="AddConversionAction"/> example.
        /// </summary>
        public class Options : OptionsBase
        {
            /// <summary>
            /// The Google Ads customer ID for which the conversion action is added.
            /// </summary>
            [Option("customerId", Required = true, HelpText =
                "The Google Ads customer ID for which the conversion action is added.")]
            public long CustomerId { get; set; }
        }

        /// <summary>
        /// Main method, to run this code example as a standalone application.
        /// </summary>
        /// <param name="args">The command line arguments.</param>
        public static void Main(string[] args)
        {
            Options options = ExampleUtilities.ParseCommandLine<Options>(args);

            AddConversionAction codeExample = new AddConversionAction();
            Console.WriteLine(codeExample.Description);
            codeExample.Run(new GoogleAdsClient(), options.CustomerId);
        }

        /// <summary>
        /// Returns a description about the code example.
        /// </summary>
        public override string Description =>
            "This code example illustrates adding a conversion action.";

        /// <summary>
        /// Runs the code example.
        /// </summary>
        /// <param name="client">The Google Ads client.</param>
        /// <param name="customerId">The Google Ads customer ID for which the conversion action is
        /// added.</param>
        public void Run(GoogleAdsClient client, long customerId)
        {
            // Get the ConversionActionService.
            ConversionActionServiceClient conversionActionService =
                client.GetService(Services.V17.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;
            }
        }
    }
}

AddConversionAction.cs

PHP

<?php

/**
 * Copyright 2018 Google LLC
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

namespace Google\Ads\GoogleAds\Examples\Remarketing;

require __DIR__ . '/../../vendor/autoload.php';

use GetOpt\GetOpt;
use Google\Ads\GoogleAds\Examples\Utils\ArgumentNames;
use Google\Ads\GoogleAds\Examples\Utils\ArgumentParser;
use Google\Ads\GoogleAds\Examples\Utils\Helper;
use Google\Ads\GoogleAds\Lib\V17\GoogleAdsClient;
use Google\Ads\GoogleAds\Lib\V17\GoogleAdsClientBuilder;
use Google\Ads\GoogleAds\Lib\V17\GoogleAdsException;
use Google\Ads\GoogleAds\Lib\OAuth2TokenBuilder;
use Google\Ads\GoogleAds\V17\Enums\ConversionActionCategoryEnum\ConversionActionCategory;
use Google\Ads\GoogleAds\V17\Enums\ConversionActionStatusEnum\ConversionActionStatus;
use Google\Ads\GoogleAds\V17\Enums\ConversionActionTypeEnum\ConversionActionType;
use Google\Ads\GoogleAds\V17\Errors\GoogleAdsError;
use Google\Ads\GoogleAds\V17\Resources\ConversionAction;
use Google\Ads\GoogleAds\V17\Resources\ConversionAction\ValueSettings;
use Google\Ads\GoogleAds\V17\Services\ConversionActionOperation;
use Google\Ads\GoogleAds\V17\Services\MutateConversionActionsRequest;
use Google\ApiCore\ApiException;

/** This example illustrates adding a conversion action. */
class AddConversionAction
{
    private const CUSTOMER_ID = 'INSERT_CUSTOMER_ID_HERE';

    public static function main()
    {
        // Either pass the required parameters for this example on the command line, or insert them
        // into the constants above.
        $options = (new ArgumentParser())->parseCommandArguments([
            ArgumentNames::CUSTOMER_ID => GetOpt::REQUIRED_ARGUMENT
        ]);

        // Generate a refreshable OAuth2 credential for authentication.
        $oAuth2Credential = (new OAuth2TokenBuilder())->fromFile()->build();

        // Construct a Google Ads client configured from a properties file and the
        // OAuth2 credentials above.
        $googleAdsClient = (new GoogleAdsClientBuilder())
            ->fromFile()
            ->withOAuth2Credential($oAuth2Credential)
            // We set this value to true to show how to use GAPIC v2 source code. You can remove the
            // below line if you wish to use the old-style source code. Note that in that case, you
            // probably need to modify some parts of the code below to make it work.
            // For more information, see
            // https://developers.devsite.corp.google.com/google-ads/api/docs/client-libs/php/gapic.
            ->usingGapicV2Source(true)
            ->build();

        try {
            self::runExample(
                $googleAdsClient,
                $options[ArgumentNames::CUSTOMER_ID] ?: self::CUSTOMER_ID
            );
        } catch (GoogleAdsException $googleAdsException) {
            printf(
                "Request with ID '%s' has failed.%sGoogle Ads failure details:%s",
                $googleAdsException->getRequestId(),
                PHP_EOL,
                PHP_EOL
            );
            foreach ($googleAdsException->getGoogleAdsFailure()->getErrors() as $error) {
                /** @var GoogleAdsError $error */
                printf(
                    "\t%s: %s%s",
                    $error->getErrorCode()->getErrorCode(),
                    $error->getMessage(),
                    PHP_EOL
                );
            }
            exit(1);
        } catch (ApiException $apiException) {
            printf(
                "ApiException was thrown with message '%s'.%s",
                $apiException->getMessage(),
                PHP_EOL
            );
            exit(1);
        }
    }

    /**
     * Runs the example.
     *
     * @param GoogleAdsClient $googleAdsClient the Google Ads API client
     * @param int $customerId the customer ID
     */
    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
            );
        }
    }
}

AddConversionAction::main();

AddConversionAction.php

Python

#!/usr/bin/env python
# Copyright 2018 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""This example illustrates adding a conversion action."""


import argparse
import sys
import uuid

from google.ads.googleads.client import GoogleAdsClient
from google.ads.googleads.errors import GoogleAdsException


def main(client, customer_id):
    conversion_action_service = client.get_service("ConversionActionService")

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

    # Create conversion action.
    conversion_action = 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 = conversion_action.value_settings
    value_settings.default_value = 15.0
    value_settings.always_use_default_value = True

    # Add the conversion action.
    conversion_action_response = (
        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}".'
    )


if __name__ == "__main__":
    parser = argparse.ArgumentParser(
        description="Adds a conversion action for specified customer."
    )
    # The following argument(s) should be provided to run the example.
    parser.add_argument(
        "-c",
        "--customer_id",
        type=str,
        required=True,
        help="The Google Ads customer ID.",
    )
    args = parser.parse_args()

    # GoogleAdsClient will read the google-ads.yaml configuration file in the
    # home directory if none is specified.
    googleads_client = GoogleAdsClient.load_from_storage(version="v17")

    try:
        main(googleads_client, args.customer_id)
    except GoogleAdsException as ex:
        print(
            f'Request with ID "{ex.request_id}" failed with status '
            f'"{ex.error.code().name}" and includes the following errors:'
        )
        for error in ex.failure.errors:
            print(f'\tError with message "{error.message}".')
            if error.location:
                for field_path_element in error.location.field_path_elements:
                    print(f"\t\tOn field: {field_path_element.field_name}")
        sys.exit(1)

add_conversion_action.py

Ruby

#!/usr/bin/env ruby
# Encoding: utf-8
#
# Copyright 2018 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# This code example illustrates adding a conversion action.

require 'optparse'
require 'google/ads/google_ads'
require 'date'

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

if __FILE__ == $0
  options = {}
  # The following parameter(s) should be provided to run the example. You can
  # either specify these by changing the INSERT_XXX_ID_HERE values below, or on
  # the command line.
  #
  # Parameters passed on the command line will override any parameters set in
  # code.
  #
  # Running the example with -h will print the command line usage.
  options[:customer_id] = 'INSERT_CUSTOMER_ID_HERE'

  OptionParser.new do |opts|
    opts.banner = sprintf('Usage: %s [options]', File.basename(__FILE__))

    opts.separator ''
    opts.separator 'Options:'

    opts.on('-C', '--customer-id CUSTOMER-ID', String, 'Customer ID') do |v|
      options[:customer_id] = v
    end

    opts.separator ''
    opts.separator 'Help:'

    opts.on_tail('-h', '--help', 'Show this message') do
      puts opts
      exit
    end
  end.parse!

  begin
    add_conversion_action(options.fetch(:customer_id).tr("-", ""))
  rescue Google::Ads::GoogleAds::Errors::GoogleAdsError => e
    e.failure.errors.each do |error|
      STDERR.printf("Error with message: %s\n", error.message)
      if error.location
        error.location.field_path_elements.each do |field_path_element|
          STDERR.printf("\tOn field: %s\n", field_path_element.field_name)
        end
      end
      error.error_code.to_h.each do |k, v|
        next if v == :UNSPECIFIED
        STDERR.printf("\tType: %s\n\tCode: %s\n", k, v)
      end
    end
    raise
  end
end

add_conversion_action.rb

Perl

#!/usr/bin/perl -w
#
# Copyright 2019, Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# This example illustrates adding a conversion action.

use strict;
use warnings;
use utf8;

use FindBin qw($Bin);
use lib "$Bin/../../lib";
use Google::Ads::GoogleAds::Client;
use Google::Ads::GoogleAds::Utils::GoogleAdsHelper;
use Google::Ads::GoogleAds::V17::Resources::ConversionAction;
use Google::Ads::GoogleAds::V17::Resources::ValueSettings;
use Google::Ads::GoogleAds::V17::Enums::ConversionActionCategoryEnum
  qw(DEFAULT);
use Google::Ads::GoogleAds::V17::Enums::ConversionActionTypeEnum   qw(WEBPAGE);
use Google::Ads::GoogleAds::V17::Enums::ConversionActionStatusEnum qw(ENABLED);
use
  Google::Ads::GoogleAds::V17::Services::ConversionActionService::ConversionActionOperation;

use Getopt::Long qw(:config auto_help);
use Pod::Usage;
use Cwd          qw(abs_path);
use Data::Uniqid qw(uniqid);

# The following parameter(s) should be provided to run the example. You can
# either specify these by changing the INSERT_XXX_ID_HERE values below, or on
# the command line.
#
# Parameters passed on the command line will override any parameters set in
# code.
#
# Running the example with -h will print the command line usage.
my $customer_id = "INSERT_CUSTOMER_ID_HERE";

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::V17::Resources::ConversionAction->new({
      name                          => $conversion_action_name,
      category                      => DEFAULT,
      type                          => WEBPAGE,
      status                        => ENABLED,
      viewThroughLookbackWindowDays => 15,
      valueSettings                 =>
        Google::Ads::GoogleAds::V17::Resources::ValueSettings->new({
          defaultValue          => 23.41,
          alwaysUseDefaultValue => "true"
        })});

  # Create a conversion action operation.
  my $conversion_action_operation =
    Google::Ads::GoogleAds::V17::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;
}

# Don't run the example if the file is being included.
if (abs_path($0) ne abs_path(__FILE__)) {
  return 1;
}

# Get Google Ads Client, credentials will be read from ~/googleads.properties.
my $api_client = Google::Ads::GoogleAds::Client->new();

# By default examples are set to die on any server returned fault.
$api_client->set_die_on_faults(1);

# Parameters passed on the command line will override any parameters set in code.
GetOptions("customer_id=s" => \$customer_id);

# Print the help message if the parameters are not initialized in the code nor
# in the command line.
pod2usage(2) if not check_params($customer_id);

# Call the example.
add_conversion_action($api_client, $customer_id =~ s/-//gr);

=pod

=head1 NAME

add_conversion_action

=head1 DESCRIPTION

This example illustrates adding a conversion action.

=head1 SYNOPSIS

add_conversion_action.pl [options]

    -help                       Show the help message.
    -customer_id                The Google Ads customer ID.

=cut

add_conversion_action.pl

Étant donné que les exemples précédents sont de nature générique, voici des remarques supplémentaires pour vous aider à configurer ConversionAction correctement pour Performance Max. Chacune de vos actions de conversion doit être configurée comme suit:

  • Type : définissez ConversionActionType sur WEBPAGE, car ces événements d'achat se produisent sur un site Web.

  • Enchérissable : définissez la valeur sur true pour votre action de conversion principale (achat) afin d'optimiser les campagnes pour les ventes. Pour les actions de conversion secondaires (ajout au panier, par exemple), définissez la valeur sur false.

  • Catégorie : pour chacune de vos actions de conversion (principale ou secondaire),définissez la catégorie ConversionActionCategory. Vous trouverez ci-dessous la catégorie d'action de conversation pertinente pour chacune des sept actions de conversion que nous vous recommandons d'implémenter. Notez que Google Ads attribue automatiquement les actions de conversion à un objectif de conversion standard en fonction de leur catégorie. Par exemple, les actions de conversion d'achat sont affectées à l'objectif de conversion standard appelé "Achats". Vous pourrez ensuite configurer la campagne Performance Max pour qu'elle optimise cet objectif "Achats".

Vous trouverez ci-dessous une liste d'actions de conversion recommandées. Nous vous recommandons d'implémenter au moins les quatre premières actions de conversion et un maximum d'autres actions recommandées.

Vous pouvez également envisager d'implémenter des événements supplémentaires pertinents pour les ventes en ligne. Pour un suivi encore plus précis, vous pouvez également créer des actions de conversion supplémentaires ou personnalisées (par exemple, une action pour "ajouter des informations de paiement" chaque fois qu'un utilisateur utilise l'option de recherche sur le site Web ou une action pour "recherche" chaque fois qu'un utilisateur utilise l'option de recherche sur le site). Les actions de conversion secondaires offrent un suivi supplémentaire pour vos marchands et sont utilisées par Google Ads à des fins d'observation.

Priorité Action de conversion Catégorie d'action de conversion Nom de l'événement de la balise Google Description
Obligatoire Acheter ACHAT purchase L'utilisateur effectue un achat.
Fortement recommandé pour tous les compilateurs de magasins Ajouter au panier ADD_TO_CART add_to_cart L'utilisateur ajoute un produit au panier
Fortement recommandé pour tous les compilateurs de magasins Paiement initié BEGIN_CHECKOUT begin_checkout L'utilisateur commence le processus de règlement
Fortement recommandé pour tous les compilateurs de magasins Afficher l'article PAGE_VIEW page_view L'utilisateur ouvre une page de produit
Fortement recommandé le cas échéant (généralement non applicable aux compilateurs de magasin) S'inscrire S'INSCRIRE sign_up L'utilisateur crée un compte
Fortement recommandé le cas échéant (généralement non applicable aux compilateurs de magasin) Générer des prospects SUBMIT_LEAD_FORM generate_lead L'utilisateur génère un prospect via un formulaire
Fortement recommandé le cas échéant (généralement non applicable aux compilateurs de magasin) S'abonner SUBSCRIBE_PAID non applicable (personnalisé) L'utilisateur s'abonne à un service payant
Fortement recommandé le cas échéant (généralement non applicable aux compilateurs de magasin) Prendre rendez-vous BOOK_APPOINTMENT non applicable (personnalisé) L'utilisateur prend un rendez-vous
Fortement recommandé le cas échéant (généralement non applicable aux compilateurs de magasin) Demande de devis REQUEST_QUOTE non applicable (personnalisé) L'utilisateur envoie un formulaire pour demander une estimation de prix

Marchands disposant d'un compte Ads

Si vous autorisez les marchands à intégrer un compte Ads existant, il est possible que le compte comporte déjà des actions de conversion. Nous vous déconseillons d'utiliser une action de conversion existante, car nous ne pouvons pas garantir qu'elle a été correctement configurée. En outre, vous devez prendre des mesures supplémentaires afin de gérer ces scénarios potentiels:

  • Le compte comporte plusieurs objectifs (par exemple, Achats + Pages vues + Contacts) qui sont tous marqués comme "par défaut du compte". Lorsqu'une campagne est créée, elle est par défaut optimisée en fonction de tous ces objectifs, ce qui n'est pas utile pour la campagne Performance Max.

  • Le compte comporte déjà une ou plusieurs actions de conversion pour le suivi des achats. Il est déjà regroupé dans l'objectif "Achats". Cela signifie qu'après que la campagne comptabilise deux fois un achat, deux balises de conversion se déclenchent.

Pour vous assurer que la campagne Performance Max utilise votre action de conversion personnalisée et cette action uniquement:

  1. Créez un CustomConversionGoal et ajoutez votre action de conversion "Achat" à la liste de conversion_actions[] de l'objectif. Définissez l'état sur ACTIVÉ.

  2. Dans le champ ConversionGoalCampaignConfig de la campagne Performance Max, définissez custom_conversion_goal sur l'objectif personnalisé que vous avez créé à l'étape 1.

  3. À l'étape 2, Google Ads devrait avoir automatiquement mis à jour la valeur "ConversionGoalCampaignConfig" de la campagne de sorte que goal_config_level soit défini sur CAMPAIGN (au lieu de CUSTOMER, ce qui lui indiquera d'utiliser les objectifs par défaut du compte). Toutefois, il est utile de vérifier que c'est bien le cas.

Récupérer la balise de l'action de conversion

Une fois l'action de conversion créée, vous devez insérer l'extrait de code correspondant (appelé balise) sur la page de conversion du site Web de l'annonceur. Pour vous assurer que Google Ads peut mesurer toutes les conversions quel que soit le navigateur du client, utilisez la nouvelle balise de suivi des conversions Google Ads. Cette balise se compose de deux parties:

  • Le global_site_tag, qui doit être installé sur chaque page du site Web de l'annonceur

  • Le event_snippet, à placer sur les pages Web qui indiquent une action de conversion, comme une page de confirmation de paiement ou d'envoi de prospects.

Vous pouvez récupérer ces deux éléments à l'aide de ConversionActionService.

La balise définit des cookies qui stockent un identifiant unique correspondant à un client ou au clic sur l'annonce qui a redirigé l'internaute vers le site. Ces informations proviennent d'un identifiant de clic Google (GCLID) inclus dans la balise de suivi des conversions. Vous devez activer le site Web et le système de suivi des prospects de l'annonceur pour capturer et stocker le GCLID, qui est l'identifiant unique fourni par Google Ads pour chaque impression d'une annonce Google.

En savoir plus sur la balise globale et son emplacement

La balise Google (gtag.js) est un framework de taggage et une API qui vous permet d'envoyer des données d'événement à Google Ads et Google Analytics. Pour suivre vos conversions, le global site tag doit être utilisé conjointement avec un extrait d'événement ou de numéro de téléphone. Ajoutez la balise Google à la section <head> de chaque page du site de l'annonceur et configurez-la pour qu'elle fonctionne avec Google Ads. Vous pouvez ensuite utiliser les commandes gtag() pour capturer des événements et envoyer des données à Google Ads. Pour en comprendre le fonctionnement, consultez Utiliser le global site tag pour le suivi des conversions Google Ads.

Utilisez les commandes suivantes avec la balise Google:

  • config:permet d'initialiser un produit Google (Google Ads, Analytics, etc.), de configurer les paramètres et de préparer l'envoi de données vers un compte.

  • Événement:enregistrez une conversion en envoyant un événement tel qu'un achat (recommandé) ou l'ajout à un panier (actions de conversion secondaires). Nous vous recommandons de consulter le Guide de référence sur les événements gtag.js.

  • set:définit les paramètres communs à tous les événements de la page, comme la devise.

L'exemple suivant est un extrait de code JavaScript du global site tag permettant d'envoyer des données à Google Ads. La valeur de l'espace réservé GOOGLE_CONVERSION_ID correspond à un identifiant numérique unique attribué à un seul compte d'annonceur.

<!-- Google Tag (gtag.js) - Google Ads: GOOGLE_CONVERSION_ID -->
<script async src="https://www.googletagmanager.com/gtag/js?id=AW-GOOGLE_CONVERSION_ID">
</script>
<script>
  window.dataLayer = window.dataLayer || [];
  function gtag(){dataLayer.push(arguments)};
  gtag('js', new Date());
   gtag('set', 'developer_id.<developer ID>', true); // Replace with your Google tag Developer ID
  gtag('config', 'AW-GOOGLE_CONVERSION_ID');
</script>

L'extrait de code de la balise Google ne doit apparaître qu'une seule fois par page. S'il existe déjà une instance de gtag.js, vous devez ajouter de nouveaux ID de balise à la balise existante. Pour envoyer des données à plusieurs comptes, vous pouvez ajouter un appel à la commande "config" pour chaque compte que vous utilisez, en spécifiant l'ID de conversion de chaque compte, comme indiqué dans l'exemple suivant:

<!-- Google Tag (gtag.js) - Google Ads: GOOGLE_CONVERSION_ID_1 -->
<script async src="https://www.googletagmanager.com/gtag/js?id=AW-GOOGLE_CONVERSION_ID_1"></script>
<script>
  window.dataLayer = window.dataLayer || [];
  function gtag(){dataLayer.push(arguments)};
  gtag('js', new Date());
  gtag('config', 'AW-GOOGLE_CONVERSION_ID_1');
  gtag('config', 'AW-GOOGLE_CONVERSION_ID_2');
</script>

En savoir plus sur l'extrait d'événement et son emplacement

Pour que le suivi des conversions d'achat fonctionne, vous devez insérer l'extrait d'événement d'achat sur la page de conversion elle-même. Il s'agit généralement de la page de confirmation de commande. Vous pouvez l'ajouter où vous le souhaitez dans le code, après l'extrait de la balise globale. Les extraits d'événement pour les actions de conversion secondaires (par exemple, ajout au panier) doivent être placés sur les pages correspondantes.

Dans l'exemple d'extrait ci-dessous, AW-CONVERSION_ID et gTag_developer_ID correspondent à l'ID de conversion propre à votre compte Google Ads et à votre compte de développeur de balises Google, tandis que AW-CONVERSION_LABEL correspond au libellé de conversion, qui est propre à chaque action de conversion:

<!-- Event snippet for a purchase conversion page -->
<script>
  gtag('event', 'conversion', {
       'send_to':'AW-CONVERSION_ID/CONVERSION_LABEL',
       'developer_id.<gTag developer ID>': true,
       'transaction_id': '<transaction_id (string)>' //unique ID for the transaction (e.g. an order ID); it's used for de-duplication purposes
       'value': 1.0,
       'currency': 'USD', //three-letter currency code, useful for advertisers who accept multiple currencies
       'country': 'US',
       'new_customer': false, //new customer acquisition goal
       'tax': 1.24, //tax cost-US only
       'shipping': 0.00, //shipping cost-US only
       'delivery_postal_code': '94043', //shipping data validation-US only
       'estimated_delivery_date': '2020-07-31', //shipping validation-US only
       'aw_merchant_id': 12345, //shipping validation-US only
       'aw_feed_country': 'US', //shipping validation-US only
       'aw_feed_language': 'EN', //shipping validation-US only
       'items': [
       {
             'id': 'P12345',
             'name': 'Android Warhol T-Shirt',
             'quantity': 2,
             'price': 12.04,
             'estimated_delivery_date': '2020-07-31', //shipping-US only
              'google_business_vertical': 'retail'
       }, …],
  });
</script>

Bien que certains paramètres soient facultatifs, nous vous recommandons d'inclure autant d'informations que possible pour chaque événement. En savoir plus sur les paramètres disponibles pour chaque type d'événement

Les paramètres fournissent des informations supplémentaires sur la façon dont les utilisateurs interagissent avec votre site Web ou votre application.

Si vous souhaitez mesurer un événement de conversion basé sur un clic (par exemple, sur un bouton ou une réponse dynamique pour un site utilisant AJAX), vous pouvez également utiliser l'extrait suivant à la place:

<!-- Event snippet for test conversion click -->
In your html page, add the snippet and call gtag_report_conversion when someone clicks on the chosen link or button. -->
<script>
function gtag_report_conversion(url) {
  var callback = function () {
    if (typeof(url) != 'undefined') {
      window.location = url;
    }
  };
  gtag('event', 'conversion', {
      'send_to': 'AW-CONVERSION_ID/CONVERSION_LABEL',
      'value': 1.0,
      'event_callback': callback,
      //other parameters
  });
  return false;
}
</script>

La balise Google intègre une API Consent permettant de gérer le consentement des utilisateurs. Il est capable de différencier le consentement des utilisateurs pour les cookies publicitaires de ceux à des fins d'analyse.

Les clients obtiendront au moins l'appel gtag('consent', 'update' {...}) intégré, sans qu'aucune action ne soit requise de leur part. Vous devez ainsi vous assurer que les balises Google (Google Ads, Floodlight, Google Analytics, Conversion Linker) peuvent lire le dernier état du consentement de l'utilisateur et l'inclure dans les requêtes réseau envoyées à Google (via le paramètre &gcs).

Une étape d'implémentation supplémentaire consisterait à déployer l'état gtag('consent', default' {...}) ou à aider les annonceurs à déployer l'état gtag('consent', default' {...}) et à débloquer les balises Google (par exemple, aucun déclenchement conditionnel basé sur le consentement) afin de permettre au mode Consentement de les déclencher en tenant compte du consentement.

Pour en savoir plus sur l'implémentation, consultez Gérer les paramètres de consentement (Web).

Conseils

À partir de votre compte administrateur Google Ads,vous pouvez suivre les conversions sur tous vos comptes d'annonceur à l'aide d'une seule balise de code de conversion. En savoir plus sur le suivi des conversions multicomptes

Le meilleur moyen de vérifier si votre mise en œuvre du suivi des conversions fonctionne est d'accéder au site Web de l'un de vos marchands (ou d'un site Web de test interne) et d'effectuer un achat réel. Vous pouvez ensuite utiliser l'outil Google Tag Assistant pour consulter ce guide de dépannage afin de vérifier que Google Ads a bien détecté votre balise et enregistre correctement les conversions. Pour obtenir une aide supplémentaire, consultez Résoudre les problèmes liés au taggage sur l'intégralité du site.

Vous pouvez compléter la balise de conversion précédente avec le suivi avancé des conversions, ce qui peut améliorer la précision de la mesure de vos conversions et générer des enchères plus performantes. En savoir plus sur la configuration du suivi avancé des conversions Avant d'implémenter le suivi avancé des conversions, vous devez vous assurer que vos marchands peuvent respecter les Règles concernant les données client pour le suivi avancé des conversions dans Google Ads.

Précédent
Associer un compte Google Ads
Suivant
4.2 Créer une campagne publicitaire