4.1.5 Seguimiento de conversiones

Valor e impacto empresarial

A fin de proporcionar de manera eficaz las potentes estadísticas y el aprendizaje automático del ecosistema de Google para las campañas publicitarias de tus clientes de comercios, debes colocar el seguimiento de conversiones y las etiquetas de remarketing en los sitios web de los clientes.

Una conversión en Google Ads ocurre cuando un usuario realiza una acción específica después de hacer clic en un anuncio, como comprar un producto, instalar una app para dispositivos móviles o registrarse en una lista de direcciones de correo electrónico. El seguimiento de conversiones proporciona estadísticas clave sobre las acciones de los usuarios después de ver un anuncio o hacer clic en él, lo que incluye información para calcular y comparar el retorno de la inversión (ROI) a fin de ayudar a los clientes a tomar decisiones sobre dónde enfocar la inversión publicitaria. El seguimiento también ayuda a garantizar que los datos estén disponibles para fines de conciliación. Los pedidos difieren según el producto o la categoría, por lo que el seguimiento de conversiones también puede ser útil para mostrar cómo grupos de fichas específicos se convierten en ventas.

Un objetivo de conversión es un grupo de acciones de conversión con el mismo objetivo subyacente. Por ejemplo, "Compra" puede ser un objetivo de conversión que tenga "Compras en el sitio web" y "Ventas en la tienda" como acciones de conversión.

Las acciones de conversión todavía se utilizan para hacer un seguimiento de las conversiones y optimizar la campaña. Tú creas acciones de conversión y Google las agrupa en objetivos de conversión.

Acción de conversión por compras

Implementar el seguimiento de conversiones que se describe aquí permite que la cuenta de Google Ads de tu comercio mida la cantidad de conversiones por compras y el valor de estas. Sin el seguimiento de conversiones, no podrás medir el valor comercial que genera la campaña en términos de ROAS (retorno de la inversión publicitaria). También envía indicadores de datos adicionales que permiten a la campaña optimizar el rendimiento.

Otras acciones de conversión

Si bien solo se requiere una acción de conversión por compras, el seguimiento de acciones de conversión adicionales puede proporcionar estadísticas adicionales para tus comercios. Te recomendamos que registres todo lo posible, a la vez que implementas la mayor cantidad de acciones de conversión principales. En la sección de orientación de la API de tecnología, se describe una lista completa de las acciones de conversión recomendadas.

En general, se recomienda capturar lo siguiente:

  • Cualquier evento de éxito asociado directamente con el valor
  • Eventos de éxito que contribuyen a las conversiones principales, como add_to_cart y sign_up.
  • Las interacciones y las interacciones de los usuarios que ayudan a los anunciantes a comprender cómo atraen a sus usuarios finales

Las acciones de conversión secundarias solo tienen fines de observación y generación de informes y afectan las ofertas.Obtén más información sobre las acciones de conversión principales y secundarias.

Orientación en UX

Para minimizar el riesgo de errores, te recomendamos que implementes el seguimiento de conversiones de manera programática sin la entrada del comercio, pero debes asegurarte de que los comercios sepan que se configuró el seguimiento de conversiones.

Cuando los comercios vinculan una cuenta de Google Ads existente, les recomendamos que muestren una notificación que indique que es posible que el seguimiento de conversiones ya esté configurado en su cuenta, ya que podría haber conflictos que deban resolverse. A continuación, se muestra un ejemplo.

connect_your_google_ads_account

Orientación técnica

A continuación, te mostramos cómo funciona el seguimiento de conversiones. En esta sección, se profundiza en cada paso:

  1. Tú creas una 'ConversionAction' en la cuenta de Google Ads de tu comercio para hacer un seguimiento de las compras (y, opcionalmente, otras acciones de los clientes) realizadas en su sitio web.

  2. Solo debes agregar la etiqueta o el fragmento de código de esa acción de conversión a un sitio web o una app para dispositivos móviles. Para obtener más detalles, consulta Cómo configurar el seguimiento de conversiones en tu sitio web.

  3. Cuando un cliente hace clic en el anuncio, se coloca una cookie temporal en la computadora o el dispositivo móvil del cliente.

  4. Cuando el cliente completa la acción definida para el anunciante, Google reconoce la cookie (a través del fragmento de código agregado) y registra una conversión junto con otros parámetros, como "valor", si corresponde.

Requisitos previos

Antes de comenzar, asegúrate de tener un ID de desarrollador de la etiqueta de Google. Si no tienes un ID de desarrollador de la etiqueta de Google, completa el formulario de solicitud de ID de desarrollador de la etiqueta de Google. Tu ID de desarrollador es diferente de otros ID, como el ID de medición o el ID de conversión, que los usuarios finales agregan al código de medición de su sitio web.

Cómo crear y configurar acciones de conversión

En los siguientes ejemplos, se muestra cómo crear una acción de conversión y agregarla a una cuenta de Google Ads. En cada muestra, se manejan todas las tareas de autenticación en segundo plano por ti y se explica cómo crear una acción de conversión:

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

Dado que los ejemplos anteriores son de naturaleza genérica, a continuación se incluyen notas adicionales para que la ConversionAction se configure correctamente para la campaña de máximo rendimiento. Cada una de tus acciones de conversión debe configurarse de la siguiente manera:

  • Type: Configura ConversionActionType como WEBPAGE, ya que estos eventos de compras ocurren en un sitio web.

  • Apto para oferta: Configúralo en true para tu acción de conversión principal (compra) a fin de optimizar las campañas en función de las ventas. Para las acciones de conversión secundarias (p. ej., agregar al carrito), establece el valor en false.

  • Category: Para cada una de tus acciones de conversión (primaria o secundaria),configura la ConversionActionCategory. A continuación, puedes encontrar la categoría de acción de conversación relevante para cada una de las 7 acciones de conversión que recomendamos implementar. Ten en cuenta que Google Ads asigna automáticamente acciones de conversión a un objetivo de conversión estándar según su categoría. Por ejemplo, las acciones de conversión por compras se asignan al objetivo de conversión estándar llamado "Compras". Más adelante, puedes configurar la campaña de máximo rendimiento para que se optimice en función de este objetivo de compras.

A continuación, encontrará una lista de acciones de conversión recomendadas. Te recomendamos que implementes al menos las primeras cuatro acciones de conversión y tantas de las otras acciones recomendadas como sea posible.

También puedes implementar eventos adicionales relevantes para las ventas en línea. Para obtener un seguimiento aún más detallado, también puedes crear acciones de conversión adicionales o personalizadas (por ejemplo, una acción para "agregar información de pago" cada vez que un usuario utiliza la opción de búsqueda en el sitio web o una acción para "buscar" cada vez que un usuario utiliza la opción de búsqueda en el sitio web). Las acciones de conversión secundarias proporcionan un seguimiento adicional para tus comercios, y Google Ads las utiliza con fines de observación.

Prioridad Acción de conversión Categoría de acción de conversión Nombre del evento de la etiqueta de Google Descripción
Obligatoria Comprar COMPRAS purchase El usuario completa una compra
Muy recomendada para todos los creadores de tiendas Agregar al carrito ADD_TO_CART add_to_cart El usuario agrega un producto al carrito
Muy recomendada para todos los creadores de tiendas Inicio de confirmación de compra BEGIN_CHECKOUT begin_checkout El usuario inicia el proceso de confirmación de la compra
Muy recomendada para todos los creadores de tiendas Ver elemento PAGE_VIEW page_view El usuario abre la página de un producto
Muy recomendada cuando corresponde (no suele aplicarse a los creadores de tiendas) Registrarse REGISTRARSE sign_up El usuario se registra para obtener una cuenta
Muy recomendada cuando corresponde (no suele aplicarse a los creadores de tiendas) Generar clientes potenciales SUBMIT_LEAD_FORM generate_lead El usuario genera un cliente potencial a través de un formulario.
Muy recomendada cuando corresponde (no suele aplicarse a los creadores de tiendas) Suscribirse SUBSCRIBE_PAID no aplicable (personalizado) El usuario se suscribe a un servicio pagado
Muy recomendada cuando corresponde (no suele aplicarse a los creadores de tiendas) Reservar cita BOOK_APPOINTMENT no aplicable (personalizado) El usuario reserva una cita
Muy recomendada cuando corresponde (no suele aplicarse a los creadores de tiendas) Solicitar cotización REQUEST_QUOTE no aplicable (personalizado) El usuario envía un formulario para solicitar una estimación de precio.

Comercios que ya tienen una cuenta de Google Ads

Si permites que los comercios se integren a una cuenta de Google Ads existente, es posible que la cuenta ya tenga acciones de conversión. No recomendamos utilizar una acción de conversión existente, ya que no hay garantía de que se haya configurado correctamente. Además, debes seguir algunos pasos adicionales para controlar estas situaciones posibles:

  • La cuenta tiene varios objetivos (por ejemplo, Compras + Vistas de página + Contactos) que están marcados como "predeterminados de la cuenta". Cuando se crea una campaña nueva, de forma predeterminada se optimiza en función de todos estos objetivos. No es conveniente hacerlo en la campaña de máximo rendimiento.

  • La cuenta ya tiene una (o más) acciones de conversión para hacer un seguimiento de las compras y ya está agrupada en el objetivo Compras. Esto significa que después de que la campaña registra una compra por duplicado, porque hay dos etiquetas de conversión que se activan.

Para asegurarte de que la campaña de máximo rendimiento utilice tu acción de conversión personalizada y solo esa acción, haz lo siguiente:

  1. Crea un CustomConversionGoal y agrega tu acción de conversión por compras a la lista de conversion_actions[] del objetivo. Establece el estado en HABILITADO.

  2. En el campo ConversionGoalCampaignConfig de la campaña de máximo rendimiento, establece custom_conversion_goal en el objetivo personalizado que creaste en el paso (1).

  3. Como resultado del paso (2), Google Ads debería haber actualizado automáticamente el parámetro ConversionGoalCampaignConfig de la campaña para que goal_config_level esté configurado como CAMPAIGN (en lugar de CUSTOMER, que lo indicaría para usar los objetivos predeterminados de la cuenta), pero vale la pena verificar que esto haya ocurrido realmente.

Cómo recuperar la etiqueta de la acción de conversión

Una vez que hayas creado la acción de conversión, debes insertar el fragmento de código correspondiente llamado etiqueta en la página de conversión del sitio web del anunciante. Para asegurarte de que Google Ads pueda medir todas las conversiones, independientemente del navegador del cliente, utiliza la etiqueta del seguimiento de conversiones actualizada de Google Ads. Esta etiqueta consta de dos partes:

  • El global_site_tag, que debe instalarse en todas las páginas del sitio web del anunciante

  • El event_snippet, que se debe colocar en las páginas web que indican una acción de conversión, como una confirmación de la confirmación de la compra o la página de envío de un cliente potencial

Puede recuperar estas dos partes con ConversionActionService.

La etiqueta configura cookies que almacenan un identificador único para un cliente o el clic en el anuncio que llevó al cliente al sitio. Las cookies reciben la información del clic en el anuncio de un parámetro del identificador de clics de Google (GCLID) incluido en la etiqueta del seguimiento de conversiones. Debes habilitar el sitio web y el sistema de seguimiento de clientes potenciales del anunciante para captar y almacenar el GCLID, que es el ID único que proporciona Google Ads para cada impresión de un anuncio de Google.

Más información sobre la etiqueta global y dónde instalarla

La etiqueta de Google (gtag.js) es un framework y una API de etiquetado que te permiten enviar datos de eventos a Google Ads y Google Analytics. La etiqueta global del sitio funciona en conjunto con un fragmento de evento o de teléfono para hacer un seguimiento de sus conversiones. Agrega la etiqueta de Google a la sección <head> de cada página en el sitio del anunciante y configúrala para que funcione con Google Ads. Luego, puedes usar los comandos de gtag() para capturar eventos y enviar datos a Google Ads. Para comprender cómo funciona esto, consulta el artículo Cómo utilizar la etiqueta global del sitio para el seguimiento de conversiones de Google Ads.

Puedes usar los siguientes comandos con la etiqueta de Google:

  • config: Inicializa un producto de Google (Google Ads, Analytics, etc.), establece la configuración y prepárate para enviar datos a una cuenta.

  • evento: Registra una conversión mediante el envío de un evento, como una compra (recomendado) o el agregado a un carrito de compras (acciones de conversión secundarias). Te recomendamos que revises la guía de referencia de eventos de gtag.js.

  • set: Establece parámetros comunes a todos los eventos en la página, como la moneda.

El siguiente ejemplo es un fragmento de código JavaScript de la etiqueta global del sitio para enviar datos a Google Ads. El valor del marcador de posición GOOGLE_CONVERSION_ID es un ID numérico único de una sola cuenta de 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>

El fragmento de la etiqueta de Google debe aparecer solo una vez por página. Si hay una instancia existente de gtag.js, debes agregar los IDs de etiqueta nuevos a la etiqueta existente. A fin de enviar datos a varias cuentas, puedes agregar una llamada al comando “config” para cada cuenta que uses y especificar el ID de conversión de cada cuenta, como se muestra en el siguiente ejemplo:

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

Más información sobre el fragmento de evento y dónde instalarlo

Para que el seguimiento de conversiones por compras funcione, el fragmento de evento de compra debe instalarse en la página de conversión. Por lo general, es la página de confirmación del pedido. Se puede colocar en cualquier parte del código, después del fragmento de la etiqueta global. Los fragmentos de evento para las acciones de conversión secundarias (por ejemplo: agregar al carrito) deben colocarse en las páginas respectivas.

En el siguiente fragmento de ejemplo, AW-CONVERSION_ID y gTag_developer_ID representan el ID de conversión único de tu cuenta de Google Ads y tu cuenta de desarrollador de la etiqueta de Google, mientras que AW-CONVERSION_LABEL significa la etiqueta de conversión, que es única para cada acción de conversión:

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

Si bien algunos parámetros son opcionales, se recomienda que incluyas toda la información disponible para cada evento. Obtén más información sobre qué parámetros están disponibles para cada tipo de evento.

Los parámetros proporcionan información adicional sobre las formas en las que los usuarios interactúan con tu sitio web o app.

Si deseas medir un evento de conversión en función de un clic (p. ej., en un botón o una respuesta dinámica para un sitio que usa AJAX), también puedes usar el siguiente fragmento:

<!-- 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 etiqueta de Google tiene una API de consentimiento integrada para administrar el consentimiento de los usuarios. Es capaz de diferenciar el consentimiento del usuario para las cookies con fines publicitarios y el consentimiento con fines estadísticos.

El resultado esperado es que los clientes obtengan, al menos, la llamada gtag('consent', 'update' {...}) integrada sin que el cliente deba realizar ninguna acción. Esto debería garantizar que las etiquetas de Google (Google Ads, Floodlight, Google Analytics y el vinculador de conversiones) puedan leer el estado de consentimiento del usuario más reciente, además de incluirlo en las solicitudes de red a Google (a través del parámetro &gcs).

Los pasos de implementación adicionales serían implementar o ayudar a los anunciantes a implementar (p.ej., a través de una IU) el estado gtag('consent', default' {...}) y desbloquear las etiquetas de Google (por ejemplo, sin activación condicional basada en consentimiento) para habilitar el modo de consentimiento a fin de activar estas funciones de manera optimizada para otorgar consentimiento.

Para conocer los detalles de la implementación, consulta Cómo administrar la configuración de consentimiento (Web).

Sugerencias

Desde la cuenta de administrador de Google Ads,puedes hacer un seguimiento de las conversiones en todas tus cuentas de anunciante mediante una sola etiqueta de código de conversión. Consulta el artículo Acerca del seguimiento de conversiones de múltiples cuentas.

La mejor manera de probar si tu implementación del seguimiento de conversiones funciona es ir al sitio web de uno de tus comercios (o de prueba interna) y realizar una compra real. Luego, puedes observar en la herramienta Google Tag Assistant usar esta guía de solución de problemas para verificar que Google Ads haya visto tu etiqueta y registre las conversiones de forma correcta. Si deseas obtener más información, consulta el artículo para solucionar problemas relacionados con el etiquetado para sitio completo.

Puedes complementar la etiqueta de conversión anterior con conversiones avanzadas, lo que puede mejorar la precisión de la medición de conversiones y permitir establecer ofertas más eficaces. Obtén más información sobre cómo configurar las conversiones avanzadas. Antes de implementar las conversiones avanzadas, debes asegurarte de que tus comercios puedan satisfacer las políticas de datos del cliente relacionadas con las conversiones avanzadas en Google Ads.

Anterior
Cómo vincular una cuenta de Google Ads
Siguiente
4.2 Creación de campañas publicitarias