4.1.5 מעקב המרות

הערך וההשפעה העסקית

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

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

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

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

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

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

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

אומנם נדרשת רק פעולת המרה מסוג רכישה, אבל המערכת עוקבת אחרי המרות נוספות פעולות המרה יכולות לספק למוֹכרים תובנות נוספות. רביעי מומלץ לרשום את כל הנתונים האפשריים, ובמקביל להטמיע כמה שיותר פעולות המרה מרכזיות. רשימה מלאה של פעולות ההמרה המומלצות שמתוארים בסעיף ההנחיות ל-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.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

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

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

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

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

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

כדאי גם לשקול ליישם אירועים נוספים שרלוונטיים למכירות אונליין. לקבלת הנחיות מפורטות יותר מעקב, אפשר גם ליצור פעולות המרה נוספות או פעולות המרה (לדוגמה, פעולה עבור 'הוספת פרטי תשלום' בכל פעם שמשתמש מבצע חיפוש באתר, או פעולה של "search" בכל פעם שמשתמש מבצע חיפוש באתר). משנית פעולות המרה מספקות מעקב נוסף למוֹכרים, משמש את 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 לא רלוונטי (בהתאמה אישית) המשתמש שולח טופס בקשה להערכת מחיר

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

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

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

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

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

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

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

  3. כתוצאה משלב (2), מערכת Google Ads הייתה אמורה לעדכן באופן אוטומטי את 'ConversionDestinationCampaignConfig' של הקמפיין, כך שהפרמטר 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 וכו'), לקבוע את ההגדרות ולהתכונן לשליחת נתונים לחשבון.

  • אירוע: רישום המרה על ידי שליחת אירוע כמו רכישה (מומלץ) או הוספה לעגלת קניות (פעולות המרה משניות). מומלץ לעיין במדריך העזר לאירועים של 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>

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

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

בקטע הקוד לדוגמה שבהמשך, AW-CONVERSION_ID ו-gTag_developer_ID לייצג את מזהה ההמרה הייחודי לחשבון Google Ads שלכם תג חשבון מפתח, ואילו 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 למטרות פרסום לבין הסכמת המשתמשים לניתוח נתונים למטרות.

התוצאה הצפויה היא שהלקוחות יקבלו לפחות את gtag('consent', 'update' {...}) השיחה משולבת ללא פעולה מצד הלקוח. הפעולה הזו לוודא שתגי Google Tag (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 יצירת קמפיין פרסום