Merchant Center-Nutzungsbedingungen verwalten

Wenn Sie das Merchant Center und die zugehörigen Funktionen nutzen möchten, müssen Sie die Merchant Center-Nutzungsbedingungen für Ihren Unternehmensstandort akzeptieren. In diesen Vereinbarungen sind die rechtlichen Bedingungen für die Nutzung der Merchant Center-Dienste dargelegt.

In diesem Leitfaden wird erläutert, 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ändler anleiten, die erforderlichen Nutzungsbedingungen zu akzeptieren.
  • Nutzungsbedingungen als Dienstleister für Kundenkonten verwalten.

Vorbereitung

Wenn Sie die Merchant API verwenden möchten, benötigen Sie ein Merchant Center-Konto. Nachdem Sie es über die Benutzeroberfläche des Merchant Center erstellt haben, können Sie Änderungen am Konto vornehmen (z. B. Informationen zum Unternehmen aktualisieren, Nutzer verwalten usw.), entweder über die Benutzeroberfläche oder die API.

Wenn Sie mehrere Konten verwalten müssen, können Sie Kundenkonten mit der Merchant API erstellen. Weitere Informationen finden Sie unter Konten erstellen.

Zustimmungsstatus 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 prü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 Merchant Center-Kernanwendung abrufen. Diese Methode gibt Ihre aktuellen Nutzungsbedingungen zurück, falls vorhanden. Wenn die Nutzungsbedingungen seit Ihrer letzten Zustimmung aktualisiert wurden, wird die aktuelle Version zurückgegeben, 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 Kennung für diesen Vereinbarungsstatus.
  • regionCode: Das Land, für das dieser Vereinbarungsstatus gilt, in der Regel das Land, in dem das Unternehmen des Kontos ansässig ist.
  • termsOfServiceKind: Dies ist MERCHANT_CENTER.
  • accepted: Details zur Version der Nutzungsbedingungen, die das Konto bereits akzeptiert hat, einschließlich des Ressourcennamens termsOfService (z. B. termsOfService/132) und der Person, die sie acceptedBy hat. Sie kann auch ein validUntil-Datum enthalten, 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 menschenlesbare Nutzungsbedingungen-Dokument 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, 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);
  }
}

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();

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()

Nutzungsbedingungen akzeptieren

Händler müssen die aktuellen Nutzungsbedingungen akzeptieren, um weiterhin Zugriff auf die Merchant Center-Funktionen zu haben.

Nutzungsbedingungen für Ihr eigenes Konto akzeptieren

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

  1. Rufen Sie termsOfServiceAgreementStates.retrieveForApplication auf, um zu ermitteln, ob Nutzungsbedingungen required sind.
  2. Wenn Nutzungsbedingungen erforderlich sind, notieren Sie sich den Namen des termsOfService aus dem Feld required (z. B. termsOfService/132).

  3. Rufen Sie termsOfService.accept auf, um die Nutzungsbedingungen zu akzeptieren. Sie benötigen den Namen der Nutzungsbedingungen, Ihre ACCOUNT_ID und die 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}"
}

    Bei einem erfolgreichen Aufruf wird ein leerer Antworttext zurückgegeben und der Status der Nutzungsbedingungen des Kontos wird aktualisiert.

Händler anleiten, die Nutzungsbedingungen zu akzeptieren (für Drittanbieter)

Wenn Sie ein Drittanbieter sind, der Merchant Center-Konten für andere Unternehmen verwaltet, dürfen Sie die Nutzungsbedingungen nicht in deren Namen akzeptieren. Stattdessen sollten Sie Folgendes tun:

  1. Aktuelle Nutzungsbedingungen abrufen: Rufen Sie termsOfService.retrieveLatest für die regionCode und die MERCHANT_CENTER-Art des Händlers auf, um die Details der neuesten Version der Nutzungsbedingungen abzurufen, 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/"
}

  2. Nutzungsbedingungen anzeigen: Verwenden Sie die fileUri aus der Antwort, um dem Händler den vollständigen Text der Nutzungsbedingungen in der Benutzeroberfläche Ihrer Anwendung anzuzeigen.

  3. Zustimmung des Händlers einholen: Der Händler muss den Nutzungsbedingungen in Ihrer Benutzeroberfläche ausdrücklich zustimmen.

  4. Zustimmung über die API aufzeichnen: Nachdem der Händler zugestimmt hat, rufen Sie termsOfService.accept mit der name der in Schritt 1 erhaltenen 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 Vereinbarung zu den 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");
  }
}

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();

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()

Besondere Überlegungen für Drittanbieter

Als Drittanbieter können Sie die Nutzungsbedingungen für Kundenkonten verwalten.

Nutzungsbedingungen für Kundenkonten verwalten

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

  • Akzeptanz durch erweitertes Konto: Wenn ein erweitertes Konto den Dienst zur Kontozusammenfassung für Kundenkonten bereitstellt, gelten die vom erweiterten Konto akzeptierten Nutzungsbedingungen auch für alle Kundenkonten mit diesem Dienst.
  • Anzeige und Einwilligung: Auch wenn die Annahme des erweiterten Kontos die Kundenkonten abdeckt, empfiehlt es sich (und ist möglicherweise gesetzlich vorgeschrieben), dem tatsächlichen Geschäftsinhaber jedes Kunden die relevanten Google Merchant Center-Nutzungsbedingungen anzuzeigen. Sie müssen die ausdrückliche Zustimmung der Unterkontoinhaber einholen, dass sie diese Bedingungen verstehen und ihnen zustimmen, auch wenn der API-Aufruf für die Zustimmung auf der Ebene des erweiterten Kontos erfolgt.
  • Kundenkontostatus 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 andere Konten verwalten

Wie im Abschnitt Händler beim Akzeptieren der Nutzungsbedingungen unterstützen beschrieben, muss das Unternehmen (der Kontoinhaber) die Nutzungsbedingungen persönlich akzeptieren, wenn Sie es beim Erstellen oder Verwalten seines Kontos unterstützen . Dazu rufen Sie die Nutzungsbedingungen ab und zeigen sie an. Anschließend rufen Sie die Methode termsOfService.accept in ihrem Namen auf, nachdem sie ihre ausdrückliche Zustimmung über Ihre Benutzeroberfläche gegeben haben.

Zurück
Manage homepage settings
Weiter
Manage Merchant Center email preferences