4.1.5 Conversion-Tracking

Wert und Auswirkungen auf das Unternehmen

Damit Sie die leistungsstarken Funktionen für maschinelles Lernen und Analysen des Google-Systems für die Werbekampagnen Ihrer 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 eine festgelegte Aktion ausführt, nachdem er auf eine Anzeige geklickt hat, z. B. ein Produkt kauft, eine mobile App installiert oder sich für eine E-Mail-Liste registriert. Conversion-Tracking liefert wichtige Informationen zu den Aktionen von Nutzern, nachdem sie sich eine Anzeige angesehen oder darauf geklickt haben. Dazu gehören auch Informationen zum Berechnen und Vergleichen des Return on Investment (ROI), damit Ihre Kunden fundierte Entscheidungen darüber treffen können, wo sie ihre Werbeausgaben konzentrieren sollten. Durch das Tracking wird außerdem sichergestellt, dass Daten für die Abgleichszwecke verfügbar sind. Bestellungen unterscheiden sich je nach Produkt oder Kategorie. Conversion-Tracking kann daher auch hilfreich sein, um zu sehen, wie sich bestimmte Eintragsgruppen in Verkäufe umwandeln.

Ein Conversion-Zielvorhaben ist eine Gruppe von Conversion-Aktionen mit demselben zugrunde liegenden Zielvorhaben. „Kauf“ kann beispielsweise ein Conversion-Zielvorhaben sein, das „Websitekäufe“ und „Ladenverkäufe“ als Conversion-Aktionen hat.

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

Conversion-Aktion vom Typ „Kauf“

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

Andere Conversion-Aktionen

Die Kauf-Conversion-Aktion ist zwar erforderlich, aber das Erfassen zusätzlicher Conversion-Aktionen kann Ihren Händlern zusätzliche Informationen liefern. Wir empfehlen, möglichst alles zu erfassen und so viele der wichtigsten Conversion-Aktionen wie möglich zu implementieren. Eine vollständige Liste der empfohlenen Conversion-Aktionen finden Sie im Abschnitt „Tech API-Leitfaden“.

Im Allgemeinen empfehlen wir Folgendes zu erfassen:

  • Alle Erfolgsereignisse, die direkt mit dem Wert verknüpft sind
  • Erfolgsereignisse, die zu wichtigen Conversions beitragen, z. B. „add_to_cart“ und „sign_up“.
  • Interaktionen und Nutzerinteraktionen, mit denen Werbetreibende nachvollziehen können, wie sie mit ihren Endnutzern interagieren

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

UX-Leitfaden

Um das Risiko von Fehlern zu minimieren, empfehlen wir Ihnen, das Conversion-Tracking programmatisch ohne Händlereingaben zu implementieren. Sie sollten Ihre Händler jedoch darüber informieren, dass das Conversion-Tracking eingerichtet wurde.

Wenn Händler ein bestehendes Google Ads-Konto verknüpfen, empfehlen wir, eine Benachrichtigung zu senden, dass in ihrem Konto möglicherweise bereits Conversion-Tracking eingerichtet ist. Es kann zu Konflikten kommen, die behoben werden müssen. Unten sehen Sie ein Beispiel.

connect_your_google_ads_account

Technische Hinweise

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

  1. Sie erstellen im Google Ads-Konto des Händlers die Conversion-Aktion „ConversionAction“, um Käufe (und optional andere Kundenaktionen) auf seiner Website zu erfassen.

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

  3. Wenn ein Nutzer auf die Anzeige klickt, wird auf seinem Computer oder Mobilgerät 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 eine Conversion zusammen mit anderen Parametern wie „value“ (Wert), sofern zutreffend.

Voraussetzungen

Sie benötigen eine Entwickler-ID für das Google-Tag. Wenn Sie noch keine Entwickler-ID für Google-Tags haben, füllen Sie das Anfrageformular für die Entwickler-ID für Google-Tags aus. Ihre Entwickler-ID unterscheidet sich von anderen IDs wie der Mess-ID oder Conversion-ID, die Ihre Endnutzer ihrem Website-Messcode hinzufügen.

Conversion-Aktionen erstellen und konfigurieren

In den folgenden Beispielen wird gezeigt, wie Sie eine Conversion-Aktion erstellen und einem Google Ads-Konto hinzufügen. Bei jedem Beispiel werden alle Aufgaben für die Authentifizierung im Hintergrund für Sie erledigt und Sie werden durch das Erstellen einer Conversion-Aktion geführt:

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

Da die vorherigen Beispiele allgemein gehalten sind, finden Sie hier weitere Hinweise, damit die ConversionAction für Performance Max-Kampagnen richtig konfiguriert ist. Jede Conversion-Aktion sollte so konfiguriert sein:

  • Typ: Legen Sie ConversionActionType auf WEBPAGE fest, da diese Kaufereignisse auf einer Website stattfinden.

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

  • Kategorie: Legen Sie für jede Conversion-Aktion (primär oder sekundär) die ConversionActionCategory fest. Unten finden Sie die relevante Kategorie für die Unterhaltungsaktion für jede der sieben Conversion-Aktionen, die wir empfehlen. Hinweis: In Google Ads werden Conversion-Aktionen basierend auf ihrer Kategorie automatisch einem Standard-Conversion-Zielvorhaben zugewiesen. Conversion-Aktionen vom Typ „Kauf“ werden beispielsweise dem Standard-Conversion-Zielvorhaben „Käufe“ zugewiesen. Später können Sie die Performance Max-Kampagne so konfigurieren, dass sie für dieses Zielvorhaben optimiert wird.

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

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

Priorität Conversion-Aktion Kategorie der Conversion-Aktion Name des Google-Tag-Ereignisses Beschreibung
Obligatorisch Kaufen KAUF purchase Nutzer schließt einen Kauf ab
Dringend empfohlen für alle Store Builder In den Einkaufswagen ADD_TO_CART add_to_cart Nutzer legt ein Produkt in den Einkaufswagen
Dringend empfohlen für alle Store Builder Bezahlvorgang starten BEGIN_CHECKOUT begin_checkout Nutzer startet den Bezahlvorgang
Dringend empfohlen für alle Store Builder Element ansehen PAGE_VIEW page_view Nutzer öffnet eine Produktseite
Dringend empfohlen, sofern zutreffend (gilt in der Regel nicht für Store Builder) Registrieren REGISTRIEREN sign_up Nutzer registriert sich für ein Konto
Dringend empfohlen, sofern zutreffend (gilt in der Regel nicht für Store Builder) Lead generieren SUBMIT_LEAD_FORM generate_lead Nutzer generiert einen Lead über ein Formular
Dringend empfohlen, sofern zutreffend (gilt in der Regel nicht für Store Builder) Abonnieren SUBSCRIBE_PAID Nicht zutreffend (benutzerdefiniert) Nutzer abonniert einen kostenpflichtigen Dienst
Dringend empfohlen, sofern zutreffend (gilt in der Regel nicht für Store Builder) Termin vereinbaren BOOK_APPOINTMENT Nicht zutreffend (benutzerdefiniert) Nutzer vereinbart einen Termin
Dringend empfohlen, sofern zutreffend (gilt in der Regel nicht für Store Builder) Angebot anfordern REQUEST_QUOTE Nicht zutreffend (benutzerdefiniert) Der Nutzer sendet ein Formular mit einer Preisanfrage.

Für Händler mit einem bestehenden Google Ads-Konto

Wenn Sie es Händlern erlauben, sich mit einem bestehenden Google Ads-Konto anzumelden, kann es vorkommen, dass das Konto bereits Conversion-Aktionen enthält. Wir empfehlen nicht, eine vorhandene Conversion-Aktion zu verwenden, da nicht garantiert werden kann, dass sie richtig eingerichtet ist. Außerdem sind zusätzliche Schritte erforderlich, um diese potenziellen Szenarien zu bewältigen:

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

  • Im Konto gibt es bereits eine oder mehrere Conversion-Aktionen zum Erfassen von Käufen, die bereits dem Zielvorhaben „Käufe“ zugeordnet sind. Das bedeutet, dass nach der Kampagne ein Kauf doppelt gezählt wird, da zwei Conversion-Tags ausgelöst werden.

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

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

  2. Legen Sie in der ConversionGoalCampaignConfig der Performance Max-Kampagne custom_conversion_goal auf das benutzerdefinierte Zielvorhaben fest, das Sie in Schritt 1 erstellt haben.

  3. Durch Schritt 2 sollte die ConversionGoalCampaignConfig der Kampagne in Google Ads automatisch so aktualisiert worden sein, dass goal_config_level auf KAMPAGNE festgelegt ist (anstelle von KUNDEN, was dazu führen würde, dass die standardmäßigen Zielvorhaben des Kontos verwendet werden). Es empfiehlt sich jedoch, dies zu überprüfen.

Tag für die Conversion-Aktion abrufen

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

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

  • Das event_snippet, das auf Webseiten platziert werden sollte, die eine Conversion-Aktion anzeigen, z. B. eine Zahlungsbestätigungs- oder Lead-Einreichungsseite.

Sie können diese beiden Teile mit ConversionActionService abrufen.

Das Tag setzt Cookies, in denen eine eindeutige Kennzeichnung für den 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-Parameter (GCLID), der im Conversion-Tracking-Tag enthalten ist. Sie müssen die Website und das Lead-Tracking-System des Werbetreibenden so einrichten, dass die GCLID erfasst und gespeichert wird. Die GCLID ist die eindeutige ID, die Google Ads für jede Impression einer Google-Anzeige bereitstellt.

Weitere Informationen zum allgemeinen Tag und zur Platzierung

Das Google-Tag (gtag.js) ist ein Tagging-Framework und eine API, mit denen Sie Ereignisdaten sowohl an Google Ads als auch an Google Analytics senden können. Damit Ihre Conversions erfasst werden können, ist neben dem allgemeinen Website-Tag zusätzlich ein Ereignis-Snippet oder ein Telefon-Snippet erforderlich. Fügen Sie das Google-Tag auf jeder Seite der Website des Werbetreibenden im Bereich <head> ein und konfigurieren Sie es für die Verwendung mit Google Ads. Anschließend können Sie gtag()-Befehle verwenden, um Ereignisse zu erfassen und Daten an Google Ads zu senden. Wie das funktioniert, erfahren Sie unter Conversion-Tracking in Google Ads mit dem allgemeinen Website-Tag.

Sie verwenden die folgenden Befehle mit dem Google-Tag:

  • config:Hiermit wird ein Google-Produkt (z. B. Google Ads oder Analytics) initialisiert, die Einstellungen konfiguriert und der Versand von Daten an ein Konto vorbereitet.

  • event:Registrieren Sie eine Conversion, indem Sie ein Ereignis wie „purchase“ (empfohlen) oder „In den Einkaufswagen“ (sekundäre Conversion-Aktionen) senden. Weitere Informationen finden Sie in der Referenz für gtag.js-Ereignisse.

  • set:Hiermit legen Sie Parameter fest, die für alle Ereignisse auf der Seite gelten, z. B. die Währung.

Im folgenden Beispiel sehen Sie ein JavaScript-Code-Snippet des allgemeinen Website-Tags, mit dem 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 sollte nur einmal pro Seite vorkommen. 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 für jedes Konto, das Sie verwenden, einen Aufruf des Befehls „config“ hinzufügen und dabei die Conversion-ID des jeweiligen Kontos angeben. Das sieht so aus:

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

Damit Kauf-Conversions erfasst werden können, muss das Ereignis-Snippet für Käufe direkt auf der Conversion-Seite eingefügt werden. Dies ist in der Regel die Seite mit der Bestellbestätigung. Es kann im Code an einer beliebigen Position nach dem allgemeinen Website-Tag platziert werden. Die Ereignis-Snippets für sekundäre Conversion-Aktionen (z. B. „In den Einkaufswagen legen“) sollten auf den entsprechenden Seiten platziert werden.

Im folgenden Beispiel-Snippet stehen AW-CONVERSION_ID und gTag_developer_ID für die 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>

Einige Parameter sind optional. Wir empfehlen jedoch, für jedes Ereignis so viele Informationen wie möglich anzugeben. Weitere Informationen zu den Parametern, die für jeden Ereignistyp verfügbar sind

Parameter geben Aufschluss darüber, 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 enthält eine integrierte Consent API, mit der die Nutzereinwilligung verwaltet wird. Es kann zwischen der Nutzereinwilligung für Cookies zu Werbezwecken und zu Analysezwecken unterschieden werden.

Das erwartete Ergebnis ist, dass Kunden mindestens den gtag('consent', 'update' {...})-Aufruf erhalten, ohne dass der Kunde etwas tun muss. So können Google-Tags (Google Ads, Floodlight, Google Analytics, Conversion-Verknüpfung) den aktuellen Einwilligungsstatus des Nutzers lesen und den Status in Netzwerkanfragen an Google (über den Parameter &gcs) einschließen.

Weitere Implementierungsschritte wären die Implementierung oder Unterstützung von Werbetreibenden bei der Implementierung (z. B. über eine Benutzeroberfläche) des Status „gtag('consent', default' {...})“ und das Aufheben der Blockierung von Google-Tags (z. B. kein nutzungsbasiertes bedingtes Auslösen), damit sie im Einwilligungsmodus nutzungsabhängig ausgelöst werden.

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

Tipps

Im Google Ads-Verwaltungskonto können Sie mit einem einzigen Conversion-Code-Tag Conversions in allen Werbetreibendenkonten erfassen. Weitere Informationen zum kontoübergreifenden Conversion-Tracking

Am besten testen Sie, ob die Implementierung des Conversion-Trackings funktioniert, indem Sie eine der Websites Ihrer Händler (oder eine interne Testwebsite) aufrufen und einen echten Kauf abschließen. Sie können dann im Google Tag Assistant und mithilfe dieses Leitfadens zur Fehlerbehebung prüfen, ob Google Ads Ihr Tag erkannt hat und Conversions erfasst. Weitere Informationen zur Fehlerbehebung finden Sie unter Websiteweites Tagging – Fehlerbehebung.

Sie können das Conversion-Tag oben durch erweiterte Conversions ergänzen. So lässt sich die Genauigkeit Ihrer Conversion-Analyse verbessern und Sie können leistungsstärkere Gebotsoptionen nutzen. Weitere Informationen zum Einrichten erweiterter Conversions Bevor Sie erweiterte Conversions einrichten, sollten Sie prüfen, ob Ihre Händler die Richtlinien für Kundendaten zu erweiterten Conversions in Google Ads einhalten können.

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