4.1.5 Suivi des conversions

Valeur et impact commercial

Pour fournir efficacement les performances de l'écosystème Google en termes de machine learning pour les campagnes publicitaires de vos clients marchands, vous devez placer des balises de suivi et de remarketing sur les sites Web des clients.

Une conversion dans Google Ads se produit lorsqu'un utilisateur effectue une action spécifiée. après avoir cliqué sur une annonce (achat d'un produit, installation d'une application mobile, ou l'inscription à une liste de diffusion. Le suivi des conversions fournit des insights clés sur l'expérience utilisateur actions après avoir vu une annonce ou cliqué dessus, y compris les informations sur Calculez et comparez le retour sur investissement (ROI) pour aider vos clients pour décider où concentrer vos dépenses publicitaires. Le suivi permet également de garantir afin que les données soient disponibles à des fins de rapprochement. Les commandes varient selon le produit ou la catégorie. Le suivi des conversions peut donc aussi être utile pour déterminer des groupes de fiches spécifiques génèrent des ventes.

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

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

Action de conversion d'achat

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

Autres actions de conversion

Bien que l'action de conversion d'achat soit uniquement obligatoire, le suivi les actions de conversion peuvent fournir des insights supplémentaires à vos marchands. Mer recommandent de consigner tout ce qui est possible, tout en implémentant la plupart des actions de conversion principales. Vous trouverez la liste complète des actions de conversion recommandées décrites dans la section "Conseils concernant les API techniques".

En général, il est recommandé de collecter les éléments suivants:

  • Tout événement de réussite directement associé à une valeur
  • Événements de réussite qui contribuent aux conversions principales (par exemple, add_to_cart et sign_up
  • Les interactions et les interactions des utilisateurs qui aident les annonceurs à comprendre susciter l'intérêt des utilisateurs finaux

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

Conseils sur l'expérience utilisateur

Pour réduire le risque d'erreurs, nous vous recommandons d'implémenter les stratégies le suivi programmatique sans intervention du marchand, mais vous devez vous assurer vos marchands savent que le suivi des conversions est configuré.

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

connect_your_google_ads_account

Conseils techniques

Voici comment fonctionne le suivi des conversions. Cette section aborde plus en détail chaque étape:

  1. Vous créez une action de conversion "ConversionAction" dans le compte Ads de votre marchand afin de 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 correspondant à cette action de conversion à un site Web l'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 le l'ordinateur ou l'appareil mobile du client.

  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 avec d'autres paramètres, comme "value" le cas échéant.

Prérequis

Avant de commencer, vérifiez que vous disposez d'un ID de développeur pour la balise Google. Si vous ne disposer d'un ID de développeur pour la balise Google, remplissez le Formulaire de demande d'ID de développeur pour la balise Google. Votre ID de développeur est différent à partir d'autres ID, tels que l'ID de mesure ou l'ID de conversion, que vous que les utilisateurs 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.v17.enums.ConversionActionCategoryEnum.ConversionActionCategory;
import com.google.ads.googleads.v17.enums.ConversionActionStatusEnum.ConversionActionStatus;
import com.google.ads.googleads.v17.enums.ConversionActionTypeEnum.ConversionActionType;
import com.google.ads.googleads.v17.errors.GoogleAdsError;
import com.google.ads.googleads.v17.errors.GoogleAdsException;
import com.google.ads.googleads.v17.resources.ConversionAction;
import com.google.ads.googleads.v17.resources.ConversionAction.ValueSettings;
import com.google.ads.googleads.v17.services.ConversionActionOperation;
import com.google.ads.googleads.v17.services.ConversionActionServiceClient;
import com.google.ads.googleads.v17.services.MutateConversionActionResult;
import com.google.ads.googleads.v17.services.MutateConversionActionsResponse;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Collections;

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

  private static class AddConversionActionParams extends CodeSampleParams {

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

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

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

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

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

  /**
   * Runs the example.
   *
   * @param googleAdsClient the Google Ads API client.
   * @param customerId the client customer ID.
   * @throws GoogleAdsException if an API request failed with one or more service errors.
   */
  private void runExample(GoogleAdsClient googleAdsClient, long customerId) {

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

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

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

AddConversionAction.java

C#

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

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

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

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

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

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

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

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

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

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

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

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

AddConversionAction.cs

PHP

<?php

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

namespace Google\Ads\GoogleAds\Examples\Remarketing;

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

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

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

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

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

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

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

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

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

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

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

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

AddConversionAction::main();

AddConversionAction.php

Python

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


import argparse
import sys
import uuid

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


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

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

    # Create conversion action.
    conversion_action = conversion_action_operation.create

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

    # Create a value settings object.
    value_settings = conversion_action.value_settings
    value_settings.default_value = 15.0
    value_settings.always_use_default_value = True

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

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


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

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

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

add_conversion_action.py

Ruby

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

add_conversion_action.rb

Perl

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

use strict;
use warnings;
use utf8;

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

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

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

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

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

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

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

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

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

  return 1;
}

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

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

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

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

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

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

=pod

=head1 NAME

add_conversion_action

=head1 DESCRIPTION

This example illustrates adding a conversion action.

=head1 SYNOPSIS

add_conversion_action.pl [options]

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

=cut

add_conversion_action.pl

Les exemples précédents étant génériques par nature, voici des remarques supplémentaires. que ConversionAction est 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 achats qui se produisent sur un site Web.

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

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

Vous trouverez ci-dessous une liste d'actions de conversion recommandées. Nous vous recommandons en implémentant au moins les quatre premières actions de conversion d'autres actions recommandées que possible.

Vous pouvez également envisager d'implémenter événements supplémentaires pertinents pour les ventes en ligne. Pour un contrôle encore plus précis suivi des conversions, vous pouvez également créer d'autres actions de conversion actions de conversion (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). Secondaire Les actions de conversion offrent un suivi supplémentaire à vos marchands utilisées par Google Ads pour l'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 magasins Ajouter au panier ADD_TO_CART add_to_cart L'utilisateur ajoute un produit au panier
Fortement recommandé pour tous les créateurs de magasins Paiement initié BEGIN_CHECKOUT begin_checkout L'utilisateur commence le processus de paiement
Fortement recommandé pour tous les créateurs de magasins Afficher l'article PAGE_VIEW page_view L'utilisateur ouvre une page de produit
Fortement recommandé, le cas échéant (ne s'applique généralement pas aux outils de création de magasins) S'inscrire S'INSCRIRE sign_up L'utilisateur s'inscrit à un compte
Fortement recommandé, le cas échéant (ne s'applique généralement pas 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é, le cas échéant (ne s'applique généralement pas aux outils de création de magasins) 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 outils de création de magasins) Prendre rendez-vous BOOK_APPOINTMENT non applicable (personnalisé) L'utilisateur prend un rendez-vous
Fortement recommandé, le cas échéant (ne s'applique généralement pas aux outils de création de magasins) Demande de devis REQUEST_QUOTE non applicable (personnalisé) L'utilisateur envoie un formulaire pour demander une estimation du prix

Marchands disposant déjà d'un compte Ads

Si vous autorisez les marchands à intégrer un compte Ads existant, vous pouvez diffuser des annonces si le compte comporte déjà des actions de conversion. Nous ne recommandent d'utiliser une action de conversion existante, car rien ne garantit qu'elle a été correctement configuré. En outre, vous devez suivre des étapes supplémentaires afin de gérer ces scénarios potentiels:

  • Votre compte a plusieurs objectifs (par exemple, achats + pages vues + contacts) qui sont toutes définies comme "par défaut du compte". Lorsqu'une campagne est créée, par défaut optimise la campagne en fonction de tous ces objectifs. Vous ne voulez pas cela pour le Performance Max.

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

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

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

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

  3. À l'issue de l'étape 2, Google Ads aurait dû automatiquement mettre à jour la ConversionGoalCampaignConfig de la campagne de sorte que goal_config_level soit défini vers CAMPAIGN (au lieu de CUSTOMER, auquel cas la classe des objectifs par défaut du compte), mais nous vous conseillons de vérifier s'est produit.

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

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

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

  • Le event_snippet, qui doit être placé sur les pages Web indiquant une action de conversion telle qu'une page de confirmation de paiement ou d'envoi d'un prospect.

Vous pouvez récupérer ces deux parties à l'aide du service ConversionActionService.

La balise définit des cookies qui stockent un identifiant unique correspondant à un client ou à l'annonce clic ayant conduit le client sur le site. Les cookies reçoivent le clic sur l'annonce. les informations d'un paramètre d'identifiant de clic Google (GCLID) incluses dans la balise de suivi des conversions. Vous devez activer le site Web de l'annonceur et de suivi des prospects pour collecter et stocker le GCLID, qui correspond à l'identifiant unique Google Ads fournit pour chaque impression d'une annonce Google.

En savoir plus sur la balise globale et les emplacements pour l'installer

La balise Google (gtag.js) est un framework et une API de taggage qui vous permet envoyer les données d'événement à Google Ads et à Google Analytics Global site tag avec un extrait d'événement ou de numéro de téléphone pour suivre des conversions. Ajouter la balise Google à la section <head> de chaque page sur le site de l'annonceur et le configurer pour qu'il fonctionne avec Google Ads. Vous pouvez ensuite Utilisez des commandes gtag() pour capturer des événements et envoyer des données à Google Ads. Pour en savoir plus, consultez Utilisez le global site tag pour le suivi des conversions Google Ads.

Vous utiliserez les commandes suivantes avec la balise Google:

  • config:permet d'initialiser un produit Google (Google Ads, Analytics, etc.), configurer les paramètres et se préparer à envoyer des données à un compte.

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

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

L'exemple suivant est un extrait de code JavaScript du global site tag permettant envoyer des données à Google Ads. La valeur de l'espace réservé GOOGLE_CONVERSION_ID est une un identifiant 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 code de la balise Google ne doit apparaître qu'une seule fois par page. S'il existe un instance de gtag.js, vous devez ajouter les nouveaux ID de balise à la balise existante. Pour envoyer données à plusieurs comptes, vous pouvez ajouter un appel à la commande pour chaque compte que vous utilisez, en spécifiant l'ID de conversion de chaque compte, comme indiqué dans l'exemple suivant:

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

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

Pour que le suivi des conversions d'achat fonctionne, 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 l'ordre page de confirmation. Vous pouvez l'ajouter où vous le souhaitez dans le code, après le global tag. extrait. Extraits d'événement pour les actions de conversion secondaires (par exemple, "Add to cart") doivent être placés sur les pages correspondantes.

Dans l'exemple d'extrait ci-dessous, AW-CONVERSION_ID et gTag_developer_ID correspond à l'ID de conversion propre à votre compte Google Ads et à votre compte Baliser le compte de développeur, tandis que AW-CONVERSION_LABEL correspond à la 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 les informations telles qu'elles sont disponibles pour chaque événement. En savoir plus sur les paramètres sont disponibles pour chaque type d'événement.

Les paramètres fournissent des informations supplémentaires sur les interactions des utilisateurs. avec votre site Web ou 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 à la place:

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

La balise Google intègre une API Consent pour gérer le consentement des utilisateurs. Il est capable de différencier le consentement de l'utilisateur pour les cookies pour les annonces et pour l'analyse objectifs.

Le résultat attendu est que les clients obtiennent au moins le code gtag('consent', 'update' {...}) appel intégré sans aucune action requise de la part du client. Cela devrait Utiliser les balises Google (Google Ads, Floodlight, Google Analytics, Conversion Linker) peuvent lire le dernier état du consentement de l'utilisateur et l'inclure dans l'état à Google (via le paramètre &gcs).

D'autres étapes d'implémentation consisteraient à procéder au déploiement ou à aider les annonceurs déployer (par exemple, via une interface utilisateur) l'état gtag('consent', default' {...}) et en débloquant les balises Google (par exemple, pas de déclenchement conditionnel basé sur le consentement) pour activer le mode Consentement pour les déclencher tout en tenant compte du consentement.

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

Conseils

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

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

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

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