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 melakukan hal berikut:

  • Memeriksa status perjanjian ToS saat ini untuk akun.
  • Mengarahkan penjual untuk menyetujui ToS yang diperlukan.
  • Mengelola ToS sebagai penyedia layanan untuk akun klien.

Prasyarat

Untuk menggunakan Merchant API, Anda memerlukan akun Merchant Center. Setelah membuatnya menggunakan Merchant Center antarmuka pengguna (UI), Anda dapat melakukan 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 akun.

Memeriksa status perjanjian ToS akun

Sebelum penjual dapat menggunakan Merchant Center sepenuhnya, atau jika Anda perlu memverifikasi status perjanjiannya saat ini, Anda dapat mengambil status perjanjian Persyaratan Layanan-nya.

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

Berikut adalah 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: Nilai ini akan berupa MERCHANT_CENTER.
  • accepted: Detail tentang versi ToS yang telah disetujui akun, termasuk nama resource termsOfService (seperti, termsOfService/132) dan siapa yang acceptedBy. Kolom ini mungkin juga menyertakan tanggal validUntil jika versi ToS yang lebih baru required.
  • required: Detail tentang versi ToS yang harus disetujui akun. Hal ini mencakup nama resource termsOfService dan tosFileUri yang mengarah ke dokumen ToS yang mudah dibaca.

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 mengarahkan 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);
  }
}

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

Menyetujui 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. Panggil termsOfServiceAgreementStates.retrieveForApplication untuk mengidentifikasi apakah ada ToS yang required.
  2. Jika ToS diperlukan, catat nama termsOfService dari required kolom (seperti, termsOfService/132).

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

    Berikut adalah 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 ToS akun.

Mengarahkan penjual untuk menyetujui ToS (untuk penyedia pihak ketiga)

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

  1. Mengambil ToS terbaru: Panggil termsOfService.retrieveLatest untuk regionCode dan jenis 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 persetujuan 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 adalah 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");
  }
}

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

Pertimbangan khusus untuk penyedia pihak ketiga

Sebagai penyedia pihak ketiga, Anda dapat mengelola ToS untuk akun klien.

Mengelola ToS untuk akun klien

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

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

Mengelola ToS untuk akun lain

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

Sebelumnya
Manage business identity
Berikutnya
Create and update regions