Mengelola perjanjian Persyaratan Layanan Merchant Center

Untuk menggunakan Merchant Center dan fiturnya, Anda harus menyetujui Persyaratan Layanan (ToS) Merchant Center untuk lokasi bisnis Anda. Perjanjian ini menguraikan persyaratan hukum untuk menggunakan layanan Merchant Center.

Panduan ini menjelaskan cara menggunakan Merchant API untuk mengelola perjanjian ini, baik untuk akun Anda sendiri maupun untuk akun yang Anda kelola sebagai penyedia pihak ketiga (3P).

Anda dapat mencapai hal berikut:

  • Periksa status perjanjian Persyaratan Penggunaan saat ini untuk akun.
  • Mengarahkan penjual untuk menyetujui Persyaratan Layanan yang diperlukan.
  • Mengelola Persyaratan Layanan sebagai penyedia pihak ketiga untuk akun klien atau akun mandiri.

Prasyarat

Untuk menggunakan Merchant API, Anda memerlukan akun Merchant Center. Setelah membuatnya menggunakan antarmuka pengguna (UI) Merchant Center, Anda dapat membuat perubahan pada akun (seperti memperbarui info bisnis, mengelola pengguna, dll.) menggunakan UI atau API.

Jika perlu mengelola beberapa akun, Anda dapat membuat akun klien menggunakan Merchant API. Lihat Membuat dan mengelola sub-akun.

Memeriksa status persetujuan Persyaratan Layanan akun

Sebelum penjual dapat memanfaatkan Merchant Center sepenuhnya, atau jika Anda perlu memverifikasi status perjanjian mereka saat ini, Anda dapat mengambil status perjanjian Persyaratan Layanan mereka.

Gunakan metode termsOfServiceAgreementStates.retrieveForApplication untuk mendapatkan status perjanjian Persyaratan Layanan untuk aplikasi Merchant Center inti. Metode ini menampilkan Persyaratan Layanan Anda saat ini, jika ada, dan jika Persyaratan Layanan telah diperbarui sejak terakhir kali Anda menyetujuinya, versi terbaru yang harus Anda setujui.

Berikut contoh permintaan:

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

Panggilan yang berhasil akan menampilkan resource TermsOfServiceAgreementState. Resource ini berisi:

  • name: ID untuk status perjanjian ini.
  • regionCode: Negara tempat status perjanjian ini berlaku, biasanya negara bisnis akun.
  • termsOfServiceKind: Ini akan menjadi MERCHANT_CENTER.
  • accepted: Detail tentang versi Persyaratan Penggunaan yang telah disetujui akun, termasuk nama resource termsOfService (seperti, termsOfService/132) dan siapa yang acceptedBy. Email ini juga dapat menyertakan tanggal validUntil jika versi ToS yang lebih baru required.
  • required: Detail tentang versi Persyaratan Penggunaan yang harus disetujui oleh akun. Hal ini mencakup nama resource termsOfService dan tosFileUri yang mengarah ke dokumen Persyaratan Layanan yang dapat dibaca manusia.

Contoh Respons:

{
  "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/"
  }
}

Jika ToS baru required, Anda harus memandu penjual untuk menyetujuinya.

Berikut adalah contoh yang dapat Anda gunakan untuk mengambil status perjanjian Persyaratan Layanan untuk akun dan negara tertentu:

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

Setujui Persyaratan Layanan

Penjual harus menyetujui Persyaratan Layanan terbaru untuk mempertahankan akses ke fitur Merchant Center.

Menyetujui ToS untuk akun Anda sendiri

Jika Anda mengelola akun Merchant Center Anda sendiri, lakukan hal berikut:

  1. Hubungi termsOfServiceAgreementStates.retrieveForApplication untuk mengidentifikasi apakah ada Persyaratan Penggunaan yang required.
  2. Jika Persyaratan Layanan diperlukan, perhatikan nama termsOfService dari kolom required (seperti, termsOfService/132).

  3. Panggil termsOfService.accept untuk menyetujui Persyaratan Layanan. Anda memerlukan nama ToS, ACCOUNT_ID, dan regionCode yang ditampilkan oleh retrieveForApplication.

    Berikut contoh permintaan:

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

    Panggilan yang berhasil akan menampilkan isi respons kosong, dan memperbarui status perjanjian Persyaratan Layanan akun.

Mengarahkan penjual untuk menyetujui Persyaratan Layanan (untuk penyedia pihak ketiga)

Jika Anda adalah penyedia pihak ketiga (3P) yang mengelola akun Merchant Center mandiri untuk bisnis lain, Anda tidak boleh menyetujui Persyaratan Layanan atas nama mereka. Sebagai gantinya, Anda harus:

  1. Mengambil ToS terbaru: Panggil termsOfService.retrieveLatest untuk jenis regionCode dan MERCHANT_CENTER penjual guna mendapatkan detail versi ToS terbaru yang mungkin perlu mereka setujui.

    Contoh Permintaan:

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

    Contoh Respons:

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

  2. Menampilkan ToS: Gunakan fileUri dari respons untuk menampilkan teks lengkap Persyaratan Layanan kepada penjual dalam UI aplikasi Anda.

  3. Mendapatkan persetujuan penjual: Penjual harus menyetujui persyaratan secara eksplisit dalam UI Anda.

  4. Mencatat penerimaan menggunakan API: Setelah penjual menyetujui, panggil termsOfService.accept menggunakan name ToS yang diperoleh pada langkah 1, ACCOUNT_ID penjual, dan regionCode mereka.

    Contoh Permintaan:

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

Berikut contoh yang dapat Anda gunakan untuk menyetujui perjanjian Persyaratan Layanan untuk akun tertentu (setelah penjual menyetujui):

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

Pertimbangan khusus untuk penyedia pihak ketiga

Sebagai penyedia pihak ketiga, Anda dapat mengelola Persyaratan Penggunaan untuk akun klien atau akun mandiri.

Mengelola Persyaratan Penggunaan untuk akun klien

Jika Anda mengoperasikan akun tingkat lanjut dan membuat akun klien untuk bisnis yang berbeda:

  • Persetujuan akun lanjutan: Jika akun lanjutan menyediakan layanan penggabungan akun untuk akun klien, maka Persyaratan Layanan yang disetujui oleh akun lanjutan juga akan berlaku untuk semua akun kliennya dengan layanan tersebut.
  • Tampilan dan izin: Meskipun persetujuan akun lanjutan mencakup akun klien, sebaiknya (dan mungkin merupakan ekspektasi hukum) menampilkan Persyaratan Layanan Google Merchant Center yang relevan kepada pemilik bisnis sebenarnya dari setiap akun klien. Anda harus mendapatkan izin eksplisit dari mereka bahwa mereka memahami dan menyetujui persyaratan ini, meskipun panggilan API untuk persetujuan dilakukan di tingkat akun lanjutan.
  • Memeriksa status akun klien: Gunakan termsOfServiceAgreementStates.retrieveForApplication di akun klien tertentu untuk memverifikasi status Persyaratannya dan melihat apakah akun tersebut tercakup dalam perjanjian akun lanjutan atau apakah ada tindakan langsung yang diperlukan.

Mengelola Persyaratan Penggunaan untuk akun mandiri

Seperti yang dijelaskan dalam Memandu penjual menyetujui Persyaratan Layanan, saat Anda membantu bisnis membuat atau mengelola akun Merchant Center mandiri, bisnis tersebut (pemilik akun) harus secara pribadi menyetujui Persyaratan Layanan. Anda memfasilitasi hal ini dengan mengambil dan menampilkan Persyaratan Layanan, lalu memanggil metode termsOfService.accept atas nama mereka setelah mereka memberikan izin eksplisit melalui antarmuka Anda.

Sebelumnya
Overview
Berikutnya
Create and manage sub-accounts