A API Merchant v1beta foi descontinuada e desativada em 28 de fevereiro de 2026. Para saber como fazer a transição para a versão estável mais recente, consulte Migrar da v1beta para a v1.

Bibliotecas de clientes

Nessa abordagem de interação com a API Merchant, você usa as bibliotecas pré-criadas que encapsulam os detalhes de baixo nível de como fazer solicitações e processar respostas, oferecendo uma maneira mais conveniente e, muitas vezes, idiomática de interagir com a API. Elas processam a autenticação, a serialização/desserialização de solicitações e respostas e outros códigos boilerplate.

Etapa 1. Configurar a autenticação e os exemplos de código

Para instruções, consulte Configurar a autenticação e os exemplos de configuração da API Merchant.

Etapa 2. Fazer o download e instalar a biblioteca de cliente e os exemplos de código

Para instruções sobre como fazer o download e instalar a biblioteca de cliente e usar os exemplos de código do GitHub, consulte Exemplos do Python da API Google Merchant Samples.

Etapa 3. Registrar-se como um desenvolvedor

Para usar a API Merchant, registre suas informações de contato de desenvolvedor.

O registro realiza o seguinte:

Cria um contato técnico para sua conta do Merchant Center atribuindo o papel API developer a um usuário. Isso permite que o Google envie atualizações importantes especificamente sobre a API e os recursos que o desenvolvedor está usando, como anúncios de serviço e informações sobre novos recursos, que podem ser de menor interesse para não desenvolvedores.
Permite que você trabalhe com várias contas de comerciante sem precisar se registrar várias vezes. Ao se registrar, o ID do projeto do Google Cloud usado para autenticar na API Merchant é associado à sua conta do Merchant Center, que tem os contatos técnicos (os API developers). Dessa forma, você pode receber atualizações importantes para todas as contas de comerciante que gerencia, desde que a autenticação seja feita com o projeto registrado do Google Cloud.

Ao se registrar, observe os pré-requisitos e restrições detalhados em Registro.

Para um exemplo de como registrar seu projeto usando bibliotecas de cliente, consulte o exemplo de registro de um projeto do Google Cloud, fornecendo um endereço de e-mail de desenvolvedor usando Python:

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

Etapa 4. Gerenciar contatos e permissões de desenvolvedor

Ao se registrar:

Se o endereço de e-mail pertencer a um usuário na conta do Merchant Center, esse usuário receberá o papel API_DEVELOPER.
Se o endereço de e-mail não pertencer a um usuário, um convite será enviado para esse endereço. O destinatário precisa aceitar o convite para ser adicionado como um novo usuário com o papel API_DEVELOPER.

Após o registro inicial, recomendamos que você adicione vários desenvolvedores e conceda a eles direitos de acesso adicionais.

Etapa 4a. Conceda outras permissões

O papel API_DEVELOPER é necessário para receber notificações importantes, mas tem permissões mínimas no Merchant Center. Para permitir que esse usuário faça outras chamadas de API ou gerencie configurações na interface do Merchant Center, conceda a ele outros papéis, como STANDARD ou ADMIN. Para mais informações, consulte Tipos de acesso.

É possível atualizar os direitos de acesso de um usuário com o accounts.users.patch método.

O exemplo de código mostra como atualizar um usuário para conceder a ele os papéis ADMIN e API_DEVELOPER. Isso permite que ele gerencie totalmente a conta e também receba comunicações relacionadas à API.

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

Etapa 4b. Adicionar desenvolvedores de backup

Para evitar que o acesso à API seja interrompido se o contato principal do desenvolvedor sair da sua organização, adicione pelo menos um desenvolvedor de backup.

É possível adicionar um usuário com o accounts.users.create método ou atualizar um usuário atual com o accounts.users.patch método. Recomendamos conceder a esse usuário os papéis ADMIN e API_DEVELOPER.

Etapa 5. Criar uma fonte de dados de produtos principal

Antes de inserir um produto, você precisa de uma fonte de dados de produtos principal. Para um exemplo de código que cria uma fonte de dados, consulte Criar um exemplo de fonte de dados de produtos principal que oferece suporte a vários idiomas com o 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

É possível conferir essa fonte de dados na interface do Merchant Center. Para mais informações, consulte Como encontrar a guia "Fontes de dados".

Etapa 6. Inserir um produto

Depois de criar a fonte de dados, tente inserir um produto nela. Para um exemplo de código que mostra como fazer isso com as bibliotecas de cliente, consulte Inserir um exemplo de entrada de produto com o 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

Etapa 7. Informe seus produtos

Para um exemplo de código que lista os produtos na sua fonte de dados, consulte o exemplo de lista de produtos com o 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

Bibliotecas de clientes Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Etapa 1. Configurar a autenticação e os exemplos de código

Etapa 2. Fazer o download e instalar a biblioteca de cliente e os exemplos de código

Etapa 3. Registrar-se como um desenvolvedor

Python

Etapa 4. Gerenciar contatos e permissões de desenvolvedor

Etapa 4a. Conceda outras permissões

Python

Etapa 4b. Adicionar desenvolvedores de backup

Etapa 5. Criar uma fonte de dados de produtos principal

Python

Etapa 6. Inserir um produto

Python

Etapa 7. Informe seus produtos

Python

Bibliotecas de clientes