You need to have a Merchant Center Account to use the Merchant API. You can use the Merchant Center UI to create it.
If you need to manage multiple accounts, you can create sub-accounts using Merchant API.
You can configure your account in the Merchant Center UI or through the API as described later.
Accept the Merchant Center Terms of Service
All merchants must accept the Merchant Center Terms of Service. Here's how to accept the Terms of Service for your own merchant account:
Call
accounts.termsOfServiceAgreementStates.retrieveForApplication
to find out which Terms of Service are required for your account.Here's a sample request:
GET https://merchantapi.googleapis.com/accounts/v1beta/accounts/{ACCOUNT_ID}/termsOfServiceAgreementStates:retrieveForApplication
Here's a sample response from a successful call:
{ "name": "accounts/{ACCOUNT_ID}/termsOfServiceAgreementStates/MERCHANT_CENTER-{COUNTRY}", "regionCode": {COUNTRY}, "termsOfServiceKind": "MERCHANT_CENTER", "accepted": { "termsOfService": "termsOfService/{VERSION}", "acceptedBy": "accounts/{ACCOUNT_ID}" } }
Call
termsOfService.accept
to accept the Terms of Service.Here's a sample request:
GET https://merchantapi.googleapis.com/accounts/v1beta/{name=termsOfService/{VERSION}}:accept
If successful, the response body will be empty.
We recommend building a UI where you display the TOS to the merchant, and ask them to accept.
Find the TOS the merchant needs to accept using
termsOfService.retrieveLatest
with theregionCode
of the business.Here's a sample request:
GET https://merchantapi.googleapis.com/accounts/v1beta/termsOfService:retrieveLatest
Here's a sample response from a successful call:
{ "name": "termsOfService/{VERSION}", "regionCode": "{COUNTRY}", "kind": "MERCHANT_CENTER", "fileUri": "{URI}" }
Display the TOS from the
fileUri
to the merchant.When the merchant accepts the TOS in your UI, call
termsOfService.accept
with thename
of the TOS to accept.
Here's a sample you can use to accept the Terms of Service agreement for a given account:
Java
import com.google.api.gax.core.FixedCredentialsProvider;
import com.google.auth.oauth2.GoogleCredentials;
import com.google.shopping.merchant.accounts.v1beta.AcceptTermsOfServiceRequest;
import com.google.shopping.merchant.accounts.v1beta.TermsOfServiceServiceClient;
import com.google.shopping.merchant.accounts.v1beta.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\V1beta\AcceptTermsOfServiceRequest;
use Google\Shopping\Merchant\Accounts\V1beta\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_v1beta import AcceptTermsOfServiceRequest
from google.shopping.merchant_accounts_v1beta 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()
If you want to retrieve the Terms of Service agreement state for a specific country, use the following sample:
Java
import com.google.api.gax.core.FixedCredentialsProvider;
import com.google.auth.oauth2.GoogleCredentials;
import com.google.shopping.merchant.accounts.v1beta.GetTermsOfServiceAgreementStateRequest;
import com.google.shopping.merchant.accounts.v1beta.TermsOfServiceAgreementState;
import com.google.shopping.merchant.accounts.v1beta.TermsOfServiceAgreementStateName;
import com.google.shopping.merchant.accounts.v1beta.TermsOfServiceAgreementStateServiceClient;
import com.google.shopping.merchant.accounts.v1beta.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\V1beta\Client\TermsOfServiceAgreementStateServiceClient;
use Google\Shopping\Merchant\Accounts\V1beta\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_v1beta import GetTermsOfServiceAgreementStateRequest
from google.shopping.merchant_accounts_v1beta 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()
After the merchant accepts the TOS, you can use Merchant API to set up the
rest of their account information. For details about what account information
you can manage with the Merchant Accounts API, see the
Account
resource.
Claim your website
You can use the Merchant Accounts API to add and claim your business's
Homepage
.
- To add a homepage to your account, call
accounts.updateHomepage
with aHomepage
resource containing your homepage URL. - To claim ownership of the homepage, call
accounts.homepage.claim
with thename
from yourHompeage
resource.
You can't use Merchant API to verify your homepage. For more information, see Verify and claim your store's website.
Update your business details
You can use the Merchant Accounts API to edit your business
PostalAddress
,
CusomerService
,
and
BusinessIdentity
.
Business identity:
- To view your business identity, call
accounts.businessIdentity.getBusinessIdentity
. - To edit your business identity, call
accounts.businessIdentity.updateBusinessIdentity
.
What's next
- Learn how you can create and manage sub-accounts.
- To understand how relationships between merchant accounts work, see Relationships between accounts.