4.1.5 Suivi des conversions

Valeur et impact sur l'entreprise

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

Une conversion dans Google Ads se produit lorsqu'un utilisateur effectue une action définie 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 insights clés sur les actions des utilisateurs après avoir vu une annonce ou cliqué dessus, y compris des informations pour calculer et 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 à des fins de rapprochement. Les commandes diffèrent selon le produit ou la catégorie. Le suivi des conversions peut donc également être utile pour montrer 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 les 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, que Google regroupe dans des objectifs de conversion.

Action de conversion d'achat

L'implémentation du suivi des conversions décrit ici permet au compte Google Ads de votre marchand de mesurer le nombre de conversions "Achat" et la valeur de ces conversions. Sans le suivi des conversions, vous ne pourrez 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 ses performances.

Autres actions de conversion

Bien que l'action de conversion d'achat soit la seule requise, le suivi d'autres actions de conversion peut fournir des insights supplémentaires à vos marchands. Nous vous recommandons de consigner tout ce qui est possible, tout en implémentant autant d'actions de conversion de base que possible. La liste complète des actions de conversion recommandées est décrite dans la section "Conseils sur les API techniques".

En règle générale, nous vous recommandons de capturer les éléments suivants:

  • Tout événement de réussite directement associé à une valeur
  • Événements de réussite qui contribuent aux conversions principales, comme add_to_cart et sign_up.
  • Engagements et interactions des utilisateurs qui aident les annonceurs à comprendre comment ils engagent leurs utilisateurs finaux

Les actions de conversion secondaires ne sont utilisées qu'à des fins d'observation et de création de rapports.Elles n'affectent pas les enchères.En savoir plus sur les actions de conversion principales et secondaires

Conseils en termes d'expérience utilisateur

Pour réduire le risque d'erreurs, nous vous recommandons d'implémenter le suivi des conversions de manière programmatique sans intervention des marchands, mais 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é dans leur compte, car des conflits peuvent survenir et doivent être résolus. Un exemple est présenté 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 action de conversion 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 l'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 son appareil mobile.

  4. Lorsque le client effectue l'action définie pour l'annonceur, Google reconnaît le cookie (via 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 pour les balises Google. Si vous ne possédez pas d'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 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.v21.enums.ConversionActionCategoryEnum.ConversionActionCategory;
import com.google.ads.googleads.v21.enums.ConversionActionStatusEnum.ConversionActionStatus;
import com.google.ads.googleads.v21.enums.ConversionActionTypeEnum.ConversionActionType;
import com.google.ads.googleads.v21.errors.GoogleAdsError;
import com.google.ads.googleads.v21.errors.GoogleAdsException;
import com.google.ads.googleads.v21.resources.ConversionAction;
import com.google.ads.googleads.v21.resources.ConversionAction.ValueSettings;
import com.google.ads.googleads.v21.services.ConversionActionOperation;
import com.google.ads.googleads.v21.services.ConversionActionServiceClient;
import com.google.ads.googleads.v21.services.MutateConversionActionResult;
import com.google.ads.googleads.v21.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.V21.Errors;
using Google.Ads.GoogleAds.V21.Resources;
using Google.Ads.GoogleAds.V21.Services;
using System;
using static Google.Ads.GoogleAds.V21.Enums.ConversionActionCategoryEnum.Types;
using static Google.Ads.GoogleAds.V21.Enums.ConversionActionStatusEnum.Types;
using static Google.Ads.GoogleAds.V21.Enums.ConversionActionTypeEnum.Types;

namespace Google.Ads.GoogleAds.Examples.V21
{
    /// <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.V21.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\V21\GoogleAdsClient;
use Google\Ads\GoogleAds\Lib\V21\GoogleAdsClientBuilder;
use Google\Ads\GoogleAds\Lib\V21\GoogleAdsException;
use Google\Ads\GoogleAds\Lib\OAuth2TokenBuilder;
use Google\Ads\GoogleAds\V21\Enums\ConversionActionCategoryEnum\ConversionActionCategory;
use Google\Ads\GoogleAds\V21\Enums\ConversionActionStatusEnum\ConversionActionStatus;
use Google\Ads\GoogleAds\V21\Enums\ConversionActionTypeEnum\ConversionActionType;
use Google\Ads\GoogleAds\V21\Errors\GoogleAdsError;
use Google\Ads\GoogleAds\V21\Resources\ConversionAction;
use Google\Ads\GoogleAds\V21\Resources\ConversionAction\ValueSettings;
use Google\Ads\GoogleAds\V21\Services\ConversionActionOperation;
use Google\Ads\GoogleAds\V21\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)
            ->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
from google.ads.googleads.v21.resources.types.conversion_action import (
    ConversionAction,
)
from google.ads.googleads.v21.services.services.conversion_action_service import (
    ConversionActionServiceClient,
)
from google.ads.googleads.v21.services.types.conversion_action_service import (
    ConversionActionOperation,
    MutateConversionActionsResponse,
)


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}".'
    )


if __name__ == "__main__":
    parser: argparse.ArgumentParser = 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: argparse.Namespace = parser.parse_args()

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

    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'
require_relative '../shared/error_handler.rb'

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
    GoogleAdsErrorHandler.handle_google_ads_error(e)
    raise # Re-raise the error to maintain original script behavior.
  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::V21::Resources::ConversionAction;
use Google::Ads::GoogleAds::V21::Resources::ValueSettings;
use Google::Ads::GoogleAds::V21::Enums::ConversionActionCategoryEnum
  qw(DEFAULT);
use Google::Ads::GoogleAds::V21::Enums::ConversionActionTypeEnum   qw(WEBPAGE);
use Google::Ads::GoogleAds::V21::Enums::ConversionActionStatusEnum qw(ENABLED);
use
  Google::Ads::GoogleAds::V21::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::V21::Resources::ConversionAction->new({
      name                          => $conversion_action_name,
      category                      => DEFAULT,
      type                          => WEBPAGE,
      status                        => ENABLED,
      viewThroughLookbackWindowDays => 15,
      valueSettings                 =>
        Google::Ads::GoogleAds::V21::Resources::ValueSettings->new({
          defaultValue          => 23.41,
          alwaysUseDefaultValue => "true"
        })});

  # Create a conversion action operation.
  my $conversion_action_operation =
    Google::Ads::GoogleAds::V21::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 que ConversionAction soit correctement configuré 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 true pour votre action de conversion principale (achat) afin d'optimiser les campagnes en fonction des ventes. Pour les actions de conversion secondaires (par exemple, l'ajout au panier), définissez la valeur sur false.

  • Catégorie : pour chacune de vos actions de conversion (principales ou secondaires),définissez ConversionActionCategory. Vous trouverez ci-dessous la catégorie d'action de conversation appropriée pour chacune des sept actions de conversion que nous vous recommandons d'implémenter. Remarque : 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 attribuées à l'objectif de conversion standard "Achats". Vous pourrez ensuite configurer la campagne Performance Max pour l'optimiser en fonction de 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 autant d'autres actions recommandées que possible.

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 des actions de conversion 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 "Rechercher" chaque fois qu'un utilisateur utilise l'option de recherche sur le site Web). Les actions de conversion secondaires fournissent 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 créateurs de boutiques Ajouter au panier ADD_TO_CART add_to_cart L'utilisateur ajoute un produit au panier
Fortement recommandé pour tous les créateurs de boutiques Paiement initié BEGIN_CHECKOUT begin_checkout L'utilisateur commence le processus de paiement
Fortement recommandé pour tous les créateurs de boutiques Afficher l'article PAGE_VIEW page_view L'utilisateur ouvre une page produit
Fortement recommandé si applicable (généralement non applicable aux outils de création de magasins) S'inscrire S'INSCRIRE sign_up L'utilisateur crée un compte
Fortement recommandé si applicable (généralement non applicable aux outils de création de magasins) Générer des prospects SUBMIT_LEAD_FORM generate_lead L'utilisateur génère un prospect via un formulaire
Fortement recommandé si applicable (généralement non applicable aux outils de création de magasins) S'abonner SUBSCRIBE_PAID Non applicable (personnalisé) L'utilisateur s'abonne à un service payant
Fortement recommandé si applicable (généralement non applicable aux outils de création de magasins) Prendre rendez-vous BOOK_APPOINTMENT Non applicable (personnalisé) L'utilisateur prend rendez-vous
Fortement recommandé si applicable (généralement non applicable aux outils de création de magasins) 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 à s'inscrire avec un compte Ads existant, il est possible que le compte dispose déjà d'actions de conversion. Nous vous déconseillons d'utiliser une action de conversion existante, car il n'est pas garanti qu'elle a été correctement configurée. De plus, vous devez effectuer des étapes supplémentaires pour gérer ces scénarios potentiels:

  • Le compte comporte plusieurs objectifs (par exemple, "Achats + Vues de pages + Contacts") qui sont tous marqués comme "par défaut du compte". Lorsqu'une campagne est créée, elle est optimisée par défaut pour tous ces objectifs. Vous ne souhaitez pas que cela se produise pour la campagne Performance Max.

  • Le compte comporte déjà une (ou plusieurs) action de conversion pour le suivi des achats, et elle est déjà regroupée sous l'objectif "Achats". Cela signifie que la campagne double le nombre d'achats, car deux balises de conversion sont déclenchées.

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

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

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

  3. À la suite de l'étape 2, Google Ads aurait dû mettre à jour automatiquement la ConversionGoalCampaignConfig de la campagne afin que goal_config_level soit défini sur CAMPAIGN (au lieu de CUSTOMER, qui l'inviterait à utiliser les objectifs par défaut du compte), mais il est utile de vérifier que cela s'est bien produit.

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 que Google Ads puisse 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:

  • La balise global_site_tag, qui doit être installée sur chaque page du site Web de l'annonceur.

  • event_snippet, qui doit être placé sur les pages Web qui indiquent une action de conversion, comme une page de confirmation de paiement ou d'envoi de prospect.

Vous pouvez récupérer ces deux éléments avec ConversionActionService.

La balise définit des cookies qui stockent un identifiant unique correspondant à un client ou au clic sur l'annonce qui l'a redirigé vers le site. Les cookies reçoivent les informations sur le clic sur l'annonce à partir d'un paramètre 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 où l'installer

La balise Google (gtag.js) est un framework et une API de taggage qui vous permettent d'envoyer des données d'événement à la fois à Google Ads et à Google Analytics. Pour que le suivi des conversions fonctionne, le global site tag doit être utilisé conjointement avec un extrait d'événement ou un extrait 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 enregistrer des événements et envoyer des données à Google Ads. Pour comprendre comment cela fonctionne, consultez Utiliser le global site tag pour le suivi des conversions Google Ads.

Vous 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 à un compte.

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

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

L'exemple suivant est un extrait de code JavaScript de la balise de site globale permettant d'envoyer des données à Google Ads. La valeur d'espace réservé GOOGLE_CONVERSION_ID correspond à un ID numérique unique pour un seul compte 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 balise Google ne doit apparaître qu'une seule fois par page. Si une instance de gtag.js existe déjà, 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 illustré 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 où l'installer

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 code de la balise globale. Les extraits d'événement pour les actions de conversion secondaires (par exemple, "Ajouter au panier") doivent être placés sur les pages respectives.

Dans l'exemple d'extrait ci-dessous, AW-CONVERSION_ID et gTag_developer_ID représentent l'ID de conversion propre à votre compte Google Ads et à votre compte de développeur Google Tag, tandis que AW-CONVERSION_LABEL correspond au libellé de conversion, qui est unique pour 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 les interactions des utilisateurs sur votre site Web ou dans votre application.

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

<!-- 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 Consentement pour gérer le consentement des utilisateurs. Il peut différencier le consentement des utilisateurs pour les cookies à des fins publicitaires de ceux à des fins analytiques.

L'objectif est que les clients intègrent au moins l'appel gtag('consent', 'update'{...}), sans aucune action requise de leur part. Cela devrait garantir que les balises Google (Google Ads, Floodlight, Google Analytics, Conversion Linker) peuvent lire le dernier état du consentement de l'utilisateur et inclure cet état dans les requêtes réseau envoyées à Google (via le paramètre &gcs).

Les étapes d'implémentation supplémentaires consistent à déployer ou à aider les annonceurs à déployer (par exemple, via une UI) l'état gtag('consent', default' {...}) et à débloquer les balises Google (par exemple, pas de déclenchement conditionnel basé sur le consentement) pour permettre au mode Consentement de les déclencher de manière conforme au consentement.

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

Conseils

Depuis le compte administrateur Google Ads,vous pouvez suivre les conversions sur l'ensemble de vos comptes annonceur à l'aide d'une seule balise de code de conversion. Consultez la page d'informations sur le suivi des conversions multicomptes.

Le meilleur moyen de vérifier si l'implémentation du suivi des conversions fonctionne est d'accéder à l'un des sites Web de vos marchands (ou à un site Web de test interne) et d'effectuer un achat réel. Vous pouvez ensuite utiliser cet guide de dépannage dans l'outil Google Tag Assistant pour vérifier que Google Ads a vu votre balise et qu'il 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 des conversions et générer des enchères plus performantes. Découvrez comment configurer le 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 associées au suivi avancé des conversions dans Google Ads.

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