Manage Merchant Center Terms of Service agreements

    To use Merchant Center and its features, you must accept the Merchant Center Terms of Service (ToS) for your business location. These agreements outline the legal terms for using Merchant Center services.

    This guide explains how you can use the Merchant API to manage these agreements, whether for your own account or for accounts you manage as a third-party provider (3P).

    You can achieve the following:

    • Check the current ToS agreement status for an account.
    • Guide merchants to accept necessary ToS.
    • Manage ToS as a third-party provider for client accounts or standalone accounts.

    Prerequisites

    To use the Merchant API you need a Merchant Center account. Once you have created it using the Merchant Center user interface (UI), you can make changes to the account (such as, update your business info, manage users, etc.) either using the UI or the API.

    If you need to manage multiple accounts, you can create client accounts using Merchant API. See Create and manage sub-accounts .

    Check an account's ToS agreement state

    Before a merchant can fully utilize Merchant Center, or if you need to verify their current agreement status, you can retrieve the state of their Terms of Service agreement.

    Use the termsOfServiceAgreementStates.retrieveForApplication method to get the ToS agreement state for the core Merchant Center application. This method returns your current ToS, if any, and, if the ToS has been updated since your last acceptance, the latest version that you need to accept.

    Here's a sample request:

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

    A successful call returns a TermsOfServiceAgreementState resource. This resource contains:

    • name : The identifier for this agreement state.
    • regionCode : The country to which this agreement state applies, usually the business country of the account.
    • termsOfServiceKind : This will be MERCHANT_CENTER .
    • accepted : Details about the ToS version the account has already accepted, including the termsOfService resource name (such as, termsOfService/132 ) and who it was acceptedBy . It might also include a validUntil date if a newer ToS version is required .
    • required : Details about a ToS version that the account must accept. This includes the termsOfService resource name and a tosFileUri pointing to the human-readable ToS document.

    Example Response:

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

    If a new ToS is required , you should guide the merchant to accept it.

    Here's a sample you can use to retrieve the Terms of Service agreement state for a specific account and country:

    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

    Accept Terms of Service

    Merchants must accept the latest Terms of Service to maintain access to Merchant Center features.

    If you are managing your own Merchant Center account, do the following:

    1. Call termsOfServiceAgreementStates.retrieveForApplication to identify if any ToS is required .
    2. If a ToS is required, note the termsOfService name from the required field (such as, termsOfService/132 ).

    3. Call termsOfService.accept to accept the ToS. You'll need the ToS name, your ACCOUNT_ID , and the regionCode returned by retrieveForApplication.

      Here's a sample request:

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

      A successful call returns an empty response body, and updates the account's ToS agreement state.

    Guide merchants to accept ToS (for third-party providers)

    If you are a third-party provider (3P) managing standalone Merchant Center accounts for other businesses, you must not accept ToS on their behalf. Instead, you should:

    1. Retrieve the latest ToS: Call termsOfService.retrieveLatest for the merchant's regionCode and MERCHANT_CENTER kind to get the details of the latest ToS version they might need to accept.

      Sample Request:

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

      Sample Response:

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

    2. Display the ToS: Use the fileUri from the response to display the full text of the Terms of Service to the merchant within your application's UI.

    3. Obtain merchant acceptance: The merchant must explicitly agree to the terms within your UI.

    4. Record acceptance using the API: After the merchant accepts, call termsOfService.accept using the name of the ToS obtained in step 1, the merchant's ACCOUNT_ID , and their regionCode .

      Sample Request:

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

    Here's a sample you can use to accept the Terms of Service agreement for a given account (after the merchant has agreed):

    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

    Special considerations for third-party providers

    As a third-party provider you may manage the ToS for client accounts or standalone accounts.

    Manage ToS for client accounts

    If you operate an advanced account and create client accounts for different businesses:

    • Advanced account acceptance: If an advanced account provides the account aggregation service to client accounts, then a ToS accepted by the advanced account will also apply to all its client accounts with that service.
    • Display and consent: Even if the advanced account's acceptance covers client accounts, it's a best practice (and might be a legal expectation) to display the relevant Google Merchant Center ToS to the actual business owner of each client account. You must obtain their explicit consent that they understand and agree to these terms, even if the API call for acceptance is made at the advanced account level.
    • Checking client account status: Use termsOfServiceAgreementStates.retrieveForApplication on a specific client account to verify its ToS status and see if it's covered by the advanced account's agreement or if any direct action is needed.

    Manage ToS for standalone accounts

    As detailed in Guide merchants to accept ToS , when you assist a business in creating or managing a standalone Merchant Center account, that business (the account owner) must personally accept the Terms of Service. You facilitate this by retrieving and displaying the ToS, and then calling the termsOfService.accept method on their behalf after they have given their explicit consent through your interface.

    Previous
    Overview
    Next
    Create and manage sub-accounts
    Create a Mobile Website
    View Site in Mobile | Classic
    Share by: