4.1.5 Śledzenie konwersji

Wartość i wpływ na firmę

Aby skutecznie udostępniać kampaniom reklamowym klientów korzystających z usługi Merchant potężne narzędzia systemów uczących się i analityczne ekosystemu Google, musisz umieścić w witrynach klientów tagi śledzenia konwersji i remarketingu.

Konwersja w Google Ads ma miejsce, gdy użytkownik wykona określone działanie po kliknięciu reklamy, np. kupi produkt, zainstaluje aplikację mobilną lub zarejestruje się na listę e-mailową. Śledzenie konwersji dostarcza kluczowych informacji o działaniach użytkowników po obejrzeniu lub kliknięciu reklamy, w tym danych do obliczania i porównywania zwrotu z inwestycji (ROI), które pomagają klientom podejmować decyzje dotyczące tego, na co przeznaczać wydatki na reklamę. Śledzenie pomaga też zapewnić dostępność danych na potrzeby uzgadniania. Zamówienia różnią się w zależności od produktu lub kategorii, więc śledzenie konwersji może być przydatne do sprawdzenia, jak konkretne grupy informacji o produktach przekładają się na sprzedaż.

Cel konwersji to grupa działań powodujących konwersję, które mają ten sam cel podstawowy. Na przykład „Zakup” może być celem konwersji, który ma działania powodujące konwersję „Zakupy w witrynie” i „Sprzedaż w sklepie”.

Działania powodujące konwersję są nadal używane do śledzenia konwersji i optymalizacji kampanii. Działania powodujące konwersję tworzysz Ty, a Google grupuje je w cele konwersji.

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

Wdrożenie śledzenia konwersji opisanego w tym artykule umożliwi Twojemu klientowi pomiar liczby konwersji typu Zakup i wartości tych konwersji na koncie Google Ads. Bez śledzenia konwersji nie możesz mierzyć wartości biznesowej, jaką kampania generuje pod względem ROAS (zwrotu z nakładów na reklamę). Wysyła też dodatkowe sygnały danych, które umożliwiają optymalizację skuteczności kampanii.

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 wszystkich możliwych zdarzeń i wdrażanie jak największej liczby podstawowych działań powodujących konwersję. Pełną listę zalecanych działań powodujących konwersję znajdziesz w sekcji dotyczącej wskazówek technicznych dotyczących interfejsu API.

Ogólnie zalecamy rejestrowanie tych informacji:

  • Każde zdarzenie sukcesu bezpośrednio powiązane z wartością
  • Zdarzenia sukcesu, które przyczyniają się do podstawowych konwersji, takich jak add_to_cart i sign_up.
  • Interakcje i zaangażowanie użytkowników, które pomagają reklamodawcom zrozumieć, jak wchodzą w interakcje z użytkownikami

Dodatkowe działania powodujące konwersję służą tylko do obserwacji i raportowania, nie mają wpływu na określanie stawek. Więcej informacji o głównych i dodatkowych działaniach powodujących konwersję

Wytyczne dotyczące UX

Aby zminimalizować ryzyko błędów, zalecamy wdrożenie śledzenia konwersji za pomocą kodu bez udziału sprzedawcy. Musisz jednak poinformować sprzedawców, że śledzenie konwersji zostało skonfigurowane.

Gdy sprzedawcy połączą istniejące konto Google Ads, zalecamy wyświetlenie powiadomienia, że na koncie może być już skonfigurowane śledzenie konwersji, ponieważ mogą wystąpić konflikty, które należy rozwiązać. Przykład znajdziesz poniżej.

connect_your_google_ads_account

Wskazówki techniczne

Śledzenie konwersji działa w ten sposób: W tej sekcji znajdziesz więcej informacji o poszczególnych krokach:

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

  2. Tag lub fragment kodu tego działania powodującego konwersję dodajesz do witryny lub aplikacji mobilnej. Więcej informacji 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 przez reklamodawcę, Google rozpozna plik cookie (przez dodany fragment kodu) i zarejestruje konwersję wraz z innymi parametrami, np. „wartość”, jeśli jest to odpowiednie.

Wymagania wstępne

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

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

Poniższe przykłady pokazują, jak utworzyć działanie powodujące konwersję i dodać je do konta Google Ads. Każdy przykład obsługuje wszystkie zadania uwierzytelniania w tle i przeprowadza 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.v23.enums.ConversionActionCategoryEnum.ConversionActionCategory;
import com.google.ads.googleads.v23.enums.ConversionActionStatusEnum.ConversionActionStatus;
import com.google.ads.googleads.v23.enums.ConversionActionTypeEnum.ConversionActionType;
import com.google.ads.googleads.v23.errors.GoogleAdsError;
import com.google.ads.googleads.v23.errors.GoogleAdsException;
import com.google.ads.googleads.v23.resources.ConversionAction;
import com.google.ads.googleads.v23.resources.ConversionAction.ValueSettings;
import com.google.ads.googleads.v23.services.ConversionActionOperation;
import com.google.ads.googleads.v23.services.ConversionActionServiceClient;
import com.google.ads.googleads.v23.services.MutateConversionActionResult;
import com.google.ads.googleads.v23.services.MutateConversionActionsResponse;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Collections;

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

  private static class AddConversionActionParams extends CodeSampleParams {

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

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

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

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

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

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

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

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

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

AddConversionAction.java

C#

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

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

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

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

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

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

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

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

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

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

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

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

AddConversionAction.cs

PHP

<?php

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

namespace Google\Ads\GoogleAds\Examples\Remarketing;

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

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

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

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

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

        // Construct a Google Ads client configured from a properties file and the
        // OAuth2 credentials above.
        $googleAdsClient = (new GoogleAdsClientBuilder())
            ->fromFile()
            ->withOAuth2Credential($oAuth2Credential)
            ->build();

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

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

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

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

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

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

AddConversionAction::main();

AddConversionAction.php

Python

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


import argparse
import sys
import uuid

from google.ads.googleads.client import GoogleAdsClient
from google.ads.googleads.errors import GoogleAdsException
from google.ads.googleads.v23.resources.types.conversion_action import (
    ConversionAction,
)
from google.ads.googleads.v23.services.services.conversion_action_service import (
    ConversionActionServiceClient,
)
from google.ads.googleads.v23.services.types.conversion_action_service import (
    ConversionActionOperation,
    MutateConversionActionsResponse,
)


def main(client: GoogleAdsClient, customer_id: str) -> None:
    conversion_action_service: ConversionActionServiceClient = (
        client.get_service("ConversionActionService")
    )

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

    # Create conversion action.
    conversion_action: ConversionAction = conversion_action_operation.create

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

    # Create a value settings object.
    value_settings: ConversionAction.ValueSettings = (
        conversion_action.value_settings
    )
    value_settings.default_value = 15.0
    value_settings.always_use_default_value = True

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

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


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

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

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

add_conversion_action.py

Ruby

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

require 'optparse'
require 'google/ads/google_ads'
require 'date'
require_relative '../shared/error_handler.rb'

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


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

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

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

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

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

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

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

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

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

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

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

  begin
    add_conversion_action(options.fetch(:customer_id).tr("-", ""))
  rescue Google::Ads::GoogleAds::Errors::GoogleAdsError => e
    GoogleAdsErrorHandler.handle_google_ads_error(e)
    raise # Re-raise the error to maintain original script behavior.
  end
end

add_conversion_action.rb

Perl

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

use strict;
use warnings;
use utf8;

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

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

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

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

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

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

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

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

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

  return 1;
}

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

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

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

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

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

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

=pod

=head1 NAME

add_conversion_action

=head1 DESCRIPTION

This example illustrates adding a conversion action.

=head1 SYNOPSIS

add_conversion_action.pl [options]

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

=cut

add_conversion_action.pl

curl

Powyższe przykłady mają charakter ogólny, dlatego poniżej znajdziesz dodatkowe uwagi, które pomogą Ci prawidłowo skonfigurować ConversionAction na potrzeby kampanii Performance Max. Każde działanie powodujące konwersję powinno być skonfigurowane w ten sposób:

  • Typ – ustaw ConversionActionType jako WEBPAGE, ponieważ te zdarzenia zakupu występują w witrynie.

  • Z możliwością ustalenia stawki – ustaw na true w przypadku głównego działania powodującego konwersję (zakup), aby optymalizować kampanie pod kątem sprzedaży. W przypadku dodatkowych działań powodujących konwersję (np.dodanie do koszyka) ustaw wartość na false.

  • Kategoria – dla każdego działania powodującego konwersję (głównego lub dodatkowego) ustaw ConversionActionCategory. Poniżej znajdziesz odpowiednią kategorię działania powodującego konwersję dla każdego z 7 działań powodujących konwersję, które zalecamy wdrożyć. Uwaga: 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ę związane z zakupem są przypisywane do standardowego celu konwersji o nazwie „Zakupy”. Później możesz skonfigurować kampanię Performance Max, aby optymalizować ją pod kątem tego celu związanego z zakupami.

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

Możesz też wdrożyć dodatkowe zdarzenia związane ze sprzedażą online. Aby uzyskać jeszcze bardziej szczegółowe śledzenie, możesz też utworzyć dodatkowe działania powodujące konwersję lub dostosowane działania powodujące konwersję (np. działanie „dodaj informacje o płatności” za każdym razem, gdy użytkownik skorzysta z opcji wyszukiwania w witrynie, lub działanie „wyszukiwanie” za każdym razem, gdy użytkownik skorzysta z opcji wyszukiwania w witrynie). Dodatkowe działania powodujące konwersję zapewniają sprzedawcom dodatkowe śledzenie i są używane przez Google Ads do obserwacji.

Priorytet Działanie powodujące konwersję Kategoria działania powodującego konwersję Nazwa zdarzenia tagu Google Opis
Obowiązkowe Zakup ZAKUP purchase Użytkownik finalizuje zakup
Zdecydowanie zalecane dla wszystkich twórców sklepów Dodanie do koszyka ADD_TO_CART add_to_cart Użytkownik dodaje produkt do koszyka
Zdecydowanie zalecane dla wszystkich twórców sklepów Rozpoczęcie procesu płatności BEGIN_CHECKOUT begin_checkout Użytkownik rozpoczyna proces płatności
Zdecydowanie zalecane dla wszystkich twórców sklepów Wyświetl pozycję PAGE_VIEW page_view Użytkownik otwiera stronę produktu
Zdecydowanie zalecane, gdy ma zastosowanie (zwykle nie dotyczy platform do tworzenia sklepów) Zarejestruj się SIGNUP sign_up Użytkownik zakłada konto
Zdecydowanie zalecane, gdy ma zastosowanie (zwykle nie dotyczy platform do tworzenia sklepów) Pozyskanie potencjalnego klienta SUBMIT_LEAD_FORM generate_lead Użytkownik generuje potencjalnego klienta za pomocą formularza
Zdecydowanie zalecane, gdy ma zastosowanie (zwykle nie dotyczy platform do tworzenia sklepów) Subskrybuj SUBSCRIBE_PAID nie dotyczy (niestandardowe) Użytkownik subskrybuje usługę płatną
Zdecydowanie zalecane, gdy ma zastosowanie (zwykle nie dotyczy platform do tworzenia sklepów) Rezerwacja wykonania usługi BOOK_APPOINTMENT nie dotyczy (niestandardowe) Użytkownik rezerwuje wizytę
Zdecydowanie zalecane, gdy ma zastosowanie (zwykle nie dotyczy platform do tworzenia sklepów) Prośba o wycenę REQUEST_QUOTE nie dotyczy (niestandardowe) Użytkownik przesyła formularz z prośbą o szacunkową cenę

Sprzedawcy, którzy mają konto Google Ads

Jeśli zezwolisz sprzedawcom na rejestrację za pomocą dotychczasowego konta Google Ads, może się zdarzyć, że na tym koncie będą już dostępne 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. Dodatkowo musisz wykonać dodatkowe czynności, aby poradzić sobie z tymi potencjalnymi scenariuszami:

  • Konto ma wiele celów (np. Zakupy + Wyświetlenia strony + Kontakty), które są oznaczone jako „domyślne na poziomie konta”. Gdy tworzysz nową kampanię, domyślnie jest ona optymalizowana pod kątem wszystkich tych celów. Nie chcesz tego w przypadku kampanii Performance Max.

  • Konto ma już co najmniej 1 działanie powodujące konwersję do śledzenia zakupów i jest ono już zgrupowane w ramach celu Zakupy. Oznacza to, że po podwojeniu liczby zakupów w kampanii wystąpią 2 tagi konwersji.

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

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

  2. W ConversionGoalCampaignConfig kampanii Performance Max ustaw wartość custom_conversion_goal na cel niestandardowy utworzony w kroku 1.

  3. W wyniku kroku (2) Google Ads powinno automatycznie zaktualizować ustawienie ConversionGoalCampaignConfig kampanii tak, aby wartość goal_config_level była ustawiona na CAMPAIGN (zamiast CUSTOMER, co spowodowałoby używanie celów domyślnych konta). Warto jednak sprawdzić, czy tak się stało.

Pobieranie tagu działania powodującego konwersję

Po utworzeniu działania powodującego konwersję musisz wstawić odpowiedni fragment kodu, czyli tag, na stronę konwersji w witrynie reklamodawcy. Aby mieć pewność, że Google Ads może mierzyć wszystkie konwersje niezależnie od przeglądarki klienta, użyj zaktualizowanego tagu śledzenia konwersji Google Ads. Tag składa się z 2 części:

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

  • event_snippet, który powinien być umieszczony na stronach internetowych wskazujących działanie powodujące konwersję, np. na stronie potwierdzenia płatności lub stronie przesyłania informacji o potencjalnych klientach.

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

Tag tworzy pliki cookie, które przechowują unikalny identyfikator klienta lub kliknięcia reklamy, które przekierowało klienta do witryny. Pliki cookie uzyskują informacje o kliknięciu reklamy z parametru identyfikator kliknięcia Google (GCLID) w tagu śledzenia konwersji. Musisz włączyć w witrynie reklamodawcy i systemie śledzenia kontaktów do potencjalnych klientów funkcję przechwytywania i przechowywania identyfikatora kliknięcia Google, czyli niepowtarzalnego identyfikatora, który Google Ads przypisuje każdemu wyświetleniu reklamy Google.

Więcej informacji o globalnym tagu i miejscu jego instalacji

Tag Google (gtag.js) to platforma dodawania tagów i interfejs API, które umożliwiają wysyłanie danych o zdarzeniach zarówno do Google Ads, jak i do Google Analytics. Globalny tag witryny śledzi konwersje, 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 tak, aby współpracował z Google Ads. Następnie możesz używać poleceń gtag() do rejestrowania zdarzeń i wysyłania danych do Google Ads. Aby dowiedzieć się, jak to działa, przeczytaj artykuł Używanie globalnego tagu witryny do śledzenia konwersji Google Ads.

W przypadku tagu Google możesz używać tych poleceń:

  • config: inicjuje usługę Google (Google Ads, Analytics itp.), konfiguruje ustawienia i przygotowuje się do wysyłania danych na konto.

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

  • set: ustawia parametry wspólne dla wszystkich zdarzeń na stronie, np. walutę.

Poniższy przykład to fragment kodu JavaScript globalnego tagu witryny, który służy do przesyłania danych do Google Ads. Wartość zastępcza GOOGLE_CONVERSION_ID to unikalny identyfikator numeryczny 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ć tylko raz na stronie. Jeśli istnieje już instancja tagu gtag.js, dodaj do niej nowe identyfikatory tagów. Aby wysyłać dane na kilka kont, możesz dodać wywołanie polecenia „config” dla każdego używanego konta, podając identyfikator konwersji każdego konta, jak pokazano 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 fragmencie kodu zdarzenia i miejscu jego instalacji

Aby działało śledzenie konwersji związanych z zakupem, fragment kodu zdarzenia zakupu należy zainstalować na stronie konwersji. Zwykle jest to strona potwierdzenia zamówienia. Można go wstawić w dowolnym miejscu w kodzie po kodzie tagu globalnego. Fragmenty kodu zdarzenia dla dodatkowych działań powodujących konwersję (np. dodanie do koszyka) należy umieścić na odpowiednich stronach.

We fragmencie kodu poniżej AW-ID_KONWERSJI i gTag_developer_ID oznaczają identyfikator konwersji unikalny dla Twojego konta Google Ads i konta dewelopera Google Tag, a AW-ETYKIETA_KONWERSJI – 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>

Niektóre parametry są opcjonalne, ale zalecamy podanie jak największej ilości informacji o każdym zdarzeniu. Więcej informacji o parametrach dostępnych w przypadku poszczególnych typów zdarzeń

Parametry podają dodatkowe informacje na temat sposobów, w jakie użytkownicy wchodzą w interakcje z Twoją witryną lub aplikacją.

Jeśli chcesz mierzyć zdarzenie konwersji na podstawie kliknięcia (np.przycisku lub dynamicznej odpowiedzi w witrynie korzystającej z AJAX), możesz też użyć tego 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 Consent API do zarządzania zgodą użytkowników. Potrafi odróżnić zgodę użytkownika na pliki cookie w celach reklamowych od zgody na pliki cookie w celach analitycznych.

Oczekiwany rezultat to zintegrowanie wywołania gtag('consent', 'update' {...}) bez konieczności podejmowania przez klienta żadnych działań. Dzięki temu 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 polegają na wdrożeniu lub pomocy reklamodawcom we wdrożeniu (np.za pomocą interfejsu) stanu gtag('consent', 'default' {...}) i odblokowaniu tagów Google (np. bez warunkowego uruchamiania na podstawie zgody), aby umożliwić trybowi uzyskiwania zgody uruchamianie ich w sposób uwzględniający zgodę.

Szczegółowe informacje o wdrażaniu znajdziesz w artykule Zarządzanie ustawieniami zgody użytkownika (wersja na przeglądarki).

Wskazówki

Na koncie menedżera Google Ads możesz śledzić konwersje na wszystkich kontach reklamodawców,korzystając z pojedynczego tagu kodu konwersji. Zobacz informacje o śledzeniu konwersji dla wielu kont.

Najlepszym sposobem sprawdzenia, czy implementacja śledzenia konwersji działa prawidłowo, jest przejście do witryny jednego z Twoich sprzedawców (lub wewnętrznej witryny testowej) i dokonanie prawdziwego zakupu. Następnie możesz użyć narzędzia Google Tag Assistant, aby sprawdzić, czy Google Ads widzi Twój tag i czy rejestruje konwersje. Możesz też skorzystać z tego przewodnika rozwiązywania problemów. Więcej informacji znajdziesz w artykule Rozwiązywanie problemów z tagowaniem całej witryny.

Możesz uzupełnić powyższy tag konwersji o konwersje rozszerzone, które mogą zwiększyć dokładność pomiaru konwersji i umożliwić korzystanie ze skuteczniejszych strategii określania stawek. Dowiedz się więcej o konfigurowaniu konwersji rozszerzonych. Przed wdrożeniem konwersji rozszerzonych upewnij się, że Twoi sprzedawcy mogą przestrzegać zasad dotyczących danych klienta w przypadku konwersji rozszerzonych w Google Ads.

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