4.1.5 Śledzenie konwersji

Wartość i wpływ na działalność

Aby skutecznie korzystać z zaawansowanych systemów uczących się i narzędzi analitycznych z ekosystemu Google do kampanii reklamowych klientów, musisz umieścić w ich witrynach tagi śledzenia konwersji i tagi remarketingowe.

Konwersja w Google Ads ma miejsce, gdy użytkownik po kliknięciu reklamy wykonuje określone działanie, np. kupuje produkt, instaluje aplikację mobilną lub rejestruje się na liście e-mailowej. Śledzenie konwersji zapewnia kluczowy wgląd w działania użytkowników po obejrzeniu lub kliknięciu reklamy, w tym dane umożliwiające obliczanie i porównywanie zwrotu z inwestycji (ROI), co pomaga klientom w podjęciu decyzji, na czym warto przeznaczyć wydatki na reklamę. Śledzenie pomaga też zapewnić dostęp do danych na potrzeby uzgodnienia. Zamówienia różnią się w zależności od produktu lub kategorii, więc śledzenie konwersji może również pomóc w ustaleniu, w jaki sposób konkretne grupy informacji o produktach przekładają się na sprzedaż.

Cel konwersji to grupa działań powodujących konwersję z tym samym podstawowym celem. Na przykład cel konwersji „Zakup” może mieć ustawione działania powodujące konwersję „Zakupy w witrynie” i „Sprzedaż w sklepie”.

Działania powodujące konwersję służą nadal do śledzenia konwersji i optymalizowania kampanii. Tworzysz działania powodujące konwersję i grupujesz je w Google w celu konwersji.

Działanie powodujące konwersję polegającą na zakupie

Wdrożenie opisanego tutaj śledzenia konwersji umożliwia konto Google Ads sprzedawcy pomiar liczby konwersji polegających na zakupie i wartości tych konwersji. Bez śledzenia konwersji nie można zmierzyć wartości biznesowej generowanej przez kampanię pod kątem zwrotu z nakładów na reklamę (ROAS). Wysyła też dodatkowe sygnały danych, które umożliwiają kampanii optymalizację skuteczności.

Inne działania powodujące konwersję

Działanie powodujące konwersję polegającą na zakupie jest wymagane, ale śledzenie dodatkowych działań powodujących konwersję może dostarczyć sprzedawcom dodatkowych informacji. Zalecamy rejestrowanie wszystkiego, co jest możliwe, przy jednoczesnym implementowaniu jak największej liczby podstawowych działań powodujących konwersję. Pełną listę zalecanych działań powodujących konwersję znajdziesz w sekcji ze wskazówkami dotyczącymi interfejsu Tech API.

Ogólnie zalecamy rejestrowanie:

  • Każde zdarzenie sukcesu powiązane bezpośrednio z wartością
  • Zdarzenia sukcesu, które przyczyniają się do generowania podstawowych konwersji, np. add_to_cart i sign_up.
  • Zaangażowanie i interakcje użytkowników, które pomagają reklamodawcom zrozumieć, w jaki sposób ich angażują

Dodatkowe działania powodujące konwersję służą tylko do obserwacji i raportowania.Wpływają na określanie stawek.Dowiedz się więcej o głównych i dodatkowych działaniach powodujących konwersję

Wskazówki dotyczące UX

Aby zminimalizować ryzyko błędów, zalecamy wdrożenie śledzenia konwersji automatycznie bez udziału sprzedawcy. Upewnij się jednak, że sprzedawcy wiedzą, że śledzenie konwersji zostało skonfigurowane.

Gdy sprzedawca połączy dotychczasowe konto Google Ads, powiadom go, że na jego koncie może być już skonfigurowane śledzenie konwersji, ponieważ mogą występować konflikty, które trzeba rozwiązać. Przykład poniżej.

connect_your_google_ads_account

Wskazówki techniczne

Oto, jak działa śledzenie konwersji. W tej sekcji znajdziesz więcej informacji o poszczególnych krokach:

  1. Tworzysz na koncie Google Ads sprzedawcy zdarzenie „ConversionAction”, aby śledzić zakupy (i opcjonalnie inne działania klientów) dokonane w jego witrynie.

  2. Tag lub fragment kodu związany z tym działaniem powodującym konwersję dodajesz do witryny lub aplikacji mobilnej. Szczegółowe informacje znajdziesz w artykule Konfigurowanie śledzenia konwersji w witrynie.

  3. Gdy klient kliknie reklamę, na jego komputerze lub urządzeniu mobilnym zostanie umieszczony tymczasowy plik cookie.

  4. Gdy klient wykona działanie określone dla reklamodawcy, Google rozpoznaje plik cookie (przez dodany fragment kodu) i w razie potrzeby rejestruje konwersję razem z innymi parametrami, np. „value”.

Wymagania wstępne

Zanim zaczniesz, upewnij się, że masz identyfikator dewelopera tagu Google. Jeśli nie masz identyfikatora dewelopera tagu Google, wypełnij formularz prośby o identyfikator dewelopera tagu Google. Twój identyfikator dewelopera różni się od innych identyfikatorów, np. identyfikatora pomiaru lub identyfikatora konwersji, które użytkownicy dodają do swojego kodu pomiarowego witryny.

Tworzenie i konfigurowanie działań powodujących konwersję

Z podanych niżej przykładów dowiesz się, jak utworzyć działanie powodujące konwersję i dodać je do konta Google Ads. Każdy przykład przeprowadzi Cię przez wszystkie zadania związane z uwierzytelnianiem w tle i przeprowadzi Cię przez proces tworzenia działania powodującego konwersję:

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

Powyższe przykłady mają charakter ogólny, więc poniżej podajemy dodatkowe uwagi, które pomogą Ci prawidłowo skonfigurować element ConversionAction w kampanii Performance Max. Każde działanie powodujące konwersję należy skonfigurować w ten sposób:

  • Type – ustaw ConversionActionType na WEBPAGE, ponieważ te zdarzenia zakupów mają miejsce w witrynie.

  • Możliwość ustalania stawek – ustaw tę wartość na true jako główne działanie powodujące konwersję (zakup), aby optymalizować kampanie pod kątem sprzedaży. W przypadku dodatkowych działań powodujących konwersję (np.dodania do koszyka) ustaw wartość false.

  • Kategoria – dla każdego działania powodującego konwersję (głównego lub dodatkowego) ustaw ConversionActionCategory. Poniżej znajdziesz informacje o odpowiednich kategoriach działań w rozmowie dla każdego z 7 zalecanych przez nas działań powodujących konwersję. Pamiętaj, że Google Ads automatycznie przypisuje działania powodujące konwersję do standardowego celu konwersji na podstawie ich kategorii. Na przykład działania powodujące konwersję polegającą na zakupie są przypisane do standardowego celu konwersji o nazwie „Zakupy”. Później możesz skonfigurować kampanię Performance Max tak, aby była optymalizowana pod kątem tego celu Zakupy.

Poniżej znajdziesz listę zalecanych działań powodujących konwersję. Zalecamy wdrożenie co najmniej 4 pierwszych działań powodujących konwersję i jak największej liczby innych zalecanych działań.

Możesz też rozważyć wdrożenie dodatkowych zdarzeń istotnych dla sprzedaży online. Możesz też utworzyć dodatkowe działania powodujące konwersję lub niestandardowe działania powodujące konwersję (np. działanie polegające na dodaniu informacji o płatności za każdym razem, gdy użytkownik skorzysta z opcji wyszukiwania w witrynie lub działanie polegające na wyszukiwaniu za każdym razem, gdy użytkownik skorzysta z opcji wyszukiwania w witrynie). Dodatkowe działania powodujące konwersję umożliwiają sprzedawcom dodatkowe śledzenie i są wykorzystywane przez Google Ads do obserwacji.

Priorytet Działanie powodujące konwersję Kategoria działań powodujących konwersję Nazwa zdarzenia tagu Google Opis
Obowiązkowe Kup ZAKUP purchase Użytkownik finalizuje zakup
Zdecydowanie zalecany dla wszystkich właścicieli sklepów Dodawanie do koszyka ADD_TO_CART add_to_cart Użytkownik dodaje produkt do koszyka
Zdecydowanie zalecany dla wszystkich właścicieli sklepów Rozpoczęcie realizacji płatności BEGIN_CHECKOUT begin_checkout Użytkownik rozpoczyna proces płatności
Zdecydowanie zalecany dla wszystkich właścicieli sklepów Wyświetl pozycję PAGE_VIEW page_view Użytkownik otwiera stronę usługi
Zdecydowanie zalecany, jeśli ma zastosowanie (zwykle nie dotyczy firm zajmujących się tworzeniem sklepów) Zarejestruj się ZAREJESTRUJ SIĘ sign_up Użytkownik zakłada konto
Zdecydowanie zalecany, jeśli ma zastosowanie (zwykle nie dotyczy firm zajmujących się tworzeniem sklepów) Wygenerowanie potencjalnego klienta SUBMIT_LEAD_FORM generate_lead Użytkownik generuje kontakt do potencjalnego klienta za pomocą formularza
Zdecydowanie zalecany, jeśli ma zastosowanie (zwykle nie dotyczy firm zajmujących się tworzeniem sklepów) Zasubskrybuj SUBSCRIBE_PAID nie dotyczy (niestandardowe) Użytkownik subskrybuje płatną usługę
Zdecydowanie zalecany, jeśli ma zastosowanie (zwykle nie dotyczy firm zajmujących się tworzeniem sklepów) Rezerwacja terminu BOOK_APPOINTMENT nie dotyczy (niestandardowe) Użytkownik rezerwuje spotkanie
Zdecydowanie zalecany, jeśli ma zastosowanie (zwykle nie dotyczy firm zajmujących się tworzeniem sklepów) Prośba o wycenę REQUEST_QUOTE nie dotyczy (niestandardowe) Użytkownik przesyła formularz z prośbą o oszacowanie ceny

sprzedawców, którzy mają już konto Google Ads;

Jeśli zezwalasz sprzedawcom na zarejestrowanie się na istniejącym koncie Google Ads, może się zdarzyć, że konto zawiera już działania powodujące konwersję. Nie zalecamy używania dotychczasowego działania powodującego konwersję, ponieważ nie ma gwarancji, że zostało ono prawidłowo skonfigurowane. Musisz też podjąć dodatkowe kroki, aby móc radzić sobie w tych potencjalnych sytuacjach:

  • Konto ma wiele celów (np. zakupy + wyświetlenia strony + kontakty), które są oznaczone jako „domyślne źródło na koncie”. Gdy tworzysz nową kampanię, domyślnie jest ona optymalizowana pod kątem wszystkich tych celów. Nie potrzebujesz tego w przypadku kampanii Performance Max.

  • Konto ma już co najmniej 1 działanie powodujące konwersję do śledzenia zakupów i jest już zgrupowane w ramach celu Zakupy. Oznacza to, że gdy kampania podwaja sprzedaż, uruchamiają się dwa tagi konwersji.

Aby mieć pewność, że kampania Performance Max korzysta tylko z niestandardowego działania powodującego konwersję:

  1. Utwórz CustomConversionGoal i dodaj działanie powodujące konwersję polegającą na zakupie do listy celu conversion_actions[]. Ustaw stan na WŁĄCZONA.

  2. W sekcji ConversionGoalCampaignConfig w kampanii Performance Max ustaw custom_conversion_goal jako cel niestandardowy utworzony w kroku 1.

  3. W efekcie kroku 2 usługa Google Ads powinna automatycznie zaktualizować parametr ConversionGoalCampaignConfig w kampanii, tak aby parametr goal_config_level miał wartość CAMPAIGN (a nie CUSTOMER, która skierowałaby ją do domyślnych celów na koncie), ale warto dokładnie sprawdzić, czy tak się stało.

Pobierz tag działania powodującego konwersję

Po utworzeniu działania powodującego konwersję wstaw odpowiedni fragment kodu (tag) na stronie konwersji w witrynie reklamodawcy. Aby mierzyć w Google Ads wszystkie konwersje niezależnie od przeglądarki klienta, użyj zaktualizowanego tagu śledzenia konwersji Google Ads. Ten tag składa się z 2 części:

  • Zasób global_site_tag, który musi być zainstalowany na każdej stronie witryny reklamodawcy.

  • Element event_snippet, który należy umieścić na stronach internetowych wskazujących działanie powodujące konwersję, np. potwierdzenie płatności lub zgłoszenie potencjalnego klienta.

Te 2 części można pobrać za pomocą usługi ConversionActionService.

Tag tworzy pliki cookie zapisujące unikalny identyfikator klienta lub kliknięcie reklamy, które przekierowało go na stronę. Pliki cookie uzyskują informacje o kliknięciu reklamy z parametru identyfikatora kliknięcia Google (GCLID) zawartego w tagu śledzenia konwersji. Musisz włączyć w witrynie reklamodawcy i systemie śledzenia potencjalnych klientów przechwytywanie i zapisywanie identyfikatora kliknięcia Google, czyli niepowtarzalnego identyfikatora, który Google Ads udostępnia przy każdym wyświetleniu reklamy Google.

Więcej informacji o tagu globalnym i miejscu jego instalacji

Tag Google (gtag.js) to platforma tagowania i interfejs API, który umożliwia wysyłanie danych o zdarzeniach zarówno do Google Ads, jak i do Google Analytics. Globalny tag witryny śledzi konwersje na Twoich stronach, działając równolegle z fragmentem kodu zdarzenia lub fragmentem kodu z numerem telefonu. Dodaj tag Google do sekcji <head> każdej strony w witrynie reklamodawcy i skonfiguruj go do współpracy z Google Ads. Następnie możesz rejestrować zdarzenia i wysyłać dane do Google Ads za pomocą poleceń gtag(). Więcej informacji o tym, jak to działa, znajdziesz w artykule Używanie globalnego tagu witryny do śledzenia konwersji Google Ads.

W tagu Google używasz tych poleceń:

  • config: inicjowanie usługi Google (Google Ads, Analytics itp.), konfigurowanie ustawień i przygotowywanie się do wysłania danych na konto.

  • event: zarejestruj konwersję, wysyłając zdarzenie takie jak zakup (zalecane) lub dodanie do koszyka (dodatkowe działania powodujące konwersję). Zalecamy zapoznanie się z przewodnikiem po zdarzeniach gtag.js.

  • set: ustaw parametry wspólne dla wszystkich zdarzeń na stronie, np. waluta.

Poniżej znajduje się przykład fragmentu kodu JavaScript globalnego tagu witryny służącego do wysyłania danych do Google Ads. Wartość zmiennej GOOGLE_CONVERSION_ID to unikalny identyfikator liczbowy pojedynczego konta reklamodawcy.

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

Fragment kodu tagu Google powinien występować na każdej stronie tylko raz. Jeśli występuje już wystąpienie tagu gtag.js, musisz do niego dodać nowe identyfikatory tagów. Aby wysyłać dane na wiele kont, możesz dodać wywołanie do polecenia „config” dla każdego używanego konta i określić identyfikator konwersji każdego z nich, jak w tym przykładzie:

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

Więcej informacji o fragmentie kodu zdarzenia i miejscu jego instalacji

Aby śledzenie konwersji polegających na zakupie działało, na stronie konwersji musisz umieścić fragment kodu zdarzenia zakupu. Zazwyczaj jest to strona potwierdzenia zamówienia. Można go umieścić w dowolnym miejscu w kodzie po fragmencie kodu tagu globalnego. Fragmenty kodu zdarzenia służące do dodatkowych działań powodujących konwersję (np. dodania do koszyka) należy umieścić na odpowiednich stronach.

We fragmencie kodu poniżej AW-CONVERSION_ID i AW-CONVERSION_ID to identyfikator konwersji unikalny dla Twojego konta Google Ads i konta dewelopera tagu Google, a AW-CONVERSION_ID – etykietę konwersji unikalną dla działania powodującego konwersję:

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

Choć niektóre parametry są opcjonalne, zalecamy podanie jak największej ilości informacji o każdym zdarzeniu. Więcej informacji o tym, jakie parametry są dostępne w przypadku poszczególnych typów zdarzeń

Parametry dostarczają dodatkowych informacji o tym, jak użytkownicy wchodzą w interakcje z Twoją witryną lub aplikacją.

Jeśli chcesz mierzyć zdarzenie konwersji na podstawie kliknięcia (np.przycisku lub odpowiedzi dynamicznej w przypadku witryny za pomocą technologii AJAX), możesz też użyć poniższego fragmentu kodu:

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

Tag Google ma wbudowany interfejs API do zarządzania zgodą użytkowników. Pozwala odróżnić zgodę użytkownika na pliki cookie do celów reklamowych od zgody na potrzeby analiz.

Spodziewa się, że klienci otrzymują zintegrowane wywołanie gtag('consent', 'update' {...}) i nie muszą nic robić. Powinno to mieć pewność, że tagi Google (Google Ads, Floodlight, Google Analytics, tag łączący konwersje) będą mogły odczytywać najnowszy stan zgody użytkownika i uwzględniać go w żądaniach sieciowych wysyłanych do Google (za pomocą parametru &gcs).

Dodatkowe kroki implementacji to wdrożenie (np.za pomocą interfejsu) stanu gtag('consent', default' {...}) i odblokowanie tagów Google (np. brak uruchamiania warunkowego opartego na wyrażeniu zgody) w celu włączenia trybu uzyskiwania zgody i uruchomienia tagów w sposób zapewniający zgodę użytkownika.

Szczegółowe informacje o implementacji znajdziesz w artykule Zarządzanie ustawieniami uzyskiwania zgody użytkowników (strony internetowe).

Wskazówki

Na koncie menedżera Google Ads możesz śledzić konwersje na wszystkich kontach reklamodawcy za pomocą jednego tagu kodu konwersji. Więcej informacji o śledzeniu konwersji dla wielu kont.

Najlepszym sposobem na sprawdzenie, czy śledzenie konwersji działa, jest wejście na stronę któregoś ze sprzedawców (lub wewnętrzną witrynę testową) i dokonanie faktycznego zakupu. Następnie możesz zobaczyć w narzędziu Google Tag Assistant, czy z tego przewodnika dotyczącego rozwiązywania problemów dowiesz się, czy Google Ads wykrywa Twój tag i rejestruje konwersje. Więcej informacji znajdziesz w artykule Rozwiązywanie problemów z tagowaniem całej witryny.

Możesz uzupełnić poprzedni tag konwersji konwersjami rozszerzonymi, które mogą zwiększyć dokładność pomiaru konwersji i umożliwić korzystanie z lepszego określania stawek. Dowiedz się więcej o konfigurowaniu konwersji rozszerzonych. Przed wdrożeniem konwersji rozszerzonych upewnij się, że Twoi sprzedawcy przestrzegają zasad dotyczących danych klienta w przypadku tych konwersji w Google Ads.

Wstecz
Łączenie konta Google Ads
Dalej
4.2 Tworzenie kampanii reklamowej