4.1.5 Śledzenie konwersji

Wartość i wpływ na firmę

Aby skutecznie udostępniać w ekosystemie Google zaawansowane systemy uczące się Analytics dla kampanii klientów sprzedawcy, należy do śledzenia i tagów remarketingowych w witrynach klientów.

Konwersja w Google Ads ma miejsce, gdy użytkownik wykona określone działanie po kliknięciu reklamy, np. zakupie produktu, zainstalowaniu aplikacji mobilnej lub utworzenie listy e-mailowej. Śledzenie konwersji daje dostęp do kluczowych statystyk na użytkowników działania po obejrzeniu lub kliknięciu reklamy, w tym informacje obliczanie i porównywanie zwrotu z inwestycji (ROI), aby pomóc swoim klientom; podejmować decyzje dotyczące przeznaczania środków na reklamę. Śledzenie pomaga też zapewnić, aby dane były dostępne na potrzeby uzgodnienia. Zamówienia różnią się w zależności od produktu lub kategorii. Śledzenie konwersji może być również przydatne do pokazywania, określonych grup informacji o produktach prowadzą do sprzedaży.

Cel konwersji to grupa działań powodujących konwersję z takim samym podstawowego celu. Na przykład „Zakup” może być celem konwersji, który ma Zakupy w witrynie i „Sprzedaż w sklepie”, jako działania powodujące konwersję.

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

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

Wdrożenie opisanego tutaj śledzenia konwersji umożliwia sprzedawcy konta Google Ads do pomiaru liczby konwersji polegających na zakupie i ich wartości. tych konwersji. Bez śledzenia konwersji nie można mierzyć wartość biznesową kampanii w kontekście ROAS (zwrotu wydatki na reklamę). Wysyła też dodatkowe sygnały danych, dzięki którym kampania może optymalizować skuteczność.

Inne działania powodujące konwersję

Chociaż wymagane jest tylko działanie powodujące konwersję polegającą na zakupie, śledzenie dodatkowych działania powodujące konwersję mogą dostarczyć sprzedawcom dodatkowych informacji. Śr zalecamy rejestrowanie wszystkiego, co jest możliwe, przy jednoczesnym wdrożeniu jak największej liczby podstawowych działań powodujących konwersję. Pełną listę zalecanych działań powodujących konwersję znajdziesz opisane w sekcji „Wskazówki dotyczące interfejsu Tech API”.

Ogólnie zalecamy uchwycenie:

  • Dowolne zdarzenie sukcesu bezpośrednio powiązane z wartością
  • zdarzenia sukcesu, które mają udział w kluczowych konwersjach, np. add_to_cart i sign_up.
  • Zaangażowanie i interakcje użytkowników, które pomagają reklamodawcom zrozumieć, angażowanie użytkowników

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

Wskazówki dotyczące UX

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

Gdy sprzedawcy połączą już istniejące konto Google Ads, zalecamy wyświetlenie powiadomienie, że na koncie może już być włączone śledzenie konwersji bo mogą pojawić się konflikty, które trzeba rozwiązać. Wyświetlany jest 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 krok:

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

  2. dla tego działania powodującego konwersję dodajesz do witryny tag (fragment kodu), aplikacji mobilnej. Więcej informacji znajdziesz w artykule Konfiguracja śledzenia konwersji w witrynie.

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

  4. Gdy klient wykona czynność określoną dla reklamodawcy, Google rozpoznaje plik cookie (przez dodany fragment kodu) i rejestruje konwersji razem z innymi parametrami, takimi jak „value” w razie potrzeby.

Wymagania wstępne

Zanim zaczniesz, upewnij się, że masz identyfikator dewelopera tagu Google. Jeśli nie chcesz masz identyfikator dewelopera tagu Google, wypełnij pole Formularz prośby o identyfikator dewelopera tagu Google Twój identyfikator dewelopera jest inny od innych identyfikatorów, np. identyfikatora pomiaru lub identyfikatora konwersji, do kodu pomiarowego witryny.

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

W przykładach poniżej pokazujemy, jak utworzyć działanie powodujące konwersję i dodać je do konto Google Ads. Każdy przykład obsługuje wszystkie zadania uwierzytelniania w tle dla oraz 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 oto dodatkowe uwagi, Sprawdź, czy wartość ConversionAction jest prawidłowo skonfigurowana w kampaniach Performance Max. Każde działanie powodujące konwersję powinno być skonfigurowane w ten sposób:

  • Typ – ustaw ConversionActionType jako WEBPAGE, ponieważ te zakupy mają miejsce w witrynie.

  • Z możliwością ustalania stawek – ustaw true jako podstawową działanie powodujące konwersję (zakup) do optymalizowania kampanii pod kątem sprzedaży. W przypadku dodatkowych działań powodujących konwersję (np.dodania do koszyka): ustaw wartość na false.

  • Kategoria – dla każdego działania powodującego konwersję (głównego lub dodatkową),ustaw ConversionActionCategory. Poniżej znajdziesz odpowiednią kategorię działań związanych z rozmową dla każdego z 7 działań powodujących konwersję, które zalecamy wdrożyć. Pamiętaj, że Google Ads automatycznie przypisuje konwersję do standardowego celu konwersji na podstawie ich kategorii. np. przypisywanym działaniom powodującym konwersję polegającą na zakupie ze standardowym celem konwersji „Zakupy”. Później możesz skonfigurować kampanię Performance Max aby zoptymalizować kampanię 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ę oraz jak największej liczby inne zalecane działania.

Możesz też rozważyć wdrożenie dodatkowe zdarzenia związane ze sprzedażą online. Jeszcze bardziej szczegółowy śledzenie konwersji, można utworzyć dodatkowe działania powodujące konwersję lub dostosowane działania powodujące konwersję (np. działanie „dodanie danych do płatności”); za każdym razem, gdy użytkownik użyje w witrynie opcji wyszukiwania lub „szukaj” za każdym razem, gdy użytkownik użyje w witrynie opcji wyszukiwania). Drugorzędne które zapewniają sprzedawcom dodatkowe śledzenie. 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 zalecany w przypadku wszystkich twórców sklepów Dodaj do koszyka ADD_TO_CART add_to_cart Użytkownik dodaje produkt do koszyka.
Zdecydowanie zalecany w przypadku wszystkich twórców sklepów Rozpoczęcie realizacji płatności BEGIN_CHECKOUT begin_checkout Użytkownik rozpoczyna proces płatności
Zdecydowanie zalecany w przypadku wszystkich twórców sklepów Wyświetl pozycję PAGE_VIEW page_view Użytkownik otwiera stronę usługi
Zdecydowanie zalecany, gdy ma zastosowanie (zwykle nie dotyczy firm tworzących sklepy) Zarejestruj się ZAREJESTRUJ SIĘ sign_up Użytkownik rejestruje konto
Zdecydowanie zalecany, gdy ma zastosowanie (zwykle nie dotyczy firm tworzących sklepy) Wygenerowanie potencjalnego klienta SUBMIT_LEAD_FORM generate_lead Użytkownik generuje kontakt do potencjalnego klienta za pomocą formularza
Zdecydowanie zalecany, gdy ma zastosowanie (zwykle nie dotyczy firm tworzących sklepy) Subskrybuj SUBSCRIBE_PAID nie dotyczy (niestandardowy) Użytkownik dokonuje subskrypcji płatnej usługi
Zdecydowanie zalecany, gdy ma zastosowanie (zwykle nie dotyczy firm tworzących sklepy) Rezerwacja terminu BOOK_APPOINTMENT nie dotyczy (niestandardowy) Użytkownik rezerwuje spotkanie
Zdecydowanie zalecany, gdy ma zastosowanie (zwykle nie dotyczy firm tworzących sklepy) Prośba o wycenę REQUEST_QUOTE nie dotyczy (niestandardowy) Użytkownik przesyła formularz z prośbą o wycenę szacunkowej ceny

Sprzedawcy, którzy mają już konto Google Ads

Jeśli zezwolisz sprzedawcom na zarejestrowanie się za pomocą istniejącego konta Google Ads, możesz: w sytuacji, gdy na koncie są już działania powodujące konwersję. Nie zakładamy zalecamy użycie dotychczasowego działania powodującego konwersję, ponieważ nie ma gwarancji, że została prawidłowo skonfigurowana. Wymagają też dodatkowych działań, aby radzić sobie z tymi potencjalnymi sytuacjami:

  • 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 optymalizuje kampanię pod kątem wszystkich tych celów. Nie chcesz tego robić w przypadku witryny Kampania Performance Max.

  • Na koncie jest już co najmniej 1 działanie powodujące konwersję do śledzenia zakupów. jest już zaliczany do celu Zakupy. Oznacza to, że po wykonaniu ponieważ kampania podwaja liczbę zakupów, ponieważ uruchamiają się 2 tagi konwersji.

Aby mieć pewność, że kampania Performance Max użyje niestandardowego działania powodującego konwersję i tylko ta czynność:

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

  2. W polu ConversionGoalCampaignConfig kampanii Performance Max ustaw wartość custom_conversion_goal do celu niestandardowego utworzonego w kroku (1).

  3. W efekcie wykonania kroku (2) usługa Google Ads powinna automatycznie zaktualizować w parametrze ConversionGoalCampaignConfig kampanii, tak by goal_config_level był ustawiony do CAMPAIGN (zamiast CUSTOMER, która skierowałaby go do użycia domyślne cele na koncie), warto jednak upewnić się, miało miejsce.

Pobierz tag działania powodującego konwersję

Po utworzeniu działania powodującego konwersję wstaw parametr odpowiedni fragment kodu wywołał tag do strony konwersji do witryny reklamodawcy. Aby usługa Google Ads mogła mierzyć wszystkie konwersje niezależnie od przeglądarki klienta, użyj zaktualizowanego tagu śledzenia konwersji Google Ads. Ten tag składa się z dwóch elementów części:

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

  • Element event_snippet, który powinien zostać umieszczony na stronach internetowych wskazujących na działanie powodujące konwersję, np. stronę potwierdzenia płatności lub przesłania potencjalnego klienta.

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

Tag tworzy pliki cookie, które przechowują unikalny identyfikator klienta lub reklamy które przekierowało klienta do witryny. Pliki cookie otrzymują kliknięcie reklamy informacje z parametru identyfikatora kliknięcia Google (GCLID); w tagu śledzenia konwersji. Musisz włączyć witrynę reklamodawcy do śledzenia potencjalnych klientów, aby rejestrować i zapisywać identyfikator kliknięcia Google, czyli unikalny identyfikator Google Ads zalicza każde wyświetlenie reklamy Google.

Więcej informacji o tagu globalnym i miejscu jego instalacji

Tag Google (gtag.js) to platforma tagowania i interfejs API, które umożliwiają Ci wysyłać dane zdarzeń zarówno do Google Ads, jak i do Google Analytics. Globalny tag witryny współdziała z fragmentem kodu zdarzenia lub fragmentem kodu z numerem telefonu, aby śledzić konwersje. Dodaj tag Google do sekcji <head> każdej strony. w witrynie reklamodawcy i skonfigurować ją pod kątem współpracy 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, zobacz Używanie globalnego tagu witryny do śledzenia konwersji Google Ads

Z tagiem Google możesz używać tych poleceń:

  • config: zainicjuj usługę Google (Google Ads, Analytics itp.), skonfigurować ustawienia i przygotować się do wysłania danych na konto.

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

  • set:pozwala ustawić parametry wspólne dla wszystkich zdarzeń na stronie, np. currency.

Poniżej znajduje się przykład fragmentu kodu JavaScript globalnego tagu witryny do przesyłać dane 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 stronie tylko raz. Jeśli masz już konto, tagu gtag.js, musisz dodać nowe identyfikatory tagów do dotychczasowego tagu. Aby wysłać do wielu kont, można dodać wywołanie do parametru „config” dla każdego polecenia z którego konta korzystasz, podając identyfikator konwersji dla każdego z nich, 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 instalowania

Aby śledzenie konwersji polegających na zakupie działało, fragment kodu zdarzenia zakupu należy umieścić na stronie konwersji. Zazwyczaj jest to zamówienie, stronie potwierdzenia. Można go wstawić w dowolnym miejscu w kodzie za tagiem globalnym . Fragmenty kodu zdarzenia związane z dodatkowymi działaniami powodującymi konwersję (np. „dodaj do koszyka”) należy umieścić na odpowiednich stronach.

we fragmencie kodu poniżej AW-CONVERSION_ID i gTag_developer_ID oznacza identyfikator konwersji unikalny dla Twojego konta Google Ads i Google Tag dewelopera, a AW-CONVERSION_LABEL oznacza konwersję etykieta, która jest unikalna 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>

Chociaż niektóre parametry są opcjonalne, zalecamy podanie jak największej ilości dostępne informacje o każdym z tych wydarzeń. Więcej informacji o tym, które parametry są dostępne dla każdego typu zdarzenia.

Parametry dostarczają dodatkowych informacji o sposobach interakcji użytkowników z Twoją witryną lub aplikacją.

Jeśli chcesz mierzyć zdarzenie konwersji na podstawie kliknięcia (np.na przycisku lub w dynamicznej odpowiedzi w witrynie korzystającej z technologii AJAX), Zamiast tego możesz użyć tego fragmentu:

<!-- 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. Jest w stanie odróżniać zgody użytkownika na pliki cookie do celów reklamowych od zgody użytkownika na przetwarzanie danych w celach informacyjnych.

W efekcie klienci powinni otrzymać co najmniej tag gtag('consent', 'update') {...}) zintegrowana z rozmową niewymagająca żadnych działań ze strony klienta. To powinno upewnić się, że tagi Google (Google Ads, Floodlight, Google Analytics, tag łączący konwersje) mogą odczytywać najnowszy stan zgody użytkownika i uwzględniać stan w sieci żądań do Google (za pomocą parametru &gcs).

Dodatkowym krokiem w implementacji jest wdrożenie lub wspieranie reklamodawców wdrażając (np. za pomocą interfejsu) stan tagu gtag('consent', default' {...}) oraz Odblokowanie tagów Google (np. brak uruchamiania warunkowego zależnego od zgody) w celu włącz tryb uzyskiwania zgody, aby uruchamiać je z uwzględnieniem zgody 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 we wszystkich na kontach reklamodawców za pomocą jednego tagu kodu konwersji. Zobacz śledzeniu konwersji dla wielu kont.

Najlepszym sposobem na sprawdzenie, czy implementacja śledzenia konwersji jest uda się do jednego ze sprzedawców witryna (lub witryna do testów wewnętrznych), i dokonają w nich zakupu. Następnie możesz obserwować ją w narzędziu Google Tag Assistant. aby skorzystać z tego przewodnika dotyczącego rozwiązywania problemów aby sprawdzić, czy Google Ads wykrył tag i rejestruje konwersje. Więcej informacji znajdziesz w artykule Rozwiązywanie problemów z tagowaniem całej witryny.

Poprzedni tag konwersji możesz uzupełnić o konwersje rozszerzone, co może zwiększyć dokładność pomiaru konwersji i udostępniać skuteczniejsze określanie stawek. Dowiedz się więcej o konfigurowaniu konwersji rozszerzonych. Przed wdrożeniem konwersji rozszerzonych musisz upewnić się, że sprzedawcy są w stanie Zasadom dotyczącym danych klientów w przypadku konwersji rozszerzonych w Google Ads.

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