Ta strona została przetłumaczona przez Cloud Translation API.

Biblioteki klienta

W tym podejściu do interakcji z interfejsem Merchant API używasz gotowych bibliotek, które zawierają szczegóły niskiego poziomu dotyczące wysyłania żądań i obsługi odpowiedzi, co zapewnia wygodniejszy i często bardziej idiomatyczny sposób interakcji z interfejsem API. Obsługują one uwierzytelnianie, serializację/deserializację żądań i odpowiedzi oraz inne powtarzalne fragmenty kodu.

Krok 1. Konfigurowanie uwierzytelniania i przykładowych kodów

Instrukcje znajdziesz w artykule Konfigurowanie uwierzytelniania i przykładowa konfiguracja Przykłady interfejsu Merchant API.

Krok 2. Pobieranie i instalowanie biblioteki klienta oraz przykładowych fragmentów kodu

Instrukcje pobierania i instalowania biblioteki klienta oraz korzystania z przykładowych kodów z GitHuba znajdziesz w artykule Przykłady w Pythonie dotyczące interfejsu Google Merchant API.

Krok 3. Zarejestruj się jako programista

Aby korzystać z interfejsu Merchant API, musisz zarejestrować dane kontaktowe dewelopera.

Rejestracja umożliwia:

Tworzy kontakt techniczny dla konta Merchant Center, przypisując użytkownikowi rolę API developer. Dzięki temu Google może wysyłać ważne aktualizacje dotyczące konkretnie interfejsu API i funkcji, z których korzysta deweloper, np. ogłoszenia o usługach i informacje o nowych funkcjach, które mogą być mniej interesujące dla osób niebędących deweloperami.
Umożliwia korzystanie z wielu kont sprzedawców bez konieczności wielokrotnej rejestracji. Podczas rejestracji identyfikator projektu Google Cloud używany do uwierzytelniania w interfejsie Merchant API jest powiązany z kontem Merchant Center, które ma kontakty techniczne (API developer). Dzięki temu możesz otrzymywać ważne aktualizacje dotyczące wszystkich kont sprzedawcy, którymi zarządzasz, o ile uwierzytelnianie odbywa się za pomocą zarejestrowanego projektu Google Cloud.

Podczas rejestracji zapoznaj się z wymaganiami wstępnymi i ograniczeniami opisanymi w sekcji Rejestracja.

Przykład rejestrowania projektu za pomocą bibliotek klienta znajdziesz w tym przykładzie w języku Python: rejestrowanie projektu Google Cloud z podaniem adresu e-mail dewelopera.

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

Krok 4. Zarządzanie kontaktami dewelopera i uprawnieniami

Podczas rejestracji:

Jeśli adres e-mail należy do użytkownika konta Merchant Center, otrzyma on rolę API_DEVELOPER.
Jeśli adres e-mail nie należy do istniejącego użytkownika, na ten adres zostanie wysłane zaproszenie. Aby zostać dodanym jako nowy użytkownik z rolą API_DEVELOPER, odbiorca musi zaakceptować zaproszenie.

Po wstępnej rejestracji zalecamy dodanie kilku deweloperów i przyznanie im dodatkowych uprawnień dostępu.

Krok 4a. Przyznawanie dodatkowych uprawnień

Rola API_DEVELOPER jest wymagana do otrzymywania ważnych powiadomień, ale ma minimalne uprawnienia w Merchant Center. Aby umożliwić temu użytkownikowi wykonywanie innych wywołań interfejsu API lub zarządzanie ustawieniami w interfejsie Merchant Center, musisz przyznać mu dodatkowe role, takie jak STANDARD lub ADMIN. Więcej informacji znajdziesz w artykule Rodzaje dostępu.

Uprawnienia dostępu użytkownika możesz zaktualizować za pomocą metody accounts.users.patch.

Przykładowy kod pokazuje, jak zaktualizować użytkownika, aby przyznać mu role ADMIN i API_DEVELOPER. Dzięki temu będą mogli w pełni zarządzać kontem, a także otrzymywać komunikaty dotyczące interfejsu 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

Krok 4b. Dodawanie deweloperów rezerwowych

Aby zapobiec przerwaniu dostępu do interfejsu API w przypadku, gdy główna osoba kontaktowa dewelopera opuści Twoją organizację, dodaj co najmniej jednego dewelopera rezerwowego.

Użytkownika możesz dodać za pomocą metody accounts.users.create lub zaktualizować istniejącego za pomocą metody accounts.users.patch. Zalecamy przyznanie temu użytkownikowi ról ADMIN i API_DEVELOPER.

Krok 5. Tworzenie podstawowego źródła danych o produktach

Zanim wstawisz produkt, musisz mieć podstawowe źródło danych o produktach. Przykładowy kod, który tworzy źródło danych, znajdziesz w artykule Przykładowy kod w Pythonie, który tworzy podstawowe źródło danych o produktach obsługujące wiele języków.

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

To źródło danych możesz wyświetlić w interfejsie Merchant Center. Więcej informacji znajdziesz w artykule Jak znaleźć kartę Źródła danych.

Krok 6. Wstaw produkt

Po utworzeniu źródła danych spróbuj wstawić do niego produkt. Przykładowy kod, który pokazuje, jak to zrobić za pomocą bibliotek klienta, znajdziesz w artykule Wstawianie przykładowych danych wejściowych produktu za pomocą języka 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

Krok 7. Wyświetlanie produktów

Przykładowy kod, który wyświetla listę produktów w źródle danych, znajdziesz w artykule Przykładowy kod wyświetlający listę produktów w Pythonie.

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

Biblioteki klienta Zadbaj o dobrą organizację dzięki kolekcji Zapisuj i kategoryzuj treści zgodnie ze swoimi preferencjami.

Krok 1. Konfigurowanie uwierzytelniania i przykładowych kodów

Krok 2. Pobieranie i instalowanie biblioteki klienta oraz przykładowych fragmentów kodu

Krok 3. Zarejestruj się jako programista

Python

Krok 4. Zarządzanie kontaktami dewelopera i uprawnieniami

Krok 4a. Przyznawanie dodatkowych uprawnień

Python

Krok 4b. Dodawanie deweloperów rezerwowych

Krok 5. Tworzenie podstawowego źródła danych o produktach

Python

Krok 6. Wstaw produkt

Python

Krok 7. Wyświetlanie produktów

Python

Biblioteki klienta