4.1.5 Acompanhamento de conversões

Valor e impacto nos negócios

---

Para fornecer de maneira eficaz o machine learning e as funcionalidades avançadas do ecossistema do Google para as campanhas publicitárias dos seus clientes, você precisa fazer análises de remarketing e de acompanhamento nos sites dos clientes.

Uma conversão no Google Ads ocorre quando um usuário realiza alguma ação específica. depois de clicar em um anúncio, como a compra de um produto, a instalação de um app para dispositivos móveis, ou se inscrever em uma lista de e-mails. O acompanhamento de conversões fornece insights importantes nos dados dos usuários, após visualizar ou clicar em um anúncio, incluindo informações sobre calcular e comparar o retorno do investimento (ROI) para ajudar seus clientes tomar decisões sobre onde concentrar os gastos com publicidade. O acompanhamento também ajuda a garantir que os dados estejam disponíveis para fins de reconciliação. Os pedidos variam de acordo com o produto ou a categoria. Sendo assim, o acompanhamento de conversões também pode ser útil para mostrar como grupos de produtos anunciados específicos estão gerando vendas.

Uma meta de conversão é um grupo de ações de conversão com o mesmo do seu objetivo. Por exemplo, "Compra" pode ser uma meta de conversão "Compras no site" e "Vendas na loja" como ações de conversão.

As ações de conversão ainda são usadas para acompanhar conversões e otimizar o campanha. Você cria ações de conversão, e o Google as agrupa nas conversões metas.

Ação de conversão de compra

A implementação do acompanhamento de conversões descrito aqui ativa a conta do Google Ads para medir o número de conversões de compra e o valor dessas conversões. Sem o acompanhamento de conversões, não é possível medir o valor comercial que a campanha está gerando em termos de ROAS (retorno do investimento em publicidade) gastos com publicidade). Ele também envia outros indicadores de dados que permitem à campanha para otimizar o desempenho.

Outras ações de conversão

Embora a ação de conversão de compra seja necessária apenas, o acompanhamento as ações de conversão podem fornecer mais insights aos seus comerciantes. Qa recomendamos registrar tudo o que for possível e implementar o máximo possível principais ações de conversão. Há uma lista completa das ações de conversão recomendadas descritas na seção de orientação da API Tech.

Em geral, a recomendação é capturar o seguinte:

• Qualquer evento de sucesso diretamente associado ao valor
• Eventos de sucesso que contribuem para as conversões principais, como add_to_cart e sign_up.
• Engajamentos e interações do usuário que ajudam os anunciantes a entender a comunicação com os usuários finais

As ações de conversão secundárias são apenas para observação e geração de relatórios. afetam os lances.Saiba mais sobre as ações de conversão principais e secundárias.

Orientação sobre UX

---

Para minimizar o risco de erros, recomendamos que você implemente programaticamente sem informações do comerciante, mas garanta que os comerciantes sabem que o acompanhamento de conversões foi configurado.

Observação :os comerciantes precisam oferecer aos usuários informações claras e informações abrangentes sobre os dados que coletam em seus sites; e obter consentimento para essa coleta, conforme os requisitos legais (consulte, exemplo, a Política de consentimento de usuários da União Europeia). Se você já tem um banner está ativada, verifique se ela usa o modo de consentimento para ajustar o comportamento das tags. Se houver não há banner ou o banner não usa o modo de consentimento, um plano de da plataforma (CMP) é recomendado para fazer o melhor esforço para que o consentimento é coletado por um banner e sinalizado ao Google com o modo de consentimento.

Quando os comerciantes vinculam uma conta do Google Ads, recomendamos exibir notificação de que a conta pode já ter o acompanhamento de conversões configuração, já que pode haver conflitos que precisam ser resolvidos. Um exemplo é mostrado a seguir.

Orientação técnica

---

Veja como o acompanhamento de conversões funciona. Esta seção explica melhor cada etapa:

1. Você cria uma 'ConversionAction' na conta do Google Ads do comerciante para acompanhar as compras (e, opcionalmente, outras ações do cliente) feitas no site.

2. Você adiciona a tag ou o snippet de código dessa ação de conversão a um site ou aplicativo para dispositivos móveis. Para mais detalhes, consulte o artigo Configurar o acompanhamento de conversões do site.

3. Quando um cliente clica no anúncio, um cookie temporário é colocado na página computador ou dispositivo móvel do cliente.

4. Quando o cliente concluir a ação definida para o anunciante, o Google reconhece o cookie (por meio do snippet de código adicionado) e registra uma conversão com outros parâmetros, como "valor" se apropriado.

Pré-requisitos

Antes de começar, confira se você tem um ID de desenvolvedor da tag do Google. Se você não tiver um ID de desenvolvedor da tag do Google, preencha Formulário de solicitação de ID do desenvolvedor da tag do Google. Seu ID de desenvolvedor é diferente de outros IDs, como o de métricas ou de conversão, que seu final que os usuários adicionam ao código de medição do site.

Criar e configurar ações de conversão

Os exemplos a seguir mostram como criar e adicionar uma ação de conversão uma conta do Google Ads. Cada exemplo lida com todas as tarefas de autenticação em segundo plano para e ajuda a criar uma ação de conversão:

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
      

Como os exemplos anteriores são de natureza genérica, veja estas observações adicionais para que se a ConversionAction está configurada corretamente para as campanhas Performance Max. Cada uma das suas ações de conversão precisa ser configurada da seguinte maneira:

• Type: define ConversionActionType como WEBPAGE, porque essas compras eventos que estão ocorrendo em um site.

• Para lance: defina como true para seu anúncio principal ação de conversão (compra) para otimizar campanhas com foco em vendas. Para ações de conversão secundárias (por exemplo, "adicionar ao carrinho"), Defina o valor como false.

• Categoria: para cada uma das suas ações de conversão (principais ou secundário),defina a ConversionActionCategory. Confira abaixo a categoria de ação de conversa relevante para cada uma das sete ações de conversão que recomendamos implementar. O Google Ads atribui automaticamente as conversões ações para uma meta de conversão padrão com base na categoria. Por exemplo, as ações de conversão de compra são atribuídas à meta de conversão padrão "Compras". Depois, você pode configurar a campanha Performance Max campanha otimizar para essa meta de compras.

Confira abaixo uma lista de ações de conversão recomendadas. Recomendamos implementar pelo menos as quatro primeiras ações de conversão e o maior número possível outras ações recomendadas possíveis.

Você também pode considerar a implementação eventos adicionais relevantes para vendas on-line. Para dados ainda mais acompanhamento de conversões, você também pode criar ações de conversão adicionais ou ações Ações de conversão (por exemplo, uma ação para "adicionar informações de pagamento" cada vez que um usuário utiliza a opção de pesquisa no site, ou uma ação para "pesquisar" sempre que um usuário utiliza a opção de pesquisa no site). Secundários as ações de conversão fornecem um acompanhamento adicional para seus comerciantes e são usados pelo Google Ads para observação.

Prioridade	Ação de conversão	Categoria da ação de conversão	Nome do evento da tag do Google	Descrição
Obrigatório	Compra	COMPRAR	purchase	O usuário conclui uma compra
Recomendado para todos os criadores de lojas	Adicionar ao carrinho	ADD_TO_CART	add_to_cart	O usuário adiciona um produto ao carrinho
Recomendado para todos os criadores de lojas	Iniciar finalização de compra	BEGIN_CHECKOUT	begin_checkout	O usuário inicia o processo de finalização da compra
Recomendado para todos os criadores de lojas	Mostrar item	PAGE_VIEW	page_view	O usuário abre a página de um produto
Altamente recomendado quando aplicável (geralmente não se aplica a construtoras de lojas)	Inscrever-se	INSCRIÇÃO	sign_up	O usuário se inscreve em uma conta
Altamente recomendado quando aplicável (geralmente não se aplica a construtoras de lojas)	Gerar lead	SUBMIT_LEAD_FORM	generate_lead	O usuário gera um lead usando um formulário
Altamente recomendado quando aplicável (geralmente não se aplica a construtoras de lojas)	Inscrever-se	SUBSCRIBE_PAID	não aplicável (personalizado)	O usuário assina um serviço pago
Altamente recomendado quando aplicável (geralmente não se aplica a construtoras de lojas)	Agendar horário	BOOK_APPOINTMENT	não aplicável (personalizado)	O usuário agenda um horário
Altamente recomendado quando aplicável (geralmente não se aplica a construtoras de lojas)	Solicitar cotação	REQUEST_QUOTE	não aplicável (personalizado)	O usuário envia um formulário solicitando uma estimativa de preço

Observação :as campanhas Performance Max exigem metas de conversão na conta ou no nível da campanha. O Google Ads cria CustomerConversionGoals automaticamente e CampaignConversionGoals ao adicionar ações de conversão à sua conta.

Comerciantes que têm uma conta do Google Ads

Se você permitir que os comerciantes integrem uma conta do Google Ads, poderá exibir quando a conta já tem ações de conversão. Nós não usar uma ação de conversão atual, porque não há garantia de que ela foi configurado corretamente. Além disso, há etapas extras que você precisa seguir para lidar com estes possíveis cenários:

• A conta tem várias metas (por exemplo, Compras + Visualizações de página + Contatos) marcadas como "padrão da conta". Quando uma nova campanha é criada, ela o padrão é otimizar todos esses objetivos. Você não quer isso para campanha Performance Max.

• A conta já tem uma (ou mais) ação de conversão para acompanhar compras e ela já estará agrupada na meta Compras. Isso significa que, depois que você as duplicações da campanha contabilizam uma compra, porque duas tags de conversão estão sendo disparadas.

Para garantir que a campanha Performance Max use sua ação de conversão personalizada e apenas essa ação:

1. Crie uma CustomConversionGoal e adicione sua ação de conversão de compra à lista de conversion_actions[] da meta. Defina o status como ATIVADO.

2. Na ConversionGoalCampaignConfig da campanha Performance Max, defina custom_conversion_goal à meta personalizada que você criou na etapa (1).

3. Como resultado da etapa (2), o Google Ads deve ter atualizado automaticamente os ConversionGoalCampaignConfig da campanha de modo que goal_config_level seja definido para CAMPAIGN (em vez de CUSTOMER, que o direcionaria para usar o método padrão da conta, mas é importante verificar se esse acontecido.

Recuperar a tag da ação de conversão

Depois de criar a ação de conversão, você precisa inserir o snippet de código correspondente chamado tag para a página de conversão site do anunciante. Para garantir que o Google Ads possa medir todas as conversões independentemente do navegador do cliente, use o atualização da tag de acompanhamento de conversões do Google Ads. Essa tag consiste em duas partes:

• O global_site_tag, que precisa ser instalado em todas as páginas do site do anunciante.

• O event_snippet, que precisa ser colocado em páginas da Web que indicam uma uma ação de conversão, como uma confirmação de finalização da compra ou página de envio de lead.

É possível recuperar essas duas partes com ConversionActionService.

A tag define cookies que armazenam um identificador exclusivo de um cliente ou do anúncio clique que levou o cliente ao site. Os cookies recebem o clique no anúncio informações de um parâmetro identificador de clique do Google (GCLID) incluídas na tag de acompanhamento de conversões. Você deve ativar o site e as configurações sistema de acompanhamento de leads para capturar e armazenar o GCLID, que é o ID exclusivo que O Google Ads fornece todas as impressões de um anúncio do Google.

Mais informações sobre a tag global e onde ela pode ser instalada

A tag do Google (gtag.js) é uma API e estrutura de inclusão de tags que permite enviar dados de eventos para o Google Ads e o Analytics. Tag global do site funciona em conjunto com um snippet de evento ou um snippet de telefone para acompanhar seus e conversões. Adicione a tag do Google à seção <head> de cada página. no site do anunciante e configurá-lo para funcionar com o Google Ads. É possível usar comandos gtag() para capturar eventos e enviar dados ao Google Ads. Para entender como isso funciona, consulte Use a tag global do site para o acompanhamento de conversões do Google Ads.

Você usa os seguintes comandos com a tag do Google:

• config: inicializar um produto do Google (Google Ads, Google Analytics etc.) definir configurações e se preparar para enviar dados para uma conta.

• event: registra uma conversão enviando um evento como comprar (recomendado) ou adicionar a um carrinho de compras (ações de conversão secundárias). Recomendamos que você consulte o Guia de referência de eventos da gtag.js.

• set: define parâmetros comuns a todos os eventos na página, como a moeda.

O exemplo a seguir é um snippet de código JavaScript da tag global do site para enviar dados para o Google Ads. O valor do marcador GOOGLE_CONVERSION_ID é um ID numérico exclusivo para uma única conta do anunciante.

<!-- 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>

O snippet de tag do Google deve aparecer apenas uma vez por página. Se já houver instância da gtag.js, adicione novos IDs à tag atual. Para enviar a várias contas, você pode adicionar uma chamada ao "config" para cada conta que você está usando, especificando o ID de conversão de cada conta, conforme mostrado no exemplo a seguir:

<!-- 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>

Mais informações sobre o snippet de evento e onde instalá-lo

Para que o acompanhamento de conversões de compra funcione, o snippet de evento de compra deve ser instalado na própria página de conversão. Geralmente, essa é a ordem página de confirmação. Ele pode ser colocado em qualquer lugar do código, após a tag global. snippet. Snippets de evento para ações de conversão secundárias (por exemplo: adicionar ao carrinho) devem ser colocados nas respectivas páginas.

No exemplo de snippet abaixo, AW-CONVERSION_ID e gTag_developer_ID são o ID de conversão exclusivo da sua conta do Google Ads e o ID do Conta de desenvolvedor de tags, enquanto AW-CONVERSION_LABEL é a conversão exclusivo por ação de conversão:

<!-- 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>

Embora alguns parâmetros sejam opcionais, é recomendável incluir o máximo possível as informações disponíveis para cada evento. Saiba mais sobre quais parâmetros estão disponíveis para cada tipo de evento.

Os parâmetros fornecem mais informações sobre como os usuários interagem com seu site ou app.

Se você quiser medir um evento de conversão com base em um clique (Por exemplo, em um botão ou em uma resposta dinâmica para um site que usa AJAX), Você também pode usar o seguinte snippet:

<!-- 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>

Implementar a API de consentimento (também conhecida como modo de consentimento)

A tag do Google tem uma API integrada para gerenciar o consentimento do usuário. Ele é capaz de diferenciar o consentimento do usuário para uso de cookies para fins publicitários e de análise propósitos.

O resultado esperado é que os clientes recebam pelo menos a gtag('consent', 'update' {...}) chamada integrada sem que o cliente precise fazer nada. Isso deve Garantir que as tags do Google (Google Ads, Floodlight, Google Analytics, Vinculador de conversões) podem ler o estado de consentimento do usuário mais recente e incluir esse estado na rede; Solicitações ao Google (pelo parâmetro &gcs).

Outras etapas de implementação incluem implantar ou ajudar os anunciantes na Implante (por exemplo, por uma interface) o estado da gtag('consent', default' {...}) e desbloquear as tags do Google (por exemplo, sem disparo condicional com base no consentimento) para ativar o modo de consentimento para demiti-los reconhecendo o consentimento.

Confira os detalhes da implementação em Gerenciar configurações de consentimento (Web).

Dicas

Na conta de administrador do Google Ads,você pode acompanhar as conversões em todas contas de anunciantes usando uma única tag de código de conversão. Consulte sobre o acompanhamento de conversões de várias contas.

A melhor maneira de testar se a implementação do acompanhamento de conversões é está trabalhando é ir até um dos seus comerciantes sites (ou um site de teste interno) e fazer uma compra real. Em seguida, observe na ferramenta do Assistente de tags do Google. para usar este guia de solução de problemas para verificar se o Google Ads viu a tag e está registrando as conversões. Para saber mais, consulte Resolver problemas de inclusão de tag em todo o site.

Você pode complementar a tag de conversão anterior com conversões otimizadas. o que pode melhorar a precisão da medição de conversões e ter lances mais eficientes. Saiba como configurar conversões otimizadas. Antes de implementar as conversões otimizadas, você deve garantir que seus comerciantes obedeçam às políticas de dados do cliente para conversões otimizadas no Google Ads.