4.1.5 Suivi des conversions

Valeur et impact sur l'activité

Pour fournir efficacement le puissant machine learning et les outils d'analyse 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 des clients.

Dans Google Ads, une conversion 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. Il inclut des informations permettant de calculer et de comparer le retour sur investissement (ROI) pour 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 varient en fonction du produit ou de la catégorie. Le suivi des conversions peut donc également être utile pour montrer comment des groupes de fiches spécifiques se transforment en 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 qui comporte 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, et Google les 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 d'achat et la valeur de ces conversions. Sans 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). Elle 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'actions de conversion supplémentaires peut fournir des insights supplémentaires à vos marchands. Nous vous recommandons de consigner tout ce qui est possible et d'implémenter autant d'actions de conversion principales que possible. La liste complète des actions de conversion recommandées est décrite dans la section "Conseils concernant l'API technique".

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 clés, comme add_to_cart et sign_up.
  • Engagements et interactions utilisateur qui aident les annonceurs à comprendre comment ils engagent leurs utilisateurs finaux

Les actions de conversion secondaires ne sont enregistrées qu'à titre d'observation et pour les rapports.Elles n'ont aucune incidence sur les enchères.En savoir plus sur les actions de conversion principales et secondaires

Conseils sur l'expérience utilisateur

Pour minimiser le risque d'erreurs, nous vous recommandons d'implémenter le suivi des conversions de manière 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 peut déjà être configuré dans leur compte, car il peut y avoir des conflits à résoudre. 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 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 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 (grâce à l'extrait de code ajouté) et enregistre une conversion avec d'autres paramètres tels que la "valeur", le cas échéant.

Prérequis

Avant de commencer, assurez-vous de disposer d'un ID de développeur de balise Google. Si vous n'avez 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 pour vous et vous guide dans la création d'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.v23.enums.ConversionActionCategoryEnum.ConversionActionCategory;
import com.google.ads.googleads.v23.enums.ConversionActionStatusEnum.ConversionActionStatus;
import com.google.ads.googleads.v23.enums.ConversionActionTypeEnum.ConversionActionType;
import com.google.ads.googleads.v23.errors.GoogleAdsError;
import com.google.ads.googleads.v23.errors.GoogleAdsException;
import com.google.ads.googleads.v23.resources.ConversionAction;
import com.google.ads.googleads.v23.resources.ConversionAction.ValueSettings;
import com.google.ads.googleads.v23.services.ConversionActionOperation;
import com.google.ads.googleads.v23.services.ConversionActionServiceClient;
import com.google.ads.googleads.v23.services.MutateConversionActionResult;
import com.google.ads.googleads.v23.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.V23.Errors;
using Google.Ads.GoogleAds.V23.Resources;
using Google.Ads.GoogleAds.V23.Services;
using System;
using static Google.Ads.GoogleAds.V23.Enums.ConversionActionCategoryEnum.Types;
using static Google.Ads.GoogleAds.V23.Enums.ConversionActionStatusEnum.Types;
using static Google.Ads.GoogleAds.V23.Enums.ConversionActionTypeEnum.Types;

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

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

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

curl

Les exemples précédents étant génériques, voici des notes supplémentaires pour que l'objet ConversionAction soit correctement configuré pour Performance Max. Chaque action 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 vos campagnes pour les ventes. Pour les actions de conversion secondaires (par exemple, l'ajout au panier), définissez la valeur sur false.

  • Catégorie : définissez la ConversionActionCategory pour chacune de vos actions de conversion (principales ou secondaires). 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. 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 personnalisées (par exemple, une action "Ajouter des informations de paiement" chaque fois qu'un utilisateur utilise l'option de recherche sur le site Web, ou une action "Recherche" chaque fois qu'un utilisateur utilise l'option de recherche sur le site Web). Les actions de conversion secondaires permettent de suivre plus précisément les 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 Achat 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 règlement
Fortement recommandé pour tous les créateurs de boutiques Afficher l'article PAGE_VIEW page_view Un utilisateur ouvre une page produit
Fortement recommandé, le cas échéant (ne s'applique généralement pas aux créateurs de boutiques) S'inscrire INSCRIPTION sign_up L'utilisateur s'inscrit à un compte
Fortement recommandé, le cas échéant (ne s'applique généralement pas aux créateurs de boutiques) Générer des prospects SUBMIT_LEAD_FORM generate_lead Un utilisateur génère un prospect via un formulaire
Fortement recommandé, le cas échéant (ne s'applique généralement pas aux créateurs de boutiques) S'abonner SUBSCRIBE_PAID Non applicable (personnalisé) L'utilisateur s'abonne à un service payant
Fortement recommandé, le cas échéant (ne s'applique généralement pas aux créateurs de boutiques) Prendre rendez-vous BOOK_APPOINTMENT Non applicable (personnalisé) L'utilisateur prend rendez-vous
Fortement recommandé, le cas échéant (ne s'applique généralement pas aux créateurs de boutiques) Demande de devis REQUEST_QUOTE Non applicable (personnalisé) L'utilisateur envoie un formulaire demandant une estimation du prix

Marchands disposant d'un compte Ads

Si vous autorisez les marchands à s'intégrer avec 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. 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 page" + "Contacts") qui sont tous marqués comme "par défaut du compte". Lorsqu'une nouvelle campagne est créée, l'optimisation est définie par défaut pour tous ces objectifs. Vous ne souhaitez pas cela pour la campagne Performance Max.

  • Le compte comporte déjà une ou plusieurs actions de conversion pour le suivi des achats, et elles sont déjà regroupées sous l'objectif "Achats". Cela signifie que la campagne comptabilise deux fois un achat, 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 uniquement celle-ci :

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

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

  3. À l'issue de l'étape (2), Google Ads devrait avoir mis à jour automatiquement le ConversionGoalCampaignConfig de la campagne de sorte que goal_config_level soit défini sur CAMPAIGN (au lieu de CUSTOMER, qui l'inviterait à utiliser les objectifs par défaut du compte). Toutefois, il est préférable de vérifier que cela s'est bien produit.

Récupérer la balise pour 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 global_site_tag, qui doit être installée sur chaque page du site Web de l'annonceur.

  • Le event_snippet, qui doit être placé sur les pages Web indiquant une action de conversion (page de confirmation de paiement ou d'envoi de prospects, par exemple).

Vous pouvez récupérer ces deux parties avec ConversionActionService.

La balise définit des cookies qui stockent un identifiant unique pour un client ou le clic sur l'annonce qui l'a redirigé vers le site. Les informations sur les clics sur les annonces proviennent d'un paramètre identifiant de clic Google (GCLID) inclus dans la balise de suivi des conversions. Vous devez activer le site Web de l'annonceur et le système de suivi des prospects 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 à 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 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 : initialiser un produit Google (Google Ads, Analytics, etc.), configurer les paramètres et 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 : définissez des 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 du code de substitution GOOGLE_CONVERSION_ID est un ID numérique unique pour 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 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 les 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 où l'installer

Pour que le suivi des conversions d'achat fonctionne, l'extrait d'événement d'achat doit être installé sur la page de conversion elle-même. Il s'agit généralement de la page de confirmation de la 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, "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 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 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 :

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

Le résultat attendu est que l'appel gtag('consent', 'update' {...}) soit intégré sans aucune action requise de la part du client. Cela devrait permettre aux balises Google (Google Ads, Floodlight, Google Analytics, Conversion Linker) de lire le dernier état du consentement de l'utilisateur et de l'inclure 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, sans déclenchement conditionnel basé sur le consentement) pour 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

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

Pour vérifier que votre implémentation du suivi des conversions fonctionne, le mieux est d'accéder au site Web d'un de vos marchands (ou à un site Web de test interne) et d'y effectuer un achat réel. Vous pouvez ensuite observer dans l'outil Tag Assistant pour utiliser ce guide de dépannage afin de vérifier que Google Ads a vu 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, 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 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