Client libraries

In this approach to interacting with Merchant API you use the prebuilt libraries that encapsulate the low-level details of making requests and handling responses, offering a more convenient and often language-idiomatic way to interact with the API. They handle authentication, request and response serialization/deserialization, and other boilerplate code.

Step 1. Set up authentication and configure code samples

For instructions, see Setting up Authentication and Sample Configuration Samples for Merchant API .

Step 2. Download and install the client library and code samples

For instructions on downloading and installing the client library and using the code samples from GitHub, see Google Merchant API Python Samples .

Step 3. Register as a developer

To use Merchant API, you must register your developer contact information.

Registration accomplishes the following:

Creates a technical contact for your Merchant Center account by assigning the API developer role to a user. This lets Google send important updates specifically about the API and the features the developer is using, such as service announcements and information about new features, that might be of less interest to non-developers.
Lets you work with multiple merchant accounts without having to register multiple times. When you register, the Google Cloud project ID used to authenticate to the Merchant API is associated with your Merchant Center account, which has the technical contacts (the API developer s). This way, you can get important updates for all the merchant accounts you manage as long as the authentication is done with the registered Google Cloud project.

When registering, observe the prerequisites and restrictions detailed at Registration .

For an example of how to register your project using client libraries, see the Register a Google Cloud project, supplying a developer email address using Python sample:

Python

  # -*- coding: utf-8 -*- 
 # Copyright 2025 Google LLC 
 # 
 # Licensed under the Apache License, Version 2.0 (the "License"); 
 # you may not use this file except in compliance with the License. 
 # You may obtain a copy of the License at 
 # 
 #     https://www.apache.org/licenses/LICENSE-2.0 
 # 
 # Unless required by applicable law or agreed to in writing, software 
 # distributed under the License is distributed on an "AS IS" BASIS, 
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
 # See the License for the specific language governing permissions and 
 # limitations under the License. 
 """This example registers a GCP project with a developer email.""" 
 from 
  
 examples.authentication 
  
 import 
 configuration 
 from 
  
 examples.authentication 
  
 import 
 generate_user_credentials 
 from 
  
 google.shopping.merchant_accounts_v1 
  
 import 
 DeveloperRegistrationServiceClient 
 from 
  
 google.shopping.merchant_accounts_v1 
  
 import 
 RegisterGcpRequest 
 def 
  
 register_gcp 
 ( 
 account_id 
 : 
 str 
 , 
 developer_email 
 : 
 str 
 ) 
 - 
> None 
 : 
  
 """Registers the GCP project used to call the Merchant API with a developer email. 
 Args: 
 account_id: The ID of your Merchant Center account. 
 developer_email: The email address of the developer to register. 
 """ 
 # Get OAuth credentials. 
 credentials 
 = 
 generate_user_credentials 
 . 
 main 
 () 
 # Create a client to the Developer Registration Service. 
 client 
 = 
 DeveloperRegistrationServiceClient 
 ( 
 credentials 
 = 
 credentials 
 ) 
 # The name has the format: accounts/{account}/developerRegistration 
 name 
 = 
 f 
 "accounts/ 
 { 
 account_id 
 } 
 /developerRegistration" 
 # Create the request to register the GCP project. 
 request 
 = 
 RegisterGcpRequest 
 ( 
 name 
 = 
 name 
 , 
 developer_email 
 = 
 developer_email 
 , 
 ) 
 # Make the API call and handle potential errors. 
 try 
 : 
 print 
 ( 
 "Sending RegisterGcp request:" 
 ) 
 response 
 = 
 client 
 . 
 register_gcp 
 ( 
 request 
 = 
 request 
 ) 
 print 
 ( 
 "Registered GCP project successfully:" 
 ) 
 print 
 ( 
 response 
 ) 
 except 
 RuntimeError 
 as 
 e 
 : 
 print 
 ( 
 f 
 "An error occurred: 
 { 
 e 
 } 
 " 
 ) 
 if 
 __name__ 
 == 
 "__main__" 
 : 
 # Your Merchant Center account ID. 
 # This can be found in the Merchant Center UI. 
 _account_id 
 = 
 configuration 
 . 
 Configuration 
 () 
 . 
 read_merchant_info 
 () 
 # The developer email to associate with the GCP project. 
 _developer_email 
 = 
 "YOUR_EMAIL_HERE" 
 register_gcp 
 ( 
 _account_id 
 , 
 _developer_email 
 ) 
   register_gcp_sample 
 . 
 py

Step 4. Manage developer contacts and permissions

When you register:

If the email address belongs to a user in the Merchant Center account, that user is granted the API_DEVELOPER role.
If the email address doesn't belong to an existing user, an invitation is sent to that address. The recipient must accept the invitation to be added as a new user with the API_DEVELOPER role.

After the initial registration, we recommend that you add multiple developers and grant them additional access rights.

Step 4a. Grant additional permissions

The API_DEVELOPER role is required to receive important notifications, but it has minimal permissions within Merchant Center. To allow this user to make other API calls or manage settings in the Merchant Center UI, you need to grant them additional roles, such as STANDARD or ADMIN . For more information, see Access types .

You can update a user's access rights with the accounts.users.patch method.

The sample code shows how to update a user to grant them both ADMIN and API_DEVELOPER roles. This lets them fully manage the account and it means they will also receive API-related communications.

Python

  # -*- coding: utf-8 -*- 
 # Copyright 2024 Google LLC 
 # 
 # Licensed under the Apache License, Version 2.0 (the "License"); 
 # you may not use this file except in compliance with the License. 
 # You may obtain a copy of the License at 
 # 
 #     http://www.apache.org/licenses/LICENSE-2.0 
 # 
 # Unless required by applicable law or agreed to in writing, software 
 # distributed under the License is distributed on an "AS IS" BASIS, 
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
 # See the License for the specific language governing permissions and 
 # limitations under the License. 
 """A module to update a user.""" 
 from 
  
 examples.authentication 
  
 import 
 configuration 
 from 
  
 examples.authentication 
  
 import 
 generate_user_credentials 
 from 
  
 google.protobuf 
  
 import 
 field_mask_pb2 
 from 
  
 google.shopping.merchant_accounts_v1 
  
 import 
 AccessRight 
 from 
  
 google.shopping.merchant_accounts_v1 
  
 import 
 UpdateUserRequest 
 from 
  
 google.shopping.merchant_accounts_v1 
  
 import 
 User 
 from 
  
 google.shopping.merchant_accounts_v1 
  
 import 
 UserServiceClient 
 FieldMask 
 = 
 field_mask_pb2 
 . 
 FieldMask 
 _ACCOUNT 
 = 
 configuration 
 . 
 Configuration 
 () 
 . 
 read_merchant_info 
 () 
 def 
  
 update_user 
 ( 
 user_email 
 , 
 user_access_right 
 ): 
  
 """Updates a user to make it an admin of the MC account.""" 
 credentials 
 = 
 generate_user_credentials 
 . 
 main 
 () 
 client 
 = 
 UserServiceClient 
 ( 
 credentials 
 = 
 credentials 
 ) 
 # Create user name string 
 name 
 = 
 "accounts/" 
 + 
 _ACCOUNT 
 + 
 "/users/" 
 + 
 user_email 
 user 
 = 
 User 
 ( 
 name 
 = 
 name 
 , 
 access_rights 
 = 
 [ 
 user_access_right 
 ]) 
 field_mask 
 = 
 FieldMask 
 ( 
 paths 
 = 
 [ 
 "access_rights" 
 ]) 
 try 
 : 
 request 
 = 
 UpdateUserRequest 
 ( 
 user 
 = 
 user 
 , 
 update_mask 
 = 
 field_mask 
 ) 
 print 
 ( 
 "Sending Update User request" 
 ) 
 response 
 = 
 client 
 . 
 update_user 
 ( 
 request 
 = 
 request 
 ) 
 print 
 ( 
 "Updated User Name below" 
 ) 
 print 
 ( 
 response 
 . 
 name 
 ) 
 except 
 RuntimeError 
 as 
 e 
 : 
 print 
 ( 
 e 
 ) 
 if 
 __name__ 
 == 
 "__main__" 
 : 
 # Modify this email to update the right user 
 email 
 = 
 "USER_MAIL_ACCOUNT" 
 access_right 
 = 
 AccessRight 
 . 
 ADMIN 
 update_user 
 ( 
 email 
 , 
 access_right 
 ) 
   update_user_sample 
 . 
 py

Step 4b. Add backup developers

To prevent your API access from being disrupted if your primary developer contact leaves your organization, you should add at least one backup developer.

You can add a user with the accounts.users.create method or update an existing one with the accounts.users.patch method. We recommend giving this user both the ADMIN and API_DEVELOPER roles.

Step 5. Create a primary products data source

Before you can insert a product, you need a primary products data source. For sample code that creates a data source, see Create a primary product data source that supports multiple languages sample with Python .

Python

  # -*- coding: utf-8 -*- 
 # Copyright 2024 Google LLC 
 # 
 # Licensed under the Apache License, Version 2.0 (the "License"); 
 # you may not use this file except in compliance with the License. 
 # You may obtain a copy of the License at 
 # 
 #     http://www.apache.org/licenses/LICENSE-2.0 
 # 
 # Unless required by applicable law or agreed to in writing, software 
 # distributed under the License is distributed on an "AS IS" BASIS, 
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
 # See the License for the specific language governing permissions and 
 # limitations under the License. 
 """This class demonstrates how to create a Primary product datasource all `feedLabel` and `contentLanguage` combinations. 
 This works only for API primary feeds. 
 """ 
 from 
  
 examples.authentication 
  
 import 
 configuration 
 from 
  
 examples.authentication 
  
 import 
 generate_user_credentials 
 from 
  
 google.shopping.merchant_datasources_v1 
  
 import 
 CreateDataSourceRequest 
 from 
  
 google.shopping.merchant_datasources_v1 
  
 import 
 DataSource 
 from 
  
 google.shopping.merchant_datasources_v1 
  
 import 
 DataSourcesServiceClient 
 from 
  
 google.shopping.merchant_datasources_v1 
  
 import 
 PrimaryProductDataSource 
 _ACCOUNT 
 = 
 configuration 
 . 
 Configuration 
 () 
 . 
 read_merchant_info 
 () 
 _PARENT 
 = 
 f 
 "accounts/ 
 { 
 _ACCOUNT 
 } 
 " 
 def 
  
 create_primary_product_data_source_multiple_languages 
 (): 
  
 """Creates a `DataSource` resource.""" 
 # Gets OAuth Credentials. 
 credentials 
 = 
 generate_user_credentials 
 . 
 main 
 () 
 # Creates a client. 
 client 
 = 
 DataSourcesServiceClient 
 ( 
 credentials 
 = 
 credentials 
 ) 
 # Creates a PrimaryProductDataSource. 
 primary_datasource 
 = 
 PrimaryProductDataSource 
 () 
 primary_datasource 
 . 
 countries 
 = 
 [ 
 "GB" 
 ] 
 # Creates a DataSource and populates its attributes. 
 data_source 
 = 
 DataSource 
 () 
 data_source 
 . 
 display_name 
 = 
 "Example Multiple Languages Primary DataSource" 
 data_source 
 . 
 primary_product_data_source 
 = 
 primary_datasource 
 # Creates the request. 
 request 
 = 
 CreateDataSourceRequest 
 ( 
 parent 
 = 
 _PARENT 
 , 
 data_source 
 = 
 data_source 
 ) 
 # Makes the request and catches and prints any error messages. 
 try 
 : 
 response 
 = 
 client 
 . 
 create_data_source 
 ( 
 request 
 = 
 request 
 ) 
 print 
 ( 
 f 
 "DataSource successfully created: 
 { 
 response 
 } 
 " 
 ) 
 except 
 RuntimeError 
 as 
 e 
 : 
 print 
 ( 
 "DataSource creation failed" 
 ) 
 print 
 ( 
 e 
 ) 
 if 
 __name__ 
 == 
 "__main__" 
 : 
 create_primary_product_data_source_multiple_languages 
 () 
   create_primary_product_data_source_multiple_languages_sample 
 . 
 py

You can view this data source in the Merchant Center UI. For more information, see How to find the Data sources tab .

Step 6. Insert a product

Once you create the data source, try to insert a product into it. For sample code that shows how to do this with the client libraries, see Insert a product input sample with Python .

Python

  # -*- coding: utf-8 -*- 
 # Copyright 2024 Google LLC 
 # 
 # Licensed under the Apache License, Version 2.0 (the "License"); 
 # you may not use this file except in compliance with the License. 
 # You may obtain a copy of the License at 
 # 
 #     http://www.apache.org/licenses/LICENSE-2.0 
 # 
 # Unless required by applicable law or agreed to in writing, software 
 # distributed under the License is distributed on an "AS IS" BASIS, 
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
 # See the License for the specific language governing permissions and 
 # limitations under the License. 
 """A module to insert a Product Input.""" 
 from 
  
 examples.authentication 
  
 import 
 configuration 
 from 
  
 examples.authentication 
  
 import 
 generate_user_credentials 
 from 
  
 google.shopping 
  
 import 
 merchant_products_v1 
 from 
  
 google.shopping.merchant_products_v1 
  
 import 
 Availability 
 from 
  
 google.shopping.merchant_products_v1 
  
 import 
 Condition 
 from 
  
 google.shopping.type 
  
 import 
 Price 
 _ACCOUNT 
 = 
 configuration 
 . 
 Configuration 
 () 
 . 
 read_merchant_info 
 () 
 _PARENT 
 = 
 f 
 "accounts/ 
 { 
 _ACCOUNT 
 } 
 " 
 # You can only insert products into datasource types of Input "API" and 
 # "FILE", and of Type "Primary" or "Supplemental." 
 _DATA_SOURCE 
 = 
 "[INSERT_DATA_SOURCE_HERE]" 
 _DATA_SOURCE_NAME 
 = 
 f 
 "accounts/ 
 { 
 _ACCOUNT 
 } 
 /dataSources/ 
 { 
 _DATA_SOURCE 
 } 
 " 
 def 
  
 create_product_input 
 (): 
  
 """Creates a `ProductInput` resource.""" 
 # Creates a shipping setting 
 price 
 = 
 Price 
 () 
 price 
 . 
 amount_micros 
 = 
 33_450_000 
 price 
 . 
 currency_code 
 = 
 "GBP" 
 shipping_option_1 
 = 
 merchant_products_v1 
 . 
 Shipping 
 () 
 shipping_option_1 
 . 
 price 
 = 
 price 
 shipping_option_1 
 . 
 country 
 = 
 "GB" 
 shipping_option_1 
 . 
 service 
 = 
 "1st class post" 
 price2 
 = 
 Price 
 () 
 price2 
 . 
 amount_micros 
 = 
 33_450_000 
 price2 
 . 
 currency_code 
 = 
 "EUR" 
 shipping_option_2 
 = 
 merchant_products_v1 
 . 
 Shipping 
 () 
 shipping_option_2 
 . 
 price 
 = 
 price2 
 shipping_option_2 
 . 
 country 
 = 
 "FR" 
 shipping_option_2 
 . 
 service 
 = 
 "2nd class post" 
 # Sets product attributes. Make sure to replace these values with your own. 
 attributes 
 = 
 merchant_products_v1 
 . 
 ProductAttributes 
 () 
 attributes 
 . 
 title 
 = 
 "A Tale of Two Cities" 
 attributes 
 . 
 description 
 = 
 "A classic novel about the French Revolution" 
 attributes 
 . 
 link 
 = 
 "https://exampleWebsite.com/tale-of-two-cities.html" 
 attributes 
 . 
 image_link 
 = 
 "https://exampleWebsite.com/tale-of-two-cities.jpg" 
 attributes 
 . 
 price 
 = 
 price 
 attributes 
 . 
 availability 
 = 
 Availability 
 . 
 IN_STOCK 
 attributes 
 . 
 condition 
 = 
 Condition 
 . 
 NEW 
 attributes 
 . 
 google_product_category 
 = 
 "Media > Books" 
 attributes 
 . 
 gtins 
 = 
 [ 
 "9780007350896" 
 ] 
 attributes 
 . 
 shipping 
 = 
 [ 
 shipping_option_1 
 , 
 shipping_option_2 
 ] 
 return 
 merchant_products_v1 
 . 
 ProductInput 
 ( 
 content_language 
 = 
 "en" 
 , 
 feed_label 
 = 
 "GB" 
 , 
 offer_id 
 = 
 "sku123" 
 , 
 product_attributes 
 = 
 attributes 
 , 
 ) 
 def 
  
 insert_product_input 
 (): 
  
 """Inserts the specified `ProductInput` resource.""" 
 # Gets OAuth Credentials. 
 credentials 
 = 
 generate_user_credentials 
 . 
 main 
 () 
 # Creates a client. 
 client 
 = 
 merchant_products_v1 
 . 
 ProductInputsServiceClient 
 ( 
 credentials 
 = 
 credentials 
 ) 
 # Creates the request. 
 request 
 = 
 merchant_products_v1 
 . 
 InsertProductInputRequest 
 ( 
 parent 
 = 
 _PARENT 
 , 
 # If this product is already owned by another datasource, when 
 # re-inserting, the new datasource will take ownership of the product. 
 product_input 
 = 
 create_product_input 
 (), 
 data_source 
 = 
 _DATA_SOURCE_NAME 
 , 
 ) 
 # Makes the request and catches and prints any error messages. 
 try 
 : 
 response 
 = 
 client 
 . 
 insert_product_input 
 ( 
 request 
 = 
 request 
 ) 
 # The last part of the product name will be the product ID assigned to a 
 # product by Google. Product ID has the format 
 # `contentLanguage~feedLabel~offerId` 
 print 
 ( 
 f 
 "Input successful: 
 { 
 response 
 } 
 " 
 ) 
 except 
 RuntimeError 
 as 
 e 
 : 
 print 
 ( 
 "Input failed" 
 ) 
 print 
 ( 
 e 
 ) 
 # After the product is inserted, the product ID will be returned in the 
 # response. We recommend that you check the Merchant Center to ensure that 
 # the product is approved and visible to users before using the product ID 
 # in any downstream processes. 
 if 
 __name__ 
 == 
 "__main__" 
 : 
 insert_product_input 
 () 
   insert_product_input_sample 
 . 
 py

Step 7. List your products

For sample code that lists the products in your data source, see List products sample with Python .

Python

  # -*- coding: utf-8 -*- 
 # Copyright 2024 Google LLC 
 # 
 # Licensed under the Apache License, Version 2.0 (the "License"); 
 # you may not use this file except in compliance with the License. 
 # You may obtain a copy of the License at 
 # 
 #     http://www.apache.org/licenses/LICENSE-2.0 
 # 
 # Unless required by applicable law or agreed to in writing, software 
 # distributed under the License is distributed on an "AS IS" BASIS, 
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
 # See the License for the specific language governing permissions and 
 # limitations under the License. 
 """A module to list Products.""" 
 from 
  
 examples.authentication 
  
 import 
 configuration 
 from 
  
 examples.authentication 
  
 import 
 generate_user_credentials 
 from 
  
 google.shopping 
  
 import 
 merchant_products_v1 
 _ACCOUNT 
 = 
 configuration 
 . 
 Configuration 
 () 
 . 
 read_merchant_info 
 () 
 _PARENT 
 = 
 f 
 "accounts/ 
 { 
 _ACCOUNT 
 } 
 " 
 def 
  
 list_products 
 (): 
  
 """Lists the `Product` resources for a given account.""" 
 # Gets OAuth Credentials. 
 credentials 
 = 
 generate_user_credentials 
 . 
 main 
 () 
 # Creates a client. 
 client 
 = 
 merchant_products_v1 
 . 
 ProductsServiceClient 
 ( 
 credentials 
 = 
 credentials 
 ) 
 # Creates the request. Set the page size to the maximum value. 
 request 
 = 
 merchant_products_v1 
 . 
 ListProductsRequest 
 ( 
 parent 
 = 
 _PARENT 
 , 
 page_size 
 = 
 1000 
 ) 
 # Makes the request and catches and prints any error messages. 
 try 
 : 
 response 
 = 
 client 
 . 
 list_products 
 ( 
 request 
 = 
 request 
 ) 
 for 
 product 
 in 
 response 
 : 
 print 
 ( 
 product 
 ) 
 print 
 ( 
 "List request successful!" 
 ) 
 except 
 RuntimeError 
 as 
 e 
 : 
 print 
 ( 
 "List request failed" 
 ) 
 print 
 ( 
 e 
 ) 
 if 
 __name__ 
 == 
 "__main__" 
 : 
 list_products 
 () 
   list_products_sample 
 . 
 py

Direct API calls

MCP Server

Client libraries Stay organized with collections Save and categorize content based on your preferences.

Step 1. Set up authentication and configure code samples

Step 2. Download and install the client library and code samples

Step 3. Register as a developer

Python

Step 4. Manage developer contacts and permissions

Step 4a. Grant additional permissions

Python

Step 4b. Add backup developers

Step 5. Create a primary products data source

Python

Step 6. Insert a product

Python

Step 7. List your products

Python

Client libraries