4.1.5 Conversion-Tracking

Wert und geschäftliche Auswirkungen

Damit Sie die leistungsfähigen Machine-Learning- und Analysefunktionen von Google für Ihre Werbekampagnen von Händlerkunden effektiv nutzen können, müssen Sie Conversion-Tracking- und Remarketing-Tags auf den Kundenwebsites platzieren.

Eine Conversion in Google Ads wird erfasst, wenn ein Nutzer nach dem Klick auf eine Anzeige eine bestimmte Aktion ausführt, z. B. den Kauf eines Produkts, die Installation einer mobilen App oder die Anmeldung für eine E-Mail-Liste. Mit Conversion-Tracking erhalten Sie wichtige Informationen zu den Aktionen, die Nutzer ausführen, nachdem sie eine Anzeige gesehen oder darauf geklickt haben. Dazu gehören auch Informationen zum Berechnen und Vergleichen des Return on Investment (ROI). So können Ihre Kunden entscheiden, worauf sie ihre Werbeausgaben konzentrieren sollten. Mithilfe von Tracking können Sie außerdem sicherstellen, dass die Daten für Abgleichzwecke verfügbar sind. Die Bestellungen unterscheiden sich je nach Produkt oder Kategorie. Daher kann Conversion-Tracking auch nützlich sein, um zu sehen, wie bestimmte Eintragsgruppen zu Verkäufen führen.

Ein Conversion-Zielvorhaben ist eine Gruppe von Conversion-Aktionen mit demselben zugrunde liegenden Zielvorhaben. Beispielsweise kann „Kauf“ ein Conversion-Zielvorhaben sein, für das „Käufe auf der Website“ und „Ladenverkäufe“ als Conversion-Aktionen festgelegt sind.

Conversion-Aktionen werden weiterhin verwendet, um Conversions zu erfassen und die Kampagne zu optimieren. Sie erstellen Conversion-Aktionen und Google gruppieren diese in Conversion-Zielvorhaben.

Kauf-Conversion-Aktion

Wenn Sie das hier beschriebene Conversion-Tracking einrichten, können im Google Ads-Konto Ihres Händlers die Anzahl der Kauf-Conversions und der Wert dieser Conversions gemessen werden. Ohne Conversion-Tracking können Sie den mit der Kampagne erzielten Geschäftswert nicht in Bezug auf den ROAS (Return on Advertising Spend) messen. Außerdem werden zusätzliche Datensignale gesendet, mit denen die Leistung der Kampagne optimiert werden kann.

Andere Conversion-Aktionen

Kauf-Conversion-Aktionen sind zwar nur erforderlich, aber das Erfassen zusätzlicher Conversion-Aktionen kann Ihren Händlern zusätzliche Informationen liefern. Wir empfehlen, alles wie möglich zu protokollieren und so viele der wichtigsten Conversion-Aktionen zu implementieren. Eine vollständige Liste der empfohlenen Conversion-Aktionen finden Sie im Abschnitt mit den technischen API-Hinweisen.

Im Allgemeinen wird empfohlen, Folgendes zu erfassen:

  • Jedes Erfolgsereignis, das direkt mit dem Wert verknüpft ist
  • Erfolgsereignisse, die zu grundlegenden Conversions beitragen, z. B. „add_to_cart“ und „sign_up“.
  • Interaktionen und Nutzerinteraktionen, anhand derer Werbetreibende verstehen, wie sie ihre Endnutzer ansprechen.

Sekundäre Conversion-Aktionen dienen nur der Beobachtung und Berichterstellung und wirken sich auf Gebote aus. Weitere Informationen zu primären und sekundären Conversion-Aktionen

UX-Anleitung

Um das Fehlerrisiko zu minimieren, empfehlen wir, das Conversion-Tracking programmatisch ohne Händlereingaben zu implementieren. Achten Sie aber darauf, dass Ihre Händler wissen, dass das Conversion-Tracking eingerichtet ist.

Wenn Händler ein bestehendes Google Ads-Konto verknüpfen, sollten Sie sich darüber informieren, dass für ihr Konto möglicherweise Conversion-Tracking bereits eingerichtet ist, da Konflikte auftreten können, die gelöst werden müssen. Unten sehen Sie ein Beispiel.

connect_your_google_ads_account

Technische Anleitung

So funktioniert Conversion-Tracking: In diesem Abschnitt werden die einzelnen Schritte näher erläutert:

  1. Erstellen Sie im Google Ads-Konto Ihres Händlers eine ConversionAction, um Käufe (und optional andere Kundenaktionen) zu erfassen, die auf der Website des Händlers getätigt werden.

  2. Sie fügen das Tag oder Code-Snippet für diese Conversion-Aktion einer Website oder mobilen App hinzu. Weitere Informationen finden Sie unter Conversion-Tracking für Ihre Website einrichten.

  3. Wenn ein Nutzer auf die Anzeige klickt, wird auf dem Computer oder Mobilgerät des Kunden ein temporäres Cookie gespeichert.

  4. Wenn der Kunde die für den Werbetreibenden definierte Aktion ausführt, erkennt Google das Cookie (über das hinzugefügte Code-Snippet) und erfasst gegebenenfalls eine Conversion zusammen mit anderen Parametern wie „Wert“.

Voraussetzungen

Sie benötigen eine Entwickler-ID für das Google-Tag. Wenn Sie keine Google-Tag-Entwickler-ID haben, füllen Sie das Antragsformular für die Google-Tag-Entwickler-ID aus. Ihre Entwickler-ID unterscheidet sich von anderen IDs, z. B. von der Mess-ID oder Conversion-ID, die Ihre Endnutzer in den Messcode ihrer Website einfügen.

Conversion-Aktionen erstellen und konfigurieren

Die folgenden Beispiele zeigen, wie Sie eine Conversion-Aktion erstellen und einem Google Ads-Konto hinzufügen. Jedes Beispiel übernimmt alle Aufgaben der Hintergrundauthentifizierung für Sie und führt Sie durch die Erstellung einer Conversion-Aktion:

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

Da die obigen Beispiele allgemein sind, möchten wir Sie darauf hinweisen, dass ConversionAction für Performance Max-Kampagnen richtig konfiguriert ist. Jede Conversion-Aktion sollte so konfiguriert werden:

  • Typ: Legen Sie für ConversionActionType die Option WEBPAGE fest, da diese Kaufereignisse auf einer Website erfolgen.

  • Gebotsierbar: Legen Sie true für Ihre primäre Conversion-Aktion (Kauf) fest, um Kampagnen für Verkäufe zu optimieren. Legen Sie für sekundäre Conversion-Aktionen (z. B. „In den Einkaufswagen“) den Wert false fest.

  • Kategorie: Legen Sie für jede primäre oder sekundäre Conversion-Aktion die ConversionActionCategory fest. Unten finden Sie die Kategorie der Unterhaltungsaktionen für jede der sieben Conversion-Aktionen, die wir implementieren sollten. In Google Ads werden Conversion-Aktionen anhand der Kategorie automatisch einem standardmäßigen Conversion-Zielvorhaben zugewiesen. Kauf-Conversion-Aktionen werden beispielsweise dem standardmäßigen Conversion-Zielvorhaben „Käufe“ zugewiesen. Später können Sie die Performance Max-Kampagne so konfigurieren, dass sie für dieses Zielvorhaben „Käufe“ optimiert wird.

Nachfolgend finden Sie eine Liste mit empfohlenen Conversion-Aktionen. Wir empfehlen, mindestens die ersten vier Conversion-Aktionen und so viele der anderen empfohlenen Maßnahmen wie möglich zu implementieren.

Sie können auch zusätzliche Ereignisse implementieren, die für Onlineverkäufe relevant sind. Für ein noch genaueres Tracking können Sie auch zusätzliche Conversion-Aktionen oder benutzerdefinierte Conversion-Aktionen erstellen, z. B. eine Aktion für „Zahlungsinformationen hinzufügen“, wenn ein Nutzer die Suchoption auf der Website verwendet, oder eine Aktion für „Suche“ jedes Mal, wenn ein Nutzer die Suchoption auf der Website verwendet. Sekundäre Conversion-Aktionen ermöglichen ein zusätzliches Tracking für Ihre Händler und werden in Google Ads zu Beobachtungszwecken verwendet.

Priorität Conversion-Aktion Kategorie der Conversion-Aktion Google-Tag-Ereignisname Beschreibung
Obligatorisch Kaufen KAUF purchase Der Nutzer schließt einen Kauf ab
Dringend empfohlen für alle Händler, die ein Geschäft aufbauen In den Einkaufswagen ADD_TO_CART add_to_cart Der Nutzer legt ein Produkt in den Einkaufswagen.
Dringend empfohlen für alle Händler, die ein Geschäft aufbauen Bezahlvorgang starten BEGIN_CHECKOUT begin_checkout Der Nutzer startet den Bezahlvorgang
Dringend empfohlen für alle Händler, die ein Geschäft aufbauen Element anzeigen PAGE_VIEW page_view Der Nutzer öffnet eine Produktseite
Dringend empfohlen, sofern anwendbar (in der Regel nicht für Store-Builder) Anmelden REGISTRIEREN sign_up Nutzer*in registriert sich für ein Konto
Dringend empfohlen, sofern anwendbar (in der Regel nicht für Store-Builder) Lead generieren SUBMIT_LEAD_FORM generate_lead Nutzer*in generiert einen Lead über ein Formular
Dringend empfohlen, sofern anwendbar (in der Regel nicht für Store-Builder) Abonnieren SUBSCRIBE_PAID nicht zutreffend (benutzerdefiniert) Nutzer abonniert einen kostenpflichtigen Dienst
Dringend empfohlen, sofern anwendbar (in der Regel nicht für Store-Builder) Termin vereinbaren BOOK_APPOINTMENT nicht zutreffend (benutzerdefiniert) Nutzer bucht einen Termin
Dringend empfohlen, sofern anwendbar (in der Regel nicht für Store-Builder) Angebot anfordern REQUEST_QUOTE nicht zutreffend (benutzerdefiniert) Der Nutzer reicht ein Formular ein, um eine Preisschätzung anzufordern

Händler mit einem bestehenden Google Ads-Konto

Wenn Sie Händlern die Einrichtung mit einem bestehenden Google Ads-Konto erlauben, kann es vorkommen, dass das Konto bereits Conversion-Aktionen hat. Wir raten davon ab, eine vorhandene Conversion-Aktion zu verwenden, da nicht garantiert werden kann, dass sie korrekt eingerichtet wurde. Darüber hinaus müssen Sie zusätzliche Schritte ausführen, um diese potenziellen Szenarien zu bewältigen:

  • Das Konto hat mehrere Zielvorhaben (z. B. Käufe + Seitenaufrufe + Kontakte), die alle als „Kontostandard“ gekennzeichnet sind. Wenn eine neue Kampagne erstellt wird, wird sie standardmäßig im Hinblick auf alle diese Zielvorhaben optimiert, für die Performance Max-Kampagne nicht.

  • Im Konto ist bereits mindestens eine Conversion-Aktion für das Tracking von Käufen vorhanden und sie ist bereits unter dem Zielvorhaben „Käufe“ gruppiert. Dies bedeutet, dass Käufe nach der Kampagne doppelt gezählt werden, da zwei Conversion-Tags ausgelöst werden.

So sorgen Sie dafür, dass in der Performance Max-Kampagne nur die benutzerdefinierte Conversion-Aktion und nur diese Aktion verwendet wird:

  1. Erstellen Sie ein CustomConversionGoal und fügen Sie die Conversion-Aktion „Kauf“ der Liste conversion_actions[] des Zielvorhabens hinzu. Legen Sie den Status auf AKTIVIERT fest.

  2. Legen Sie in der Konfiguration der Performance Max-Kampagne ConversionGoalCampaignConfig für custom_conversion_goal das in Schritt 1 erstellte benutzerdefinierte Zielvorhaben fest.

  3. In Schritt 2 sollte in Google Ads die ConversionGoalCampaignConfig der Kampagne automatisch so aktualisiert worden sein, dass goal_config_level auf CAMPAIGN gesetzt ist und nicht auf CUSTOMER, womit die Standardzielvorhaben auf Kontoebene verwendet werden. Sie sollten jedoch überprüfen, ob dies tatsächlich der Fall ist.

Tag für die Conversion-Aktion abrufen

Nachdem Sie die Conversion-Aktion erstellt haben, müssen Sie das entsprechende Code-Snippet, ein sogenanntes Tag, in die Conversion-Seite auf der Website des Werbetreibenden einfügen. Damit in Google Ads alle Conversions unabhängig vom Browser des Kunden gemessen werden können, sollten Sie das aktualisierte Google Ads-Conversion-Tracking-Tag verwenden. Dieses Tag besteht aus zwei Teilen:

  • Das global_site_tag-Objekt, das auf jeder Seite der Website des Werbetreibenden installiert werden muss.

  • Das event_snippet-Element, das auf Webseiten platziert werden muss, auf denen eine Conversion-Aktion angezeigt wird, z. B. eine Kaufbestätigung oder eine Seite zur Lead-Übermittlung.

Sie können diese beiden Teile mit ConversionActionService abrufen.

Das Tag setzt Cookies, in denen eine eindeutige Kennzeichnung für einen Kunden oder den Anzeigenklick gespeichert wird, über den der Kunde auf die Website gelangt ist. Die Cookies empfangen die Informationen zum Anzeigenklick aus einem Google Click Identifier (GCLID)-Parameter, der im Conversion-Tracking-Tag enthalten ist. Sie müssen die Website und das Lead-Erfassungssystem des Werbetreibenden aktivieren, damit die GCLID erfasst und gespeichert wird. Das ist die eindeutige ID, die Google Ads für jede Impression einer Google Anzeige bereitstellt.

Weitere Informationen zum allgemeinen Tag und dazu, wo es installiert werden muss

Das Google-Tag (gtag.js) ist ein Tagging-Framework und eine API, mit dem Sie Ereignisdaten sowohl an Google Ads als auch an Google Analytics senden können. Damit Conversions erfasst werden können, ist das allgemeine Website-Tag zusammen mit einem Ereignis-Snippet oder einem Telefon-Snippet erforderlich. Fügen Sie das Google-Tag auf jeder Seite auf der Website des Werbetreibenden im Abschnitt <head> ein und konfigurieren Sie es für Google Ads. Anschließend können Sie mit gtag()-Befehlen Ereignisse erfassen und Daten an Google Ads senden. Weitere Informationen finden Sie unter Das allgemeine Website-Tag für das Google Ads-Conversion-Tracking verwenden.

Sie verwenden die folgenden Befehle mit dem Google-Tag:

  • config: Initialisiert ein Google-Produkt (z. B. Google Ads oder Analytics), konfigurieren Sie Einstellungen und bereiten Sie das Senden von Daten an ein Konto vor.

  • Ereignis:Zum Erfassen einer Conversion wird ein Ereignis wie „Kauf“ (empfohlen) oder das Hinzufügen zum Einkaufswagen (sekundäre Conversion-Aktionen) gesendet. Wir empfehlen Ihnen, den Leitfaden zu gtag.js-Ereignissen zu lesen.

  • set:Hiermit werden Parameter festgelegt, die für alle Ereignisse auf der Seite gelten, z. B. eine Währung.

Im folgenden Beispiel sehen Sie ein JavaScript-Code-Snippet des allgemeinen Website-Tags, über das Daten an Google Ads gesendet werden. Der Platzhalterwert GOOGLE_CONVERSION_ID ist eine eindeutige numerische ID für ein einzelnes Werbetreibendenkonto.

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

Das Google-Tag-Snippet darf nur einmal pro Seite eingefügt werden. Wenn bereits eine Instanz von gtag.js vorhanden ist, sollten Sie dem vorhandenen Tag neue Tag-IDs hinzufügen. Wenn Sie Daten an mehrere Konten senden möchten, können Sie dem Befehl "config" für jedes verwendete Konto einen Aufruf hinzufügen. Dabei geben Sie die Conversion-ID für jedes Konto an, wie im folgenden Beispiel gezeigt:

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

Weitere Informationen zum Ereignis-Snippet und dazu, wo es installiert werden muss

Damit das Conversion-Tracking für Käufe funktioniert, muss das Ereignis-Snippet für Käufe direkt auf der Conversion-Seite eingefügt werden. Dies ist normalerweise die Seite zur Bestellbestätigung. Es kann im Code an einer beliebigen Stelle nach dem allgemeinen Tag-Snippet platziert werden. Die Ereignis-Snippets für sekundäre Conversion-Aktionen (z. B. „In den Einkaufswagen“) sollten auf den entsprechenden Seiten platziert werden.

Im folgenden Beispiel-Snippet stehen AW-CONVERSION_ID und gTag_developer_ID für die individuelle Conversion-ID Ihres Google Ads-Kontos und Ihres Google-Tag-Entwicklerkontos. AW-CONVERSION_LABEL steht für das Conversion-Label, das für jede Conversion-Aktion eindeutig ist:

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

Obwohl einige Parameter optional sind, sollten Sie für jedes Ereignis so viele Informationen wie möglich angeben. Weitere Informationen dazu, welche Parameter für die einzelnen Ereignistypen verfügbar sind

Parameter liefern zusätzliche Informationen dazu, wie Nutzer mit Ihrer Website oder App interagieren.

Wenn Sie ein Conversion-Ereignis basierend auf einem Klick erfassen möchten, z. B. auf eine Schaltfläche oder eine dynamische Antwort für eine Website mit AJAX, können Sie stattdessen auch das folgende Snippet verwenden:

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

Das Google-Tag hat eine integrierte Consent API, mit der die Nutzereinwilligung verwaltet werden kann. Damit lässt sich die Nutzereinwilligung für Cookies zu Werbezwecken von denen für Analysezwecke unterscheiden.

Das erwartete Ergebnis ist, dass Kunden mindestens den gtag('consent', 'update'{...})-Aufruf erhalten, ohne dass der Kunde etwas tun muss. Dadurch wird sichergestellt, dass über Google-Tags (Google Ads, Floodlight, Google Analytics, Conversion-Verknüpfung) der aktuelle Einwilligungsstatus der Nutzer gelesen und der Status in Netzwerkanfragen an Google über den Parameter „&gcs“ aufgenommen werden kann.

Weitere Implementierungsschritte wären das Bereitstellen des gtag('consent', default' {...})-Status und das Aufheben der Blockierung von Google-Tags (z. B. keine bedingte bedingte Auslösung auf Grundlage von Einwilligungen), um Werbetreibende dabei zu unterstützen (z. B. über eine UI), um den Einwilligungsmodus zu aktivieren und die Tags entsprechend der Einwilligung auszulösen.

Informationen zur Implementierung finden Sie unter Einwilligungseinstellungen verwalten (Web).

Tipps

Über das Google Ads-Verwaltungskonto können Sie Conversions für alle Werbetreibendenkonten mit einem einzigen Conversion-Code-Tag erfassen. Weitere Informationen finden Sie unter Kontoübergreifendes Conversion-Tracking.

Wenn Sie testen möchten, ob Ihre Conversion-Tracking-Implementierung funktioniert, rufen Sie am besten eine Ihrer Händlerwebsites (oder eine interne Testwebsite) auf und führen Sie einen echten Kauf durch. Anschließend können Sie im Google Tag Assistant mithilfe dieser Anleitung zur Fehlerbehebung prüfen, ob das Tag in Google Ads erkannt wurde und Conversions erfolgreich erfasst werden. Weitere Informationen zur Fehlerbehebung finden Sie unter Fehlerbehebung für websiteweites Tagging.

Sie können das vorherige Conversion-Tag durch erweiterte Conversions ergänzen. Dadurch lassen sich Conversions noch genauer erfassen und leistungsstärkere Gebotsoptionen nutzen. Weitere Informationen zum Einrichten erweiterter Conversions Bevor Sie erweiterte Conversions implementieren, sollten Sie dafür sorgen, dass Ihre Händler die Richtlinien für Kundendaten für erweiterte Conversions in Google Ads einhalten können.

Zurück
Google Ads-Konto wird verknüpft
Weiter
4.2 Anzeigenkampagnen erstellen