Diese Seite wurde von der Cloud Translation API übersetzt.

Merchant Center-Nutzungsbedingungen verwalten

Wenn Sie das Merchant Center und seine Funktionen nutzen möchten, müssen Sie die Merchant Center-Nutzungsbedingungen für Ihren Geschäftsstandort akzeptieren. In diesen Vereinbarungen werden die rechtlichen Bedingungen für die Nutzung von Merchant Center-Diensten beschrieben.

In dieser Anleitung erfahren Sie, wie Sie diese Vereinbarungen mit der Merchant API verwalten können, entweder für Ihr eigenes Konto oder für Konten, die Sie als Drittanbieter verwalten.

Sie können Folgendes erreichen:

Aktuellen Status der Nutzungsbedingungen für ein Konto prüfen
Händlern helfen, die erforderlichen Nutzungsbedingungen zu akzeptieren
Verwalten Sie Nutzungsbedingungen als Drittanbieter für Kundenkonten oder Standalone-Konten.

Vorbereitung

Um die Merchant API verwenden zu können, benötigen Sie ein Merchant Center-Konto. Nachdem Sie das Konto über die Merchant Center-Benutzeroberfläche erstellt haben, können Sie Änderungen daran vornehmen (z. B. Informationen zum Unternehmen aktualisieren oder Nutzer verwalten). Dazu können Sie entweder die Benutzeroberfläche oder die API verwenden.

Wenn Sie mehrere Konten verwalten müssen, können Sie Kundenkonten über die Merchant API erstellen. Weitere Informationen finden Sie unter Unterkonten erstellen und verwalten.

Status der Nutzungsbedingungen eines Kontos prüfen

Bevor ein Händler das Merchant Center vollständig nutzen kann oder wenn Sie den aktuellen Status seiner Vereinbarung überprüfen müssen, können Sie den Status seiner Nutzungsbedingungen abrufen.

Mit der Methode termsOfServiceAgreementStates.retrieveForApplication können Sie den Status der Nutzungsbedingungen für die Hauptanwendung des Merchant Centers abrufen. Diese Methode gibt Ihre aktuellen Nutzungsbedingungen zurück, sofern vorhanden, und, falls die Nutzungsbedingungen seit Ihrer letzten Akzeptanz aktualisiert wurden, die neueste Version, die Sie akzeptieren müssen.

Hier ein Beispiel für eine Anfrage:

GET https://merchantapi.googleapis.com/accounts/v1/accounts/{ACCOUNT_ID}/termsOfServiceAgreementStates:retrieveForApplication

Bei einem erfolgreichen Aufruf wird eine TermsOfServiceAgreementState-Ressource zurückgegeben. Diese Ressource enthält:

name: Die Kennzeichnung für diesen Vereinbarungsstatus.
regionCode: Das Land, für das dieser Vereinbarungsstatus gilt. Das ist in der Regel das Land, in dem sich der Geschäftssitz des Kontos befindet.
termsOfServiceKind: Dies ist MERCHANT_CENTER.
accepted: Details zur Version der Nutzungsbedingungen, die für das Konto bereits akzeptiert wurden, einschließlich des termsOfService-Ressourcennamens (z. B. termsOfService/132) und wer sie acceptedBy hat. Es kann auch ein validUntil-Datum enthalten sein, wenn eine neuere Version der Nutzungsbedingungen required ist.
required: Details zu einer Version der Nutzungsbedingungen, die das Konto akzeptieren muss. Dazu gehören der Ressourcenname termsOfService und ein tosFileUri, der auf das für Menschen lesbare Dokument mit den Nutzungsbedingungen verweist.

Beispielantwort:

{
  "name": "accounts/{ACCOUNT_ID}/termsOfServiceAgreementStates/MERCHANT_CENTER-{REGION_CODE}",
  "regionCode": "{REGION_CODE}",
  "termsOfServiceKind": "MERCHANT_CENTER",
  "accepted": {
    "termsOfService": "termsOfService/132",
    "acceptedBy": "accounts/{ACCOUNT_ID}"
  },
  "required": {
    "termsOfService": "termsOfService/132",
    "tosFileUri": "https://www.google.com/intl/{REGION_CODE}/policies/merchants/terms/"
  }
}

Wenn neue Nutzungsbedingungen required sind, sollten Sie den Händler bitten, sie zu akzeptieren.

Hier ist ein Beispiel, mit dem Sie den Status der Nutzungsbedingungen für ein bestimmtes Konto und Land abrufen können:

Java

import com.google.api.gax.core.FixedCredentialsProvider;
import com.google.auth.oauth2.GoogleCredentials;
import com.google.shopping.merchant.accounts.v1.GetTermsOfServiceAgreementStateRequest;
import com.google.shopping.merchant.accounts.v1.TermsOfServiceAgreementState;
import com.google.shopping.merchant.accounts.v1.TermsOfServiceAgreementStateName;
import com.google.shopping.merchant.accounts.v1.TermsOfServiceAgreementStateServiceClient;
import com.google.shopping.merchant.accounts.v1.TermsOfServiceAgreementStateServiceSettings;
import shopping.merchant.samples.utils.Authenticator;
import shopping.merchant.samples.utils.Config;

/**
 * This class demonstrates how to get a TermsOfServiceAgreementState for a specific
 * TermsOfServiceKind and country.
 */
public class GetTermsOfServiceAgreementStateSample {

  public static void getTermsOfServiceAgreementState(Config config) throws Exception {

    // Obtains OAuth token based on the user's configuration.
    GoogleCredentials credential = new Authenticator().authenticate();

    // Creates service settings using the credentials retrieved above.
    TermsOfServiceAgreementStateServiceSettings termsOfServiceAgreementStateServiceSettings =
        TermsOfServiceAgreementStateServiceSettings.newBuilder()
            .setCredentialsProvider(FixedCredentialsProvider.create(credential))
            .build();

    // Creates TermsOfServiceAgreementState name to identify TermsOfServiceAgreementState.
    String name =
        TermsOfServiceAgreementStateName.newBuilder()
            .setAccount(config.getAccountId().toString())
            // The Identifier is: "{TermsOfServiceKind}-{country}"
            .setIdentifier("MERCHANT_CENTER-US")
            .build()
            .toString();

    System.out.println(name);

    // Calls the API and catches and prints any network failures/errors.
    try (TermsOfServiceAgreementStateServiceClient termsOfServiceAgreementStateServiceClient =
        TermsOfServiceAgreementStateServiceClient.create(
            termsOfServiceAgreementStateServiceSettings)) {

      // The name has the format:
      // accounts/{account}/termsOfServiceAgreementStates/{TermsOfServiceKind}-{country}
      GetTermsOfServiceAgreementStateRequest request =
          GetTermsOfServiceAgreementStateRequest.newBuilder().setName(name).build();

      System.out.println("Sending Get TermsOfServiceAgreementState request:");
      TermsOfServiceAgreementState response =
          termsOfServiceAgreementStateServiceClient.getTermsOfServiceAgreementState(request);

      System.out.println("Retrieved TermsOfServiceAgreementState below");
      // If the terms of service needs to be accepted, the "required" field will include the
      // specific version of the terms of service which needs to be accepted, alongside a link to
      // the terms of service itself.
      System.out.println(response);
    } catch (Exception e) {
      System.out.println(e);
    }
  }


  public static void main(String[] args) throws Exception {
    Config config = Config.load();

    getTermsOfServiceAgreementState(config);
  }
}GetTermsOfServiceAgreementStateSample.java

PHP

use Google\ApiCore\ApiException;
use Google\Shopping\Merchant\Accounts\V1\Client\TermsOfServiceAgreementStateServiceClient;
use Google\Shopping\Merchant\Accounts\V1\GetTermsOfServiceAgreementStateRequest;

/**
 * Demonstrates how to get a TermsOfServiceAgreementState.
 */
class GetTermsOfServiceAgreementState
{

    /**
     * Gets a TermsOfServiceAgreementState.
     *
     * @param array $config The configuration data.
     * @return void
     */
    public static function getTermsOfServiceAgreementState($config): void
    {
        // Get OAuth credentials.
        $credentials = Authentication::useServiceAccountOrTokenFile();

        // Create client options.
        $options = ['credentials' => $credentials];

        // Create a TermsOfServiceAgreementStateServiceClient.
        $termsOfServiceAgreementStateServiceClient = new TermsOfServiceAgreementStateServiceClient($options);

        // Service agreeement identifier
        $identifier = "MERCHANT_CENTER-US";

        // Create TermsOfServiceAgreementState name.
        $name = "accounts/" . $config['accountId'] . "/termsOfServiceAgreementStates/" . $identifier;

        print $name . PHP_EOL;

        try {
            // Prepare the request.
            $request = new GetTermsOfServiceAgreementStateRequest([
                'name' => $name,
            ]);

            print "Sending Get TermsOfServiceAgreementState request:" . PHP_EOL;
            $response = $termsOfServiceAgreementStateServiceClient->getTermsOfServiceAgreementState($request);

            print "Retrieved TermsOfServiceAgreementState below\n";
            print $response->serializeToJsonString() . PHP_EOL;
        } catch (ApiException $e) {
            print $e->getMessage();
        }
    }

    /**
     * Helper to execute the sample.
     *
     * @return void
     */
    public function callSample(): void
    {
        $config = Config::generateConfig();

        self::getTermsOfServiceAgreementState($config);
    }

}

// Run the script
$sample = new GetTermsOfServiceAgreementState();
$sample->callSample();GetTermsOfServiceAgreementStateSample.php

Python

from examples.authentication import configuration
from examples.authentication import generate_user_credentials
from google.shopping.merchant_accounts_v1 import GetTermsOfServiceAgreementStateRequest
from google.shopping.merchant_accounts_v1 import TermsOfServiceAgreementStateServiceClient

# Replace with your actual value.
_ACCOUNT_ID = configuration.Configuration().read_merchant_info()
_IDENTIFIER = "MERCHANT_CENTER-US"  # Replace with your identifier


def get_terms_of_service_agreement_state():
  """Gets a TermsOfServiceAgreementState for a specific TermsOfServiceKind and country."""

  credentials = generate_user_credentials.main()
  client = TermsOfServiceAgreementStateServiceClient(credentials=credentials)

  name = (
      "accounts/"
      + _ACCOUNT_ID
      + "/termsOfServiceAgreementStates/"
      + _IDENTIFIER
  )

  print(name)

  request = GetTermsOfServiceAgreementStateRequest(name=name)

  try:
    print("Sending Get TermsOfServiceAgreementState request:")
    response = client.get_terms_of_service_agreement_state(request=request)
    print("Retrieved TermsOfServiceAgreementState below")
    print(response)
  except RuntimeError as e:
    print(e)


if __name__ == "__main__":
  get_terms_of_service_agreement_state()
get_terms_of_service_agreement_state_sample.py

Nutzungsbedingungen akzeptieren

Händler müssen die aktuellen Nutzungsbedingungen akzeptieren, um weiterhin auf Merchant Center-Funktionen zugreifen zu können.

Nutzungsbedingungen für Ihr eigenes Konto akzeptieren

Wenn Sie Ihr eigenes Merchant Center-Konto verwalten, gehen Sie so vor:

Rufen Sie termsOfServiceAgreementStates.retrieveForApplication auf, um festzustellen, ob die Nutzungsbedingungen required sind.
Wenn Nutzungsbedingungen erforderlich sind, notieren Sie sich den Namen termsOfService aus dem Feld required (z. B. termsOfService/132).
Rufen Sie termsOfService.accept auf, um die Nutzungsbedingungen zu akzeptieren. Sie benötigen den Namen der Nutzungsbedingungen, Ihr ACCOUNT_ID und das von „retrieveForApplication“ zurückgegebene regionCode.

Hier ein Beispiel für eine Anfrage:
```
POST https://merchantapi.googleapis.com/accounts/v1/{name={termsOfService/VERSION}}:accept
{
  "account": "accounts/{ACCOUNT_ID}",
  "regionCode": "{REGION_CODE}"
}
```
Ein erfolgreicher Aufruf gibt einen leeren Antworttext zurück und aktualisiert den Status der Nutzungsbedingungen des Kontos.

Händlern helfen, die Nutzungsbedingungen zu akzeptieren (für Drittanbieter)

Wenn Sie als Drittanbieter eigenständige Merchant Center-Konten für andere Unternehmen verwalten, dürfen Sie die Nutzungsbedingungen nicht in deren Namen akzeptieren. Stattdessen sollten Sie Folgendes tun:

Neueste Nutzungsbedingungen abrufen: Rufen Sie termsOfService.retrieveLatest für die regionCode- und MERCHANT_CENTER-Art des Händlers auf, um die Details der neuesten Version der Nutzungsbedingungen zu erhalten, die er möglicherweise akzeptieren muss.

Beispielanfrage:

GET https://merchantapi.googleapis.com/accounts/v1/termsOfService:retrieveLatest?regionCode={REGION_CODE}&kind=MERCHANT_CENTER

Beispielantwort:

{
    "name": "{termsOfService/VERSION}",
    "regionCode": "{REGION_CODE}",
    "kind": "MERCHANT_CENTER",
    "fileUri": "https://www.google.com/intl/{REGION_CODE}/policies/merchants/terms/"
}

Nutzungsbedingungen anzeigen: Verwenden Sie die fileUri aus der Antwort, um den vollständigen Text der Nutzungsbedingungen in der Benutzeroberfläche Ihrer Anwendung für den Händler anzuzeigen.
Zustimmung des Händlers einholen: Der Händler muss den Bedingungen in Ihrer Benutzeroberfläche ausdrücklich zustimmen.
Annahme mit der API aufzeichnen: Rufen Sie nach der Annahme durch den Händler termsOfService.accept mit dem name der in Schritt 1 abgerufenen Nutzungsbedingungen, der ACCOUNT_ID des Händlers und seiner regionCode auf.

Beispielanfrage:
```
POST https://merchantapi.googleapis.com/accounts/v1/{name={termsOfService/VERSION}}:accept
{
  "account": "accounts/{MERCHANT_ACCOUNT_ID}",
  "regionCode": "{REGION_CODE}"
}
```

Hier ist ein Beispiel, mit dem Sie die Nutzungsbedingungen für ein bestimmtes Konto akzeptieren können (nachdem der Händler zugestimmt hat):

Java

import com.google.api.gax.core.FixedCredentialsProvider;
import com.google.auth.oauth2.GoogleCredentials;
import com.google.shopping.merchant.accounts.v1.AcceptTermsOfServiceRequest;
import com.google.shopping.merchant.accounts.v1.TermsOfServiceServiceClient;
import com.google.shopping.merchant.accounts.v1.TermsOfServiceServiceSettings;
import shopping.merchant.samples.utils.Authenticator;
import shopping.merchant.samples.utils.Config;

/** This class demonstrates how to accept the TermsOfService agreement in a given account. */
public class AcceptTermsOfServiceSample {

  public static void acceptTermsOfService(String accountId, String tosVersion, String regionCode)
      throws Exception {

    // Obtains OAuth token based on the user's configuration.
    GoogleCredentials credential = new Authenticator().authenticate();

    // Creates service settings using the credentials retrieved above.
    TermsOfServiceServiceSettings tosServiceSettings =
        TermsOfServiceServiceSettings.newBuilder()
            .setCredentialsProvider(FixedCredentialsProvider.create(credential))
            .build();

    // Calls the API and catches and prints any network failures/errors.
    try (TermsOfServiceServiceClient tosServiceClient =
        TermsOfServiceServiceClient.create(tosServiceSettings)) {

      // The parent has the format: accounts/{account}
      AcceptTermsOfServiceRequest request =
          AcceptTermsOfServiceRequest.newBuilder()
              .setName(String.format("termsOfService/%s", tosVersion))
              .setAccount(String.format("accounts/%s", accountId))
              .setRegionCode(regionCode)
              .build();

      System.out.println("Sending request to accept terms of service...");
      tosServiceClient.acceptTermsOfService(request);

      System.out.println("Successfully accepted terms of service.");
    } catch (Exception e) {
      System.out.println(e);
    }
  }

  public static void main(String[] args) throws Exception {
    Config config = Config.load();

    // See GetTermsOfServiceAgreementStateSample to understand how to check which version of the
    // terms of service needs to be accepted, if any.
    // Likewise, if you know that the terms of service needs to be accepted, you can also simply
    // call RetrieveLatestTermsOfService to get the latest version of the terms of service.
    // Region code is either a country when the ToS applies specifically to that country or 001 when
    // it applies globally.
    acceptTermsOfService(config.getAccountId().toString(), "VERSION_HERE", "REGION_CODE_HERE");
  }
}AcceptTermsOfServiceSample.java

PHP

use Google\ApiCore\ApiException;
use Google\Shopping\Merchant\Accounts\V1\AcceptTermsOfServiceRequest;
use Google\Shopping\Merchant\Accounts\V1\Client\TermsOfServiceServiceClient;

/**
 * Demonstrates how to accept the TermsOfService agreement in a given account.
 */
class AcceptTermsOfService
{

    /**
     * Accepts the Terms of Service agreement.
     *
     * @param string $accountId The account ID.
     * @param string $tosVersion The Terms of Service version.
     * @param string $regionCode The region code.
     * @return void
     */
    public static function acceptTermsOfService($accountId, $tosVersion, $regionCode): void
    {
        // Get OAuth credentials.
        $credentials = Authentication::useServiceAccountOrTokenFile();

        // Create client options.
        $options = ['credentials' => $credentials];

        // Create a TermsOfServiceServiceClient.
        $tosServiceClient = new TermsOfServiceServiceClient($options);

        try {
            // Prepare the request.
            $request = new AcceptTermsOfServiceRequest([
                'name' => sprintf("termsOfService/%s", $tosVersion),
                'account' => sprintf("accounts/%s", $accountId),
                'region_code' => $regionCode,
            ]);

            print "Sending request to accept terms of service...\n";
            $tosServiceClient->acceptTermsOfService($request);

            print "Successfully accepted terms of service.\n";
        } catch (ApiException $e) {
            print $e->getMessage();
        }
    }

    /**
     * Helper to execute the sample.
     *
     * @return void
     */
    public function callSample(): void
    {
        $config = Config::generateConfig();

        // Replace with actual values.
        $tosVersion = "132";
        $regionCode = "US";

        self::acceptTermsOfService($config['accountId'], $tosVersion, $regionCode);
    }
}

// Run the script
$sample = new AcceptTermsOfService();
$sample->callSample();AcceptTermsOfServiceSample.php

Python

from examples.authentication import configuration
from examples.authentication import generate_user_credentials
from google.shopping.merchant_accounts_v1 import AcceptTermsOfServiceRequest
from google.shopping.merchant_accounts_v1 import TermsOfServiceServiceClient

# Replace with your actual values.
_ACCOUNT_ID = configuration.Configuration().read_merchant_info()
_TOS_VERSION = (  # Replace with the Terms of Service version to accept
    "VERSION_HERE"
)
_REGION_CODE = "US"  # Replace with the region code


def accept_terms_of_service():
  """Accepts the Terms of Service agreement for a given account."""

  credentials = generate_user_credentials.main()
  client = TermsOfServiceServiceClient(credentials=credentials)

  # Construct the request
  request = AcceptTermsOfServiceRequest(
      name=f"termsOfService/{_TOS_VERSION}",
      account=f"accounts/{_ACCOUNT_ID}",
      region_code=_REGION_CODE,
  )

  try:
    print("Sending request to accept terms of service...")
    client.accept_terms_of_service(request=request)
    print("Successfully accepted terms of service.")
  except RuntimeError as e:
    print(e)


if __name__ == "__main__":
  accept_terms_of_service()
accept_terms_of_service_sample.py

Besondere Überlegungen für Drittanbieter

Als Drittanbieter können Sie die Nutzungsbedingungen für Kundenkonten oder eigenständige Konten verwalten.

Nutzungsbedingungen für Kundenkonten verwalten

Wenn Sie ein erweitertes Konto haben und Kundenkonten für verschiedene Unternehmen erstellen:

Erweiterte Kontoakzeptanz: Wenn ein erweitertes Konto den Kontoaggregationsdienst für Kundenkonten bereitstellt, gelten die Nutzungsbedingungen, die vom erweiterten Konto akzeptiert wurden, auch für alle zugehörigen Kundenkonten mit diesem Dienst.
Anzeige und Einwilligung: Auch wenn die Annahme des erweiterten Kontos Kundenkonten abdeckt, ist es eine Best Practice (und möglicherweise eine rechtliche Anforderung), dem tatsächlichen Inhaber jedes Kundenkontos die relevanten Google Merchant Center-Nutzungsbedingungen zu präsentieren. Sie müssen die ausdrückliche Einwilligung der Nutzer einholen, dass sie diese Bedingungen verstanden haben und ihnen zustimmen, auch wenn der API-Aufruf zur Akzeptanz auf der Ebene des erweiterten Kontos erfolgt.
Status des Kundenkontos prüfen: Verwenden Sie termsOfServiceAgreementStates.retrieveForApplication für ein bestimmtes Kundenkonto, um den Status der Nutzungsbedingungen zu prüfen und festzustellen, ob es durch die Vereinbarung des erweiterten Kontos abgedeckt ist oder ob direkte Maßnahmen erforderlich sind.

Nutzungsbedingungen für Standalone-Konten verwalten

Wie im Leitfaden für Händler zum Akzeptieren der Nutzungsbedingungen beschrieben, muss das Unternehmen (der Kontoinhaber) die Nutzungsbedingungen persönlich akzeptieren, wenn Sie es beim Erstellen oder Verwalten eines eigenständigen Merchant Center-Kontos unterstützen. Sie erleichtern dies, indem Sie die Nutzungsbedingungen abrufen und anzeigen und dann in ihrem Namen die Methode termsOfService.accept aufrufen, nachdem sie über Ihre Benutzeroberfläche ihre ausdrückliche Einwilligung gegeben haben.

Zurück

Overview

Weiter

Create and manage sub-accounts