Diese Seite wurde von der Cloud Translation API übersetzt.

Clientbibliotheken

Bei dieser Methode zur Interaktion mit der Merchant API verwenden Sie die vorgefertigten Bibliotheken, die die Low-Level-Details zum Senden von Anfragen und Verarbeiten von Antworten enthalten. So können Sie auf bequemere und oft sprachspezifische Weise mit der API interagieren. Sie kümmern sich um die Authentifizierung, die Serialisierung/Deserialisierung von Anfragen und Antworten sowie um anderen Boilerplate-Code.

Schritt 1: Authentifizierung einrichten und Codebeispiele konfigurieren

Eine Anleitung finden Sie unter Authentifizierung einrichten und Beispielkonfigurationen für die Merchant API.

Schritt 2: Clientbibliothek und Codebeispiele herunterladen und installieren

Eine Anleitung zum Herunterladen und Installieren der Clientbibliothek sowie zur Verwendung der Codebeispiele von GitHub finden Sie unter Google Merchant API Python Samples.

Schritt 3: Als Entwickler registrieren

Wenn Sie die Merchant API verwenden möchten, müssen Sie Ihre Entwicklerkontaktdaten registrieren.

Die Registrierung hat folgende Auswirkungen:

Erstellt einen technischen Kontakt für Ihr Merchant Center-Konto, indem einem Nutzer die Rolle API developer zugewiesen wird. So kann Google wichtige Updates speziell zur API und zu den Funktionen senden, die der Entwickler verwendet, z. B. Servicemitteilungen und Informationen zu neuen Funktionen, die für Nicht-Entwickler möglicherweise weniger interessant sind.
Sie können mehrere Händlerkonten verwenden, ohne sich mehrmals registrieren zu müssen. Bei der Registrierung wird die Google Cloud-Projekt-ID, die für die Authentifizierung bei der Merchant API verwendet wird, Ihrem Merchant Center-Konto zugeordnet, das die technischen Kontakte (die API developer) enthält. So erhalten Sie wichtige Updates für alle Händlerkonten, die Sie verwalten, sofern die Authentifizierung mit dem registrierten Google Cloud-Projekt erfolgt.

Beachten Sie bei der Registrierung die unter Registrierung beschriebenen Voraussetzungen und Einschränkungen.

Ein Beispiel dafür, wie Sie Ihr Projekt mit Clientbibliotheken registrieren, finden Sie im Python-Beispiel zum Registrieren eines Google Cloud-Projekts mit Angabe einer Entwickler-E-Mail-Adresse:

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

Schritt 4: Entwicklerkontakte und ‑berechtigungen verwalten

Wenn Sie sich registrieren, gilt Folgendes:

Wenn die E-Mail-Adresse zu einem Nutzer im Merchant Center-Konto gehört, erhält dieser Nutzer die Rolle API_DEVELOPER.
Wenn die E-Mail-Adresse nicht zu einem vorhandenen Nutzer gehört, wird eine Einladung an diese Adresse gesendet. Der Empfänger muss die Einladung annehmen, um als neuer Nutzer mit der Rolle API_DEVELOPER hinzugefügt zu werden.

Nach der ersten Registrierung empfehlen wir Ihnen, mehrere Entwickler hinzuzufügen und ihnen zusätzliche Zugriffsrechte zu gewähren.

Schritt 4a: Zusätzliche Berechtigungen erteilen

Die Rolle API_DEVELOPER ist erforderlich, um wichtige Benachrichtigungen zu erhalten. Sie hat jedoch nur minimale Berechtigungen im Merchant Center. Wenn dieser Nutzer andere API-Aufrufe ausführen oder Einstellungen in der Merchant Center-Benutzeroberfläche verwalten soll, müssen Sie ihm zusätzliche Rollen wie STANDARD oder ADMIN zuweisen. Weitere Informationen finden Sie unter Zugriffstypen.

Sie können die Zugriffsrechte eines Nutzers mit der Methode accounts.users.patch aktualisieren.

Der Beispielcode zeigt, wie Sie einen Nutzer aktualisieren, um ihm die Rollen ADMIN und API_DEVELOPER zuzuweisen. So können sie das Konto vollständig verwalten und erhalten auch API-bezogene Mitteilungen.

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

Schritt 4b: Ersatzentwickler hinzufügen

Damit Ihr API-Zugriff nicht unterbrochen wird, wenn Ihr primärer Entwicklerkontakt Ihre Organisation verlässt, sollten Sie mindestens einen Backup-Entwickler hinzufügen.

Sie können einen Nutzer mit der Methode accounts.users.create hinzufügen oder einen vorhandenen Nutzer mit der Methode accounts.users.patch aktualisieren. Wir empfehlen, diesem Nutzer sowohl die Rolle ADMIN als auch die Rolle API_DEVELOPER zuzuweisen.

Schritt 5: Primäre Produktdatenquelle erstellen

Bevor Sie ein Produkt einfügen können, benötigen Sie eine primäre Produktdatenquelle. Beispielcode zum Erstellen einer Datenquelle finden Sie unter Beispiel für das Erstellen einer primären Produktdatenquelle, die mehrere Sprachen unterstützt, mit 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

Sie können diese Datenquelle auf der Merchant Center-Benutzeroberfläche aufrufen. Weitere Informationen

Schritt 6: Produkt einfügen

Nachdem Sie die Datenquelle erstellt haben, versuchen Sie, ein Produkt einzufügen. Beispielcode, der zeigt, wie Sie dies mit den Clientbibliotheken tun, finden Sie unter Produkt-Eingabebeispiel mit Python einfügen.

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

Schritt 7: Produkte auflisten

Beispielcode zum Auflisten der Produkte in Ihrer Datenquelle finden Sie unter Beispiel für das Auflisten von Produkten mit 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

Clientbibliotheken Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Schritt 1: Authentifizierung einrichten und Codebeispiele konfigurieren

Schritt 2: Clientbibliothek und Codebeispiele herunterladen und installieren

Schritt 3: Als Entwickler registrieren

Python

Schritt 4: Entwicklerkontakte und ‑berechtigungen verwalten

Schritt 4a: Zusätzliche Berechtigungen erteilen

Python

Schritt 4b: Ersatzentwickler hinzufügen

Schritt 5: Primäre Produktdatenquelle erstellen

Python

Schritt 6: Produkt einfügen

Python

Schritt 7: Produkte auflisten

Python

Clientbibliotheken