4.1.5 מעקב המרות

הערך וההשפעה על העסק

כדי לספק ביעילות את הניתוח והלמידה החישובית החזקים של הסביבה העסקית של Google לקמפיינים של המודעות של לקוחות המוכרים, צריך להציב תגי מעקב המרות ותגי רימרקטינג באתרים של הלקוחות.

המרה ב-Google Ads מתרחשת כשמשתמש מבצע פעולה מסוימת אחרי לחיצה על מודעה, למשל רכישה של מוצר, התקנה של אפליקציה לנייד או הרשמה לרשימת כתובות אימייל. מעקב המרות מספק תובנות חשובות לגבי הפעולות שהמשתמשים מבצעים אחרי שהם צופים במודעה או לוחצים עליה, כולל מידע לחישוב ולהשוואה של החזר ה-ROI (החזר על ההשקעה), כדי לעזור ללקוחות שלכם לקבל החלטות לגבי המקום שבו כדאי למקד את ההוצאות על הפרסום. המעקב גם עוזר לוודא שהנתונים זמינים לצורכי התאמה. ההזמנות משתנות בהתאם למוצר או לקטגוריה, ולכן מעקב ההמרות יכול גם להועיל כדי להראות איך קבוצות ספציפיות של כרטיסי מוצר הופכות להמרות למכירות.

יעד המרה הוא קבוצה של פעולות המרה עם אותו יעד בסיסי. לדוגמה, 'רכישה' יכול להיות יעד המרה שכולל את פעולות ההמרה 'רכישות באתר' ו 'מכירות בחנות הפיזית'.

פעולות ההמרה עדיין משמשות למעקב אחר המרות ולביצוע אופטימיזציה של הקמפיין. אתם יוצרים פעולות המרה ו-Google מקבצת אותן ביעדי המרה.

פעולת המרה מסוג רכישה

הטמעת מעקב ההמרות שמתואר כאן מאפשרת לחשבון Google Ads של המוכר למדוד את מספר ההמרות מסוג 'רכישה' ואת הערך של ההמרות האלה. בלי מעקב המרות, לא תוכלו למדוד את הערך העסקי שהקמפיין מניב במונחים של החזר על הוצאות הפרסום (ROAS). הוא גם שולח אותות נתונים נוספים שמאפשרים לבצע אופטימיזציה של הביצועים בקמפיין.

פעולות המרה אחרות

פעולת ההמרה מסוג רכישה היא חובה, אבל מעקב אחרי פעולות המרה נוספות יכול לספק למוכרים תובנות נוספות. מומלץ לתעד ביומן את כל מה שאפשר, תוך הטמעה של כמה שיותר פעולות המרה מרכזיות. רשימה מלאה של פעולות ההמרה המומלצות מפורטת בקטע ההנחיות בנושא Tech API.

באופן כללי, מומלץ לתעד את הפרטים הבאים:

  • כל אירוע הצלחה שמשויך ישירות לערך
  • אירועי הצלחה שתורמים להמרות הליבה, כמו add_to_cart ו-sign_up.
  • אינטראקציות ראשוניות ואינטראקציות של משתמשים שעוזרות למפרסמים להבין איך הם מעוררים עניין בקרב משתמשי הקצה

פעולות המרה משניות משמשות רק לצורכי תיעוד ודיווח, ולא משפיעות על הבידינג.מידע נוסף על פעולות המרה ראשיות ומשניות

הנחיות בנושא UX

כדי לצמצם את הסיכון לשגיאות, מומלץ להטמיע מעקב המרות באופן פרוגרמטי בלי קלט מהמוכרים, אבל חשוב לוודא שהמוכרים יודעים שהוגדר מעקב המרות.

כשמוכרים מקשרים חשבון Google Ads קיים, מומלץ להציג להם התראה על כך שיכול להיות שכבר הוגדר בחשבון מעקב המרות, כי יכול להיות שיהיו התנגשויות שצריך לפתור. דוגמה מופיעה בהמשך.

connect_your_google_ads_account

הנחיות טכניות

כך פועל מעקב ההמרות. בקטע הזה מוסבר בהרחבה על כל שלב:

  1. יוצרים 'ConversionAction' בחשבון Google Ads של המוכר כדי לעקוב אחרי רכישות (ואם רוצים, גם אחרי פעולות אחרות של לקוחות) שבוצעו באתר שלו.

  2. מוסיפים את התג או קטע הקוד של פעולת ההמרה הזו לאתר או לאפליקציה לנייד. פרטים נוספים זמינים במאמר הגדרת מעקב המרות באתר.

  3. כשלקוח לוחץ על המודעה, מוצב קובץ Cookie זמני במחשב או בנייד שלו.

  4. כשהלקוח משלים את הפעולה שהוגדרה למפרסם, Google מזהה את קובץ ה-Cookie (באמצעות קטע הקוד שנוסף) ומתעדת המרה יחד עם פרמטרים אחרים, כמו 'ערך', אם רלוונטי.

דרישות מוקדמות

לפני שמתחילים, חשוב לוודא שיש לכם מזהה מפתח של Google Tag. אם אין לכם מזהה מפתח של Google Tag, תוכלו למלא את טופס הבקשה למזהה מפתח של Google Tag. מזהה המפתח שונה ממזהים אחרים, כמו מזהה המדידה או מזהה ההמרה, שמשתמשי הקצה מוסיפים לקוד המדידה של האתר שלהם.

יצירת פעולות המרה והגדרתן

בדוגמאות הבאות מוסבר איך ליצור פעולת המרה ולהוסיף אותה לחשבון Google Ads. כל דוגמה מטפלת בכל משימות האימות ברקע, ומסבירה איך יוצרים פעולת המרה:

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.v21.enums.ConversionActionCategoryEnum.ConversionActionCategory;
import com.google.ads.googleads.v21.enums.ConversionActionStatusEnum.ConversionActionStatus;
import com.google.ads.googleads.v21.enums.ConversionActionTypeEnum.ConversionActionType;
import com.google.ads.googleads.v21.errors.GoogleAdsError;
import com.google.ads.googleads.v21.errors.GoogleAdsException;
import com.google.ads.googleads.v21.resources.ConversionAction;
import com.google.ads.googleads.v21.resources.ConversionAction.ValueSettings;
import com.google.ads.googleads.v21.services.ConversionActionOperation;
import com.google.ads.googleads.v21.services.ConversionActionServiceClient;
import com.google.ads.googleads.v21.services.MutateConversionActionResult;
import com.google.ads.googleads.v21.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.V21.Errors;
using Google.Ads.GoogleAds.V21.Resources;
using Google.Ads.GoogleAds.V21.Services;
using System;
using static Google.Ads.GoogleAds.V21.Enums.ConversionActionCategoryEnum.Types;
using static Google.Ads.GoogleAds.V21.Enums.ConversionActionStatusEnum.Types;
using static Google.Ads.GoogleAds.V21.Enums.ConversionActionTypeEnum.Types;

namespace Google.Ads.GoogleAds.Examples.V21
{
    /// <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.V21.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\V21\GoogleAdsClient;
use Google\Ads\GoogleAds\Lib\V21\GoogleAdsClientBuilder;
use Google\Ads\GoogleAds\Lib\V21\GoogleAdsException;
use Google\Ads\GoogleAds\Lib\OAuth2TokenBuilder;
use Google\Ads\GoogleAds\V21\Enums\ConversionActionCategoryEnum\ConversionActionCategory;
use Google\Ads\GoogleAds\V21\Enums\ConversionActionStatusEnum\ConversionActionStatus;
use Google\Ads\GoogleAds\V21\Enums\ConversionActionTypeEnum\ConversionActionType;
use Google\Ads\GoogleAds\V21\Errors\GoogleAdsError;
use Google\Ads\GoogleAds\V21\Resources\ConversionAction;
use Google\Ads\GoogleAds\V21\Resources\ConversionAction\ValueSettings;
use Google\Ads\GoogleAds\V21\Services\ConversionActionOperation;
use Google\Ads\GoogleAds\V21\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.v21.resources.types.conversion_action import (
    ConversionAction,
)
from google.ads.googleads.v21.services.services.conversion_action_service import (
    ConversionActionServiceClient,
)
from google.ads.googleads.v21.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="v21"
    )

    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::V21::Resources::ConversionAction;
use Google::Ads::GoogleAds::V21::Resources::ValueSettings;
use Google::Ads::GoogleAds::V21::Enums::ConversionActionCategoryEnum
  qw(DEFAULT);
use Google::Ads::GoogleAds::V21::Enums::ConversionActionTypeEnum   qw(WEBPAGE);
use Google::Ads::GoogleAds::V21::Enums::ConversionActionStatusEnum qw(ENABLED);
use
  Google::Ads::GoogleAds::V21::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::V21::Resources::ConversionAction->new({
      name                          => $conversion_action_name,
      category                      => DEFAULT,
      type                          => WEBPAGE,
      status                        => ENABLED,
      viewThroughLookbackWindowDays => 15,
      valueSettings                 =>
        Google::Ads::GoogleAds::V21::Resources::ValueSettings->new({
          defaultValue          => 23.41,
          alwaysUseDefaultValue => "true"
        })});

  # Create a conversion action operation.
  my $conversion_action_operation =
    Google::Ads::GoogleAds::V21::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

הדוגמאות הקודמות הן כלליות, לכן ריכזנו כאן הערות נוספות כדי שConversionAction יוגדר בצורה נכונה בקמפיינים למיקסום הביצועים. צריך להגדיר כל אחת מפעולות ההמרה באופן הבא:

  • סוג – מגדירים את ConversionActionType כ-WEBPAGE, כי אירועי הרכישות האלה מתרחשים באתר.

  • המרות שאפשר להגיש עליהן הצעות מחיר – מגדירים את הערך true לפעולת ההמרה הראשית (רכישה) כדי לבצע אופטימיזציה של הקמפיינים להשגת מכירות. לפעולות המרה משניות (למשל, הוספה לעגלת הקניות), מגדירים את הערך כ-false.

  • קטגוריה – לכל אחת מפעולות ההמרה (ראשית או משנית),מגדירים את ConversionActionCategory. בהמשך מפורטת קטגוריית הפעולה הרלוונטית בשיחה לכל אחת מ-7 פעולות ההמרה שאנחנו ממליצים להטמיע. שימו לב: מערכת Google Ads מקצה באופן אוטומטי פעולות המרה ליעד המרה רגיל על סמך הקטגוריה שלהן. לדוגמה, פעולות המרה מסוג 'רכישה' מוקצות ליעד ההמרה הרגיל שנקרא 'רכישות'. בשלב מאוחר יותר, תוכלו להגדיר לקמפיין למיקסום הביצועים אופטימיזציה להשגת היעד 'רכישות'.

בהמשך מופיעה רשימה של פעולות המרה מומלצות. מומלץ להטמיע לפחות את ארבע פעולות ההמרה הראשונות וכמה שיותר מהפעולות המומלצות האחרות.

כדאי גם להטמיע אירועים נוספים שרלוונטיים למכירות אונליין. כדי לעקוב בצורה מפורטת יותר, אפשר גם ליצור פעולות המרה נוספות או פעולות המרה בהתאמה אישית (לדוגמה, פעולה מסוג 'הוספת פרטי תשלום' בכל פעם שמשתמש משתמש באפשרות החיפוש באתר, או פעולה מסוג 'חיפוש' בכל פעם שמשתמש משתמש באפשרות החיפוש באתר). פעולות המרה משניות מספקות למוכרים מעקב נוסף, ומערכת Google Ads משתמשת בהן לתצפית.

עדיפות פעולת המרה קטגוריית פעולת המרה שם האירוע ב-Google Tag תיאור
חובה רכישה קנה purchase משתמש מבצע רכישה
מומלץ מאוד לכל בוני החנויות הוספה לעגלת הקניות ADD_TO_CART add_to_cart משתמש מוסיף מוצר לעגלת הקניות
מומלץ מאוד לכל בוני החנויות התחלת התשלום בקופה BEGIN_CHECKOUT begin_checkout המשתמש מתחיל את תהליך התשלום בקופה
מומלץ מאוד לכל בוני החנויות צפייה בפריט PAGE_VIEW page_view משתמש פותח דף מוצר
מומלץ מאוד כשהדבר רלוונטי (בדרך כלל לא רלוונטי לבעלים של חנויות פיזיות) הרשמה הרשמה sign_up משתמש נרשם לחשבון
מומלץ מאוד כשהדבר רלוונטי (בדרך כלל לא רלוונטי לבעלים של חנויות פיזיות) יצירת ליד SUBMIT_LEAD_FORM generate_lead משתמש יוצר ליד באמצעות טופס
מומלץ מאוד כשהדבר רלוונטי (בדרך כלל לא רלוונטי לבעלים של חנויות פיזיות) להרשמה SUBSCRIBE_PAID לא רלוונטי (בהתאמה אישית) משתמש שנרשם לשירות בתשלום
מומלץ מאוד כשהדבר רלוונטי (בדרך כלל לא רלוונטי לבעלים של חנויות פיזיות) קביעת תור או פגישה BOOK_APPOINTMENT לא רלוונטי (בהתאמה אישית) משתמש קובע פגישה
מומלץ מאוד כשהדבר רלוונטי (בדרך כלל לא רלוונטי לבעלים של חנויות פיזיות) בקשה להצעת מחיר REQUEST_QUOTE לא רלוונטי (בהתאמה אישית) משתמש שולח טופס עם בקשה להערכת מחיר

מוכרים שיש להם חשבון Ads קיים

אם תאפשרו למוכרים להצטרף באמצעות חשבון Ads קיים, יכול להיות שתתקלו במצב שבו לחשבון כבר יש פעולות המרה. לא מומלץ להשתמש בפעולת המרה קיימת, כי אין ערובה שהיא הוגדרה כראוי. בנוסף, יש עוד שלבים שצריך לבצע כדי לטפל בתרחישים האפשריים האלה:

  • בחשבון יש כמה יעדים (לדוגמה, 'רכישות' + 'צפיות בדף' + 'אנשי קשר') שכולם מסומנים בתור 'ברירת מחדל לחשבון'. כשיוצרים קמפיין חדש, המערכת מבצעת אופטימיזציה לאותם יעדים כברירת מחדל. לא רוצים שזה יקרה בקמפיין למיקסום הביצועים.

  • בחשבון כבר יש פעולת המרה אחת (או יותר) למעקב אחר רכישות, והיא כבר מקובצת בקטע 'רכישות'. פירוש הדבר הוא שהקמפיין מחשב רכישה כפולה, כי שני תגי המרה מופעלים.

כדי לוודא שהקמפיין למיקסום הביצועים ישתמש בפעולה המותאמת אישית של ההמרה, ורק בפעולה הזו:

  1. יוצרים CustomConversionGoal ומוסיפים את פעולת ההמרה 'רכישה' לרשימת conversion_actions[] של היעד. מגדירים את הסטטוס ל-ENABLED.

  2. בקמפיין למיקסום הביצועים, בקטע ConversionGoalCampaignConfig, מגדירים את הערך של custom_conversion_goal ליעד המותאם אישית שיצרתם בשלב (1).

  3. כתוצאה משלב (2), מערכת Google Ads אמורה הייתה לעדכן באופן אוטומטי את ConversionGoalCampaignConfig של הקמפיין כך שהערך של goal_config_level יהיה CAMPAIGN (במקום CUSTOMER, שיגרום למערכת להשתמש ביעדים שמוגדרים כברירת מחדל בחשבון). עם זאת, כדאי לוודא שזה אכן קרה.

אחזור התג של פעולת ההמרה

אחרי שיוצרים את פעולת ההמרה, צריך להוסיף את קטע הקוד התואם שנקרא תג לדף ההמרה באתר של המפרסם. כדי להבטיח שמערכת Google Ads תוכל למדוד את כל ההמרות, ללא קשר לדפדפן של הלקוח, צריך להשתמש בתג מעקב ההמרות העדכני של Google Ads. התג הזה מורכב משני חלקים:

  • התג global_site_tag, שצריך להתקין בכל דף באתר של המפרסם.

  • event_snippet, שצריך להוסיף לדפי אינטרנט שמציינים פעולת המרה, כמו דף אישור תשלום או דף שליחת לידים.

אפשר לאחזר את שני החלקים האלה באמצעות ConversionActionService.

התג מגדיר קובצי cookie שמאחסנים מזהה ייחודי של לקוח או של הקליק על המודעה שהביא את הלקוח לאתר. קובצי ה-cookie מקבלים את המידע לגבי הקליקים על המודעות מפרמטר מספר הקליק ב-Google (GCLID) שכלול בתג מעקב ההמרות. צריך להפעיל באתר של המפרסם ובמערכת למעקב אחר לידים את האפשרות לתעד ולשמור את ה-GCLID, שהוא המזהה הייחודי שמערכת Google Ads מספקת לכל חשיפה של מודעה של Google.

מידע נוסף על התג ברמת האתר ואיפה להתקין אותו

Google Tag‏ (gtag.js) הוא מסגרת תיוג ו-API שמאפשרים לשלוח נתוני אירועים גם ל-Google Ads וגם ל-Google Analytics. תג המעקב ברמת האתר פועל בשילוב עם קטע קוד של אירוע (event snippet) או קטע קוד להחלפת מספר טלפון, כדי לעקוב אחר ההמרות שלכם. מוסיפים את Google Tag לקטע <head> בכל דף באתר של המפרסם ומגדירים אותו לעבודה עם Google Ads. לאחר מכן תוכלו להשתמש בפקודות gtag()‎ כדי לתעד אירועים ולשלוח נתונים אל Google Ads. במאמר שימוש בתג המעקב ברמת האתר לצורך מעקב המרות ב-Google Ads מוסבר איך זה עובד.

משתמשים בפקודות הבאות עם Google Tag:

  • config: איפוס של מוצר Google (Google Ads,‏ Analytics וכו'), הגדרת ההגדרות והכנה לשליחת נתונים לחשבון.

  • event: כדי לרשום המרה, שולחים אירוע כמו רכישה (מומלץ) או הוספה לעגלת קניות (פעולות המרה משניות). מומלץ לעיין במדריך העזר בנושא אירועים ב-gtag.js.

  • set: הגדרת פרמטרים שיהיו משותפים לכל האירועים בדף, כמו מטבע.

הדוגמה הבאה היא קטע קוד של JavaScript של תג המעקב ברמת האתר, שמשמש לשליחת נתונים אל Google Ads. ערך placeholder‏ GOOGLE_CONVERSION_ID הוא מזהה מספרי ייחודי של חשבון מפרסם יחיד.

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

קטע הקוד של Google Tag צריך להופיע רק פעם אחת בכל דף. אם יש כבר מופע של gtag.js, צריך להוסיף מזהי תגים חדשים לתג הקיים. כדי לשלוח נתונים לכמה חשבונות, אפשר להוסיף קריאה לפקודה 'config' לכל חשבון שבו אתם משתמשים, ולציין את מזהה ההמרה של כל חשבון, כפי שמתואר בדוגמה הבאה:

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

מידע נוסף על קטע הקוד של האירוע (event snippet) ואיפה אפשר להתקין אותו

כדי שמעקב ההמרות מסוג רכישה יפעל, צריך להוסיף את קטע הקוד של אירוע הרכישה לדף ההמרה עצמו. בדרך כלל זהו דף אישור ההזמנה. אפשר למקם אותו בכל מקום בקוד, אחרי קטע הקוד של התג הגלובלי. קטעי הקוד של האירועים של פעולות ההמרה המשניות (למשל: הוספה לעגלת הקניות) צריכים להיות ממוקמים בדפים המתאימים.

בקטע הקוד לדוגמה שבהמשך, AW-CONVERSION_ID ו-gTag_developer_ID מייצגים את מזהה ההמרה הייחודי לחשבון Google Ads ולחשבון הפיתוח של Google Tag, ו-AW-CONVERSION_LABEL מייצג את תווית ההמרה, שהיא ייחודית לכל פעולת המרה:

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

חלק מהפרמטרים הם אופציונליים, אבל מומלץ לכלול כמה שיותר מידע לגבי כל אירוע. מידע נוסף על הפרמטרים שזמינים לכל סוג אירוע

פרמטרים מספקים מידע נוסף על הדרכים שבהן משתמשים מקיימים אינטראקציה עם האתר או האפליקציה שלכם.

אם רוצים למדוד אירוע המרה על סמך קליק (למשל, על לחצן או על תגובה דינמית לאתר באמצעות AJAX), אפשר להשתמש במקום זאת בקטע הקוד הבא:

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

ב-Google Tag יש ממשק Consent API מובנה לניהול הסכמת המשתמשים. הוא יכול להבדיל בין הסכמת המשתמשים לשימוש בקובצי cookie למטרות פרסום לבין הסכמתם לשימוש בקובצי cookie למטרות ניתוח נתונים.

התוצאה הצפויה היא שהלקוחות יקבלו לפחות את הקריאה המשולבת gtag('consent', 'update'{‎…}), בלי שהלקוח יצטרך לבצע פעולה כלשהי. הפעולה הזו אמורה להבטיח שתגי Google (Google Ads, ‏ Floodlight, ‏ Google Analytics, ‏ Conversion Linker) יוכלו לקרוא את מצב ההסכמה העדכני של המשתמש ולכלול את המצב בבקשות הרשת ל-Google (באמצעות הפרמטר &gcs).

שלבי הטמעה נוספים כוללים פריסה או סיוע למפרסמים בפריסה (למשל, דרך ממשק משתמש) של המצב gtag('consent', default' {...}) וביטול החסימה של תגי Google (לדוגמה: אין הפעלה מותנית שמבוססת על הסכמה) כדי לאפשר לסטטוס ההסכמה להפעיל אותם באופן שמתחשב בהסכמה.

פרטים על ההטמעה זמינים במאמר ניהול של הגדרות ההסכמה (אתרים).

טיפים

חשבון הניהול ב-Google Ads מאפשר לכם לעקוב אחרי המרות בכל חשבונות המפרסמים שלכם באמצעות תג קוד המרות אחד. מידע נוסף על מעקב המרות ברמת חשבון ניהול

הדרך הטובה ביותר לבדוק אם הטמעת מעקב ההמרות פועלת היא להיכנס לאחד מהאתרים של המוכרים (או לאתר בדיקה פנימי) ולבצע רכישה אמיתית. לאחר מכן, תוכלו להיעזר במדריך לפתרון בעיות הזה בכלי Google Tag Assistant כדי לוודא שמערכת Google Ads זיהתה את התג שלכם והיא מתעדת המרות בהצלחה. כדי לפתור בעיות נוספות, אפשר לעיין במאמר פתרון בעיות בתיוג של כל דפי האתר (sitewide).

אפשר להוסיף לתג ההמרה הקודם המרות משופרות, שיכולות לשפר את הדיוק של מעקב ההמרות ולאפשר בידינג עם ביצועים טובים יותר. מידע נוסף על הגדרת המרות משופרות לפני שמטמיעים המרות משופרות, צריך לוודא שהמוכרים יכולים לעמוד בדרישות של המדיניות בנושא נתוני לקוחות של המרות משופרות ב-Google Ads.

הקודם
קישור חשבון Google Ads
הבא
4.2 יצירת קמפיין פרסום