จัดการข้อตกลงเกี่ยวกับข้อกำหนดในการให้บริการของ Merchant Center

หากต้องการใช้ Merchant Center และฟีเจอร์ต่างๆ คุณต้องยอมรับ ข้อกำหนดในการให้บริการของ Merchant Center (ToS) สำหรับสถานที่ตั้งธุรกิจ ข้อตกลงเหล่านี้ระบุเงื่อนไขทางกฎหมายสำหรับการใช้บริการ Merchant Center

คำแนะนำนี้จะอธิบายวิธีใช้ Merchant API เพื่อจัดการข้อตกลงเหล่านี้ ไม่ว่าจะเป็นบัญชีของคุณเองหรือบัญชีที่คุณจัดการในฐานะผู้ให้บริการบุคคลที่สาม (3P)

คุณสามารถทำสิ่งต่อไปนี้ได้

  • ตรวจสอบสถานะข้อตกลง ToS ปัจจุบันของบัญชี
  • แนะนำผู้ขายให้ยอมรับ ToS ที่จำเป็น
  • จัดการ ToS ในฐานะผู้ให้บริการสำหรับบัญชีลูกค้า

ข้อกำหนดเบื้องต้น

หากต้องการใช้ Merchant API คุณต้องมีบัญชี Merchant Center เมื่อสร้างบัญชีโดยใช้ อินเทอร์เฟซผู้ใช้ (UI) ของ Merchant Center แล้ว คุณสามารถทำการเปลี่ยนแปลงบัญชี (เช่น อัปเดตข้อมูล ธุรกิจ จัดการผู้ใช้ ฯลฯ) โดยใช้ UI หรือ API ก็ได้

หากต้องการจัดการหลายบัญชี คุณสามารถสร้างบัญชีลูกค้าโดยใช้ Merchant API ดูหัวข้อสร้างบัญชี

ตรวจสอบสถานะข้อตกลง ToS ของบัญชี

ก่อนที่ผู้ขายจะใช้ Merchant Center ได้อย่างเต็มที่ หรือหากคุณต้องการ ยืนยันสถานะข้อตกลงปัจจุบันของผู้ขาย คุณสามารถดึงข้อมูลสถานะข้อตกลงเกี่ยวกับ ข้อกำหนดในการให้บริการของผู้ขายได้

ใช้เมธอด termsOfServiceAgreementStates.retrieveForApplication เพื่อรับสถานะข้อตกลง ToS สำหรับแอปพลิเคชัน Merchant Center หลัก เมธอดนี้จะแสดง ToS ปัจจุบัน (หากมี) และหาก ToS ได้รับการอัปเดตตั้งแต่ที่คุณยอมรับครั้งล่าสุด ก็จะแสดงเวอร์ชันล่าสุดที่คุณต้องยอมรับ

ตัวอย่างคำขอ

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

การเรียกที่สำเร็จจะแสดง TermsOfServiceAgreementState แหล่งข้อมูล แหล่งข้อมูลนี้ประกอบด้วยข้อมูลต่อไปนี้

  • name: ตัวระบุสำหรับสถานะข้อตกลงนี้
  • regionCode: ประเทศที่สถานะข้อตกลงนี้มีผลบังคับใช้ ซึ่งโดยปกติจะเป็นประเทศที่ธุรกิจตั้งอยู่ของบัญชี
  • termsOfServiceKind: ค่าจะเป็น MERCHANT_CENTER
  • accepted: รายละเอียดเกี่ยวกับเวอร์ชัน ToS ที่บัญชีได้ยอมรับแล้ว ซึ่งรวมถึงชื่อแหล่งข้อมูล termsOfService (เช่น termsOfService/132) และผู้ที่ acceptedBy นอกจากนี้ยังอาจมีวันที่ validUntil หาก required ต้องใช้ ToS เวอร์ชันใหม่กว่า
  • required: รายละเอียดเกี่ยวกับเวอร์ชัน ToS ที่บัญชีต้องยอมรับ ซึ่งรวมถึงชื่อแหล่งข้อมูล termsOfService และ tosFileUri ที่ชี้ไปยังเอกสาร ToS ที่มนุษย์อ่านได้

ตัวอย่างคำตอบ

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

หาก required ต้องใช้ ToS ใหม่ คุณควรแนะนำให้ผู้ขายยอมรับ ToS ดังกล่าว

ตัวอย่างที่คุณใช้เพื่อดึงข้อมูลสถานะข้อตกลงเกี่ยวกับข้อกำหนดในการให้บริการ สำหรับบัญชีและประเทศที่เฉพาะเจาะจง

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

ยอมรับข้อกำหนดในการให้บริการ

ผู้ขายต้องยอมรับข้อกำหนดในการให้บริการล่าสุดจึงจะมีสิทธิ์เข้าถึง ฟีเจอร์ของ Merchant Center ต่อไปได้

ยอมรับ ToS สำหรับบัญชีของคุณเอง

หากคุณจัดการบัญชี Merchant Center ของคุณเอง ให้ทำดังนี้

  1. เรียก termsOfServiceAgreementStates.retrieveForApplication เพื่อระบุว่า required ต้องใช้ ToS หรือไม่
  2. หากต้องใช้ข้อกำหนดในการให้บริการ ให้จดชื่อ termsOfService จากช่อง required (เช่น termsOfService/132)

  3. เรียก termsOfService.accept เพื่อยอมรับ ToS คุณจะต้องใช้ชื่อ ToS, ACCOUNT_ID และ regionCode ที่แสดงโดย retrieveForApplication

    ตัวอย่างคำขอ

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

    การเรียกที่สำเร็จจะแสดงเนื้อหาคำตอบว่างเปล่า และอัปเดตสถานะข้อตกลง ToS ของบัญชี

แนะนำผู้ขายให้ยอมรับ ToS (สำหรับผู้ให้บริการบุคคลที่สาม)

หากคุณเป็นผู้ให้บริการบุคคลที่สาม (3P) ที่จัดการบัญชี Merchant Center ให้ธุรกิจอื่นๆ คุณต้องไม่ยอมรับ ToS ในนามของธุรกิจเหล่านั้น แต่คุณควรทำดังนี้

  1. ดึงข้อมูล ToS ล่าสุด: เรียก termsOfService.retrieveLatest สำหรับ regionCode และประเภท MERCHANT_CENTER ของผู้ขายเพื่อดู รายละเอียดของ ToS เวอร์ชันล่าสุดที่ผู้ขายอาจต้องยอมรับ

    ตัวอย่างคำขอ

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

    ตัวอย่างคำตอบ

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

  2. แสดง ToS: ใช้ fileUri จากคำตอบเพื่อแสดงข้อความฉบับเต็มของข้อกำหนดในการให้บริการแก่ผู้ขายภายใน UI ของแอปพลิเคชัน

  3. ขอการยอมรับจากผู้ขาย: ผู้ขายต้องยอมรับ ข้อกำหนดอย่างชัดแจ้งภายใน UI ของคุณ

  4. บันทึกการยอมรับโดยใช้ API: หลังจากผู้ขายยอมรับแล้ว ให้เรียก termsOfService.accept โดยใช้ name ของ ToS ที่ได้รับในขั้นตอนที่ 1, ACCOUNT_ID ของผู้ขาย, และ regionCode ของผู้ขาย

    ตัวอย่างคำขอ

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

ตัวอย่างที่คุณใช้เพื่อยอมรับข้อตกลงเกี่ยวกับข้อกำหนดในการให้บริการสำหรับบัญชีที่กำหนด (หลังจากที่ผู้ขายตกลงแล้ว)

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

ข้อควรพิจารณาเป็นกรณีพิเศษสำหรับผู้ให้บริการบุคคลที่สาม

ในฐานะผู้ให้บริการบุคคลที่สาม คุณอาจจัดการ ToS สำหรับบัญชีลูกค้าได้

จัดการ ToS สำหรับบัญชีลูกค้า

หากคุณใช้บัญชีขั้นสูงและสร้างบัญชีลูกค้าสำหรับธุรกิจต่างๆ ให้ทำดังนี้

  • การยอมรับของบัญชีขั้นสูง: หากบัญชีขั้นสูงให้บริการการรวบรวมบัญชีแก่บัญชีลูกค้า ToS ที่บัญชีขั้นสูงยอมรับจะมีผลกับบัญชีลูกค้าทั้งหมดที่มีบริการดังกล่าวด้วย
  • การแสดงและการให้ความยินยอม: แม้ว่าการยอมรับของบัญชีขั้นสูงจะครอบคลุม บัญชีลูกค้า แต่แนวทางปฏิบัติแนะนำ (และอาจเป็นข้อกำหนดทางกฎหมาย) คือการ แสดง ToS ที่เกี่ยวข้องของ Google Merchant Center แก่เจ้าของธุรกิจ จริงของลูกค้าแต่ละราย คุณต้องขอความยินยอมอย่างชัดแจ้งจากเจ้าของธุรกิจว่าเข้าใจและยอมรับข้อกำหนดเหล่านี้ แม้ว่าการเรียก API เพื่อยอมรับจะดำเนินการในระดับบัญชีขั้นสูงก็ตาม
  • การตรวจสอบสถานะบัญชีลูกค้า: ใช้ termsOfServiceAgreementStates.retrieveForApplication ในบัญชีลูกค้าที่เฉพาะเจาะจงเพื่อยืนยันสถานะ ToS และดูว่าบัญชีลูกค้าดังกล่าวได้รับความคุ้มครองตามข้อตกลงของบัญชีขั้นสูงหรือไม่ หรือต้องดำเนินการโดยตรงหรือไม่

จัดการ ToS สำหรับบัญชีอื่นๆ

ตามที่ระบุไว้ในหัวข้อ แนะนำผู้ขายให้ยอมรับ ToS เมื่อคุณช่วยเหลือ ธุรกิจในการสร้างหรือจัดการบัญชีของตนเอง ธุรกิจดังกล่าว (เจ้าของบัญชี ) ต้องยอมรับข้อกำหนดในการให้บริการด้วยตนเอง คุณสามารถอำนวยความสะดวกในเรื่องนี้ได้โดยการดึงข้อมูลและแสดง ToS จากนั้นเรียกเมธอด termsOfService.accept ในนามของธุรกิจ หลังจาก ที่ธุรกิจให้ความยินยอมอย่างชัดแจ้งผ่านอินเทอร์เฟซของคุณแล้ว

ก่อนหน้า
Manage business identity
ถัดไป
Create and update regions