สำคัญ: ระบบได้เลิกให้บริการ Content API for Shopping ไปแล้วเมื่อวันที่ 18 สิงหาคม 2026

ตั้งแต่วันที่ 1 กันยายน 2026 เป็นต้นไป คำขอ Content API for Shopping จะ พบข้อผิดพลาดเพิ่มขึ้นเรื่อยๆ โปรดอ่านคู่มือการเลิกให้บริการ Content API

หากต้องการเวลาเพิ่มเติมในการย้ายข้อมูลไปยัง Merchant API โปรดสมัครขอสิทธิ์เข้าถึง Content API for Shopping เพิ่มเติม

Google ใช้เทคโนโลยี AI เพื่อแปลเนื้อหาเป็นภาษาที่คุณต้องการ การแปลโดย AI อาจมีข้อผิดพลาด

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

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

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

คุณจะทำสิ่งต่อไปนี้ได้

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

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

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

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

ตรวจสอบสถานะการยอมรับข้อกำหนดในการให้บริการของบัญชี

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

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

ตัวอย่างคำขอมีดังนี้

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
required: รายละเอียดเกี่ยวกับเวอร์ชันของข้อกำหนดในการให้บริการที่บัญชีต้องยอมรับ ซึ่งรวมถึงชื่อทรัพยากร termsOfService และ tosFileUri ที่ชี้ไปยังเอกสารข้อกำหนดในการให้บริการที่มนุษย์อ่านได้

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

{
  "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 คุณควรแนะนำให้ผู้ขายยอมรับข้อกำหนดดังกล่าว

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

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

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

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

ยอมรับข้อกำหนดในการให้บริการสำหรับบัญชีของคุณเอง

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

โทรหา termsOfServiceAgreementStates.retrieveForApplication เพื่อระบุว่า ToS มีสถานะเป็นrequiredหรือไม่
หากต้องใช้ข้อกำหนดในการให้บริการ ให้จดชื่อ termsOfService จากช่อง required (เช่น termsOfService/132)
โทรหา termsOfService.accept เพื่อยอมรับข้อกำหนดในการให้บริการ คุณจะต้องมีชื่อ ToS, ACCOUNT_ID และ regionCode ที่แสดงผลโดย retrieveForApplication

ตัวอย่างคำขอมีดังนี้
```
POST https://merchantapi.googleapis.com/accounts/v1/{name={termsOfService/VERSION}}:accept
{
  "account": "accounts/{ACCOUNT_ID}",
  "regionCode": "{REGION_CODE}"
}
```
การเรียกที่สำเร็จจะแสดงเนื้อหาการตอบกลับที่ว่างเปล่า และอัปเดตสถานะข้อตกลง ToS ของบัญชี

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

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

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

คำขอตัวอย่าง:
```
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/"
}
```
แสดงข้อกำหนดในการให้บริการ: ใช้ fileUri จากการตอบกลับเพื่อแสดงข้อความทั้งหมดของข้อกำหนดในการให้บริการแก่ผู้ขายภายใน UI ของแอปพลิเคชัน
ได้รับการยอมรับจากผู้ขาย: ผู้ขายต้องยอมรับข้อกำหนดภายใน UI ของคุณอย่างชัดแจ้ง
บันทึกการยอมรับโดยใช้ 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");
  }
}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

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

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

จัดการข้อกำหนดในการให้บริการสำหรับบัญชีลูกค้า

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

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

จัดการข้อกำหนดในการให้บริการสำหรับบัญชีอื่นๆ

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

Manage homepage settings

Manage Merchant Center email preferences