Als Entwickler registrieren

Die Registrierung als Entwickler ist ein obligatorischer einmaliger Einrichtungsprozess, bei dem Ihr Google Cloud-Projekt mit Ihrem Merchant Center-Konto verknüpft und Ihre Entwicklerkontaktdaten bei Google registriert werden. So kann Google wichtige Servicemitteilungen und erforderliche Updates an die entsprechenden technischen
Kontakte senden, die Sie angeben.

Dieses Dokument ist Teil einer mehrteiligen Reihe zum Einstieg in die Merchant API. Wenn Sie sich bereits für die Merchant API registriert haben, können Sie mit dem nächsten Abschnitt fortfahren: Erstes Produkt einfügen 

Vorbereitung

Bevor Sie sich für die Verwendung der Merchant API registrieren, müssen Sie die folgenden Anforderungen erfüllen:

  • Merchant Center-Konto: Sie benötigen ein bestehendes Merchant Center-Konto.
  • Administratorzugriff auf das Merchant Center-Konto: Die E-Mail-Adresse oder das Dienstkonto, mit dem Sie den Registrierungsaufruf autorisieren, muss im Merchant Center-Konto, für das Sie sich registrieren, den Zugriffstyp ADMIN haben. Weitere Informationen finden Sie unter Anfragen an die Merchant API autorisieren.
  • Google Cloud-Projekt-ID: Ihre Anwendung muss einem dedizierten Google Cloud-Projekt zugeordnet sein, um Anmeldedaten für die Authentifizierung bereitzustellen. Weitere Informationen dazu, wo Sie die Projekt-ID finden, finden Sie hier.
  • Eine gültige E‑Mail-Adresse, die mit einem Google-Konto verknüpft ist und die Sie als Kontakt-E‑Mail-Adresse für Entwickler für Benachrichtigungen von Google angeben. Darf keine E‑Mail-Adresse eines Dienstkontos sein. Sie können eine E‑Mail-Adresse verwenden, die bereits Teil des Merchant Center-Kontos ist, oder eine neue.

Als Entwickler mit der Merchant API registrieren

Wenn Sie die Merchant API verwenden möchten, müssen Sie Ihre Entwicklerkontaktinformationen und Ihr Google Cloud-Projekt über die Methode registerGcp in Ihrem Merchant Center-Konto registrieren.

Unabhängig davon, ob Sie mit mehreren Händlerkonten arbeiten oder nicht, führen Sie den Registrierungsvorgang einmal für jedes Google Cloud-Projekt aus, das Sie verwenden möchten. Wenn Sie mit mehreren Google Cloud-Projekten arbeiten, können Sie alle oder einige davon im selben Merchant Center-Konto registrieren.

Vorteile der Registrierung

Die Registrierung bietet folgende Vorteile:

  • Erstellung des technischen Kontakts: Ein technischer Kontakt wird im Merchant Center erstellt. Google sendet wichtige API-spezifische Updates an den technischen Kontakt, z. B. Dienstankündigungen und Informationen zu neuen Funktionen.
  • Verwaltung mehrerer Händlerkonten: Sie können den Entwickler-Ansprechpartner für alle von Ihnen verwalteten Händlerkonten angeben.

Mit Ausnahme der Registrierung werden alle Aufrufe der Merchant API über ein nicht registriertes Google Cloud-Projekt blockiert. Es wird der Fehlercode 401 mit dem Status UNAUTHENTICATED und der folgenden Fehlermeldung zurückgegeben:

GCP project with id {GCP_ID} and number {GCP_NUMBER} is not registered with the merchant account.
Please follow these steps https://developers.google.com/merchant/api/guides/quickstart#register_as_a_developer
to register the GCP project with the merchant account then try calling the API again in 5 minutes.

Wichtige Hinweise

  • Einmalige Einrichtung für jedes Google Cloud-Projekt: Die Registrierung ist eine einmalige Einrichtung für jedes Google Cloud-Projekt und gilt für alle Nutzer und Dienstkonten im Google Cloud-Projekt. Achten Sie darauf, dass die Merchant API in Ihrem Google Cloud-Projekt aktiviert ist.
  • Jedes Google Cloud-Projekt kann jeweils nur mit einem Merchant Center-Konto registriert werden: Wenn Sie versuchen, ein Google Cloud-Projekt gleichzeitig mit mehreren Merchant Center-Konten zu registrieren, erhalten Sie den Fehler ALREADY_REGISTERED. Verwenden Sie für die Registrierung dieselbe E‑Mail-Adresse für Entwickler. Mehrere Google Cloud-Projekte können im selben Merchant Center-Konto registriert werden.
  • Das richtige Konto für Drittanbieter festlegen, die mehrere Händler verwalten:Drittanbieter, die mehrere Händler vertreten oder verwalten, müssen die entsprechende Kontostruktur im Google-Ökosystem verwenden. Welche ID Sie verwenden müssen, hängt von Ihrem Unternehmenstyp ab:
    • Marktplätze mit einem bestehenden erweiterten Konto:Wenn Ihr Unternehmen als Marktplatz fungiert und bereits ein erweitertes Konto für die gesamte Plattform hat, sollten Sie diese Konto-ID verwenden.
    • Preisvergleichsportale (Comparison Shopping Services, CSS): Wenn Sie ein Preisvergleichsportal sind, sollten Sie Ihre eindeutige Konto-ID für Preisvergleichsportale oder die Konto-ID für Preisvergleichsportal-Gruppen verwenden.
    • Agenturen, Entwickler und andere Drittanbieter:Wenn Sie ein Drittanbieterunternehmen wie eine Agentur oder ein Drittanbieterentwickler sind, das mehrere Händlerkonten verwaltet und keine einzelne Merchant Center-ID hat, die Ihr Unternehmen repräsentiert, sollten Sie ein neues primäres Merchant Center-Konto erstellen und beantragen, es in ein erweitertes Konto umzuwandeln. Mit erweiterten Konten können Unterkonten verwaltet werden und die erforderliche Struktur für Drittanbieter-Vorgänge bereitgestellt werden.
  • Registrierung nur für Ihr primäres Merchant Center-Konto durchführen: Sie führen die Entwicklerregistrierung nur mit Ihrem primären Merchant Center-Konto durch und werden zum Entwicklerkontakt für alle verknüpften Merchant Center-Unterkonten. Sie müssen sich nicht für jedes Ihrer Merchant Center-Unterkonten registrieren.

Alt-Text für Barrierefreiheit

Das obige Diagramm zeigt die Registrierungseinrichtung bei Verwendung mehrerer Google Cloud-Projekte und eines primären Merchant Center-Kontos mit optional mehreren Merchant Center-Unterkonten.

  • Nachdem Sie eine E‑Mail-Adresse für Entwickler registriert haben:
    • Sie können innerhalb von 5 Minuten nach der Registrierung Merchant API-Aufrufe durchführen.
    • Wenn die E-Mail-Adresse zu einem vorhandenen Merchant Center-Nutzer gehört, wird ihm die Rolle API_DEVELOPER zugewiesen. Andernfalls wird ein neuer Nutzer im Merchant Center erstellt und er muss eine Einladung innerhalb von 14 Tagen annehmen, damit sie nicht abläuft und der Registrierungsprozess nicht neu gestartet werden muss. Sie schließen die Registrierung erst ab, nachdem der Nutzer auf den Einladungslink geklickt hat.

Registrierungsanruf tätigen

Die Registrierung erfolgt durch Aufrufen der Methode registerGcp. Sie haben zwei Möglichkeiten, den Registrierungsanruf zu starten:

  • Option 1: Direkte API-Aufrufe: Sie senden Rohdatenanfragen direkt an die API-Endpunkte, in der Regel über HTTP(S). Sie kümmern sich manuell um Aspekte wie das Erstellen des Anfragetexts, das Festlegen von Headern (einschließlich der Authentifizierung) und das Parsen der Antwort.
  • Option 2: Clientbibliotheken Sie verwenden die vorgefertigten Bibliotheken, die eine bequemere, sprachidiomatische Möglichkeit zur Interaktion mit der Merchant API bieten. Sie übernehmen die Authentifizierung und Autorisierung und bieten eine praktische Möglichkeit, die zugrunde liegende HTTP-Kommunikation zu abstrahieren. Offizielle Codebeispiele sind verfügbar, um Ihnen den Einstieg zu erleichtern.

Autorisierung für den Registrierungsanruf

Wie im Schritt Anfragen an die Merchant API autorisieren beschrieben, gibt es zwei verschiedene Authentifizierungsszenarien:

  • OAuth 2.0: für Drittanbieter oder Agenturen, die mehrere Händlerkonten verwalten
  • Dienstkonten: für den Zugriff auf Ihr eigenes Merchant Center-Konto

Weitere Informationen zur Autorisierung des Registrierungsaufrufs finden Sie unter Wie führe ich die Authentifizierung und Autorisierung für den Registrierungsaufruf durch?

Registrierungsanruf

In den folgenden Beispielen führen Sie den Registrierungsaufruf mit direkten API-Aufrufen oder Clientbibliotheken aus.

Sie führen den Registrierungsaufruf mit der Methode registerGcp durch.

POST https://merchantapi.googleapis.com/accounts/v1/accounts/{ACCOUNT_ID}/developerRegistration:registerGcp
Content-Type: application/json
Authorization: Bearer {ACCESS_TOKEN}"

{
  "developerEmail": "{DEVELOPER_EMAIL}"
}

Ersetzen Sie Folgendes:

  • ACCOUNT_ID: Ihre Merchant Center-ID
  • ACCESS_TOKEN: das Autorisierungstoken für den API-Aufruf
  • DEVELOPER_EMAIL: die E-Mail-Adresse des primären technischen Kontakts

Bei einem erfolgreichen Aufruf wird eine DeveloperRegistration-Ressource zurückgegeben, die den erfolgreichen Verknüpfungsstatus bestätigt:

  "name": "accounts/{ACCOUNT_ID}/developerRegistration",
  "gcpIds": ["{GOOGLE_CLOUD_PROJECT_ID}"]

Python

Laden Sie die Beispiele herunter und folgen Sie der Anleitung unter Google Merchant API Python Samples, um die Python-Clientbibliotheken einzurichten.

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

Java

Laden Sie die Beispiele herunter und folgen Sie der Anleitung unter Google Merchant API Java Samples, um die Java-Clientbibliotheken einzurichten.

import com.google.api.gax.core.FixedCredentialsProvider;
import com.google.auth.oauth2.GoogleCredentials;
import com.google.shopping.merchant.accounts.v1.DeveloperRegistration;
import com.google.shopping.merchant.accounts.v1.DeveloperRegistrationName;
import com.google.shopping.merchant.accounts.v1.DeveloperRegistrationServiceClient;
import com.google.shopping.merchant.accounts.v1.DeveloperRegistrationServiceSettings;
import com.google.shopping.merchant.accounts.v1.RegisterGcpRequest;
import shopping.merchant.samples.utils.Authenticator;
import shopping.merchant.samples.utils.Config;

/**
 * This class demonstrates how to register the GCP project used to call the Merchant API with a
 * developer email.
 */
public class RegisterGcpSample {

  public static void registerGcp(Config config, String developerEmail) throws Exception {

    // Obtains OAuth token based on the user's configuration.
    GoogleCredentials credential = new Authenticator().authenticate();

    // Creates service settings using the credentials retrieved above.
    DeveloperRegistrationServiceSettings developerRegistrationServiceSettings =
        DeveloperRegistrationServiceSettings.newBuilder()
            .setCredentialsProvider(FixedCredentialsProvider.create(credential))
            .build();

    // Creates DeveloperRegistration name to identify the DeveloperRegistration.
    // The name has the format: accounts/{account}/developerRegistration
    String name =
        DeveloperRegistrationName.newBuilder()
            .setAccount(config.getAccountId().toString())
            .build()
            .toString();

    // Calls the API and catches and prints any network failures/errors.
    try (DeveloperRegistrationServiceClient developerRegistrationServiceClient =
        DeveloperRegistrationServiceClient.create(developerRegistrationServiceSettings)) {

      // Creates a request to register the GCP project with the developer email.
      RegisterGcpRequest request =
          RegisterGcpRequest.newBuilder().setName(name).setDeveloperEmail(developerEmail).build();

      System.out.println("Sending RegisterGcp request:");
      DeveloperRegistration response = developerRegistrationServiceClient.registerGcp(request);

      System.out.println(response);
    } catch (Exception e) {
      System.out.println(e);
    }
  }

  public static void main(String[] args) throws Exception {
    Config config = Config.load();
    String developerEmail = "YOUR_EMAIL_HERE"; // Replace with your email
    registerGcp(config, developerEmail);
  }
}
RegisterGcpSample.java

PHP

Laden Sie die Beispiele herunter und folgen Sie der Anleitung unter Google Merchant API PHP Samples, um die PHP-Clientbibliotheken einzurichten.

require_once __DIR__ . '/../../../../vendor/autoload.php';
require_once __DIR__ . '/../../../Authentication/Authentication.php';
require_once __DIR__ . '/../../../Authentication/Config.php';

use Google\ApiCore\ApiException;
use Google\Shopping\Merchant\Accounts\V1\Client\DeveloperRegistrationServiceClient;
use Google\Shopping\Merchant\Accounts\V1\RegisterGcpRequest;

/**
 * This class demonstrates how to register the GCP project used to call the
 * Merchant API with a developer email.
 */
class RegisterGcpSample
{
    /**
     * A helper function to create the name string for the
     * DeveloperRegistration.
     *
     * @param string $accountId The merchant account ID.
     * @return string The name, which has the format:
     *     `accounts/{account}/developerRegistration`
     */
    private static function getName(string $accountId): string
    {
        return sprintf("accounts/%s/developerRegistration", $accountId);
    }

    /**
     * Registers the GCP project with a developer email.
     *
     * @param array $config The configuration data for authentication and account ID.
     * @param string $developerEmail The email of the developer to register.
     */
    public static function registerGcpSample(array $config, string $developerEmail): void
    {
        // Obtains OAuth credentials from the configuration file.
        $credentials = Authentication::useServiceAccountOrTokenFile();

        // Creates a configuration object for the client.
        $options = ['credentials' => $credentials];

        // Creates the DeveloperRegistrationServiceClient.
        $developerRegistrationServiceClient = new DeveloperRegistrationServiceClient($options);

        // Creates the name of the developer registration to identify it.
        $name = self::getName($config['accountId']);

        // Calls the API and handles any network failures.
        try {
            // Creates a request to register the GCP project with the developer email.
            $request = new RegisterGcpRequest([
                'name' => $name,
                'developer_email' => $developerEmail
            ]);

            printf("Sending RegisterGcp request:%s", PHP_EOL);
            // The `registerGcp` method returns a `DeveloperRegistration` object
            // upon success.
            $response = $developerRegistrationServiceClient->registerGcp($request);
            print "Successfully registered developer email '$developerEmail' for account {$config['accountId']}.\n";
            print_r($response);
        } catch (ApiException $e) {
            printf("An error occurred: %s%s", $e->getMessage(), PHP_EOL);
        }
    }

    /**
     * Helper to execute the sample.
     */
    public function callSample(): void
    {
        $config = Config::generateConfig();
        // An email address for a developer to register for the API.
        $developerEmail = 'YOUR_EMAIL_HERE'; // Replace with your email
        self::registerGcpSample($config, $developerEmail);
    }
}

// Executes the sample.
$sample = new RegisterGcpSample();
$sample->callSample();
RegisterGcpSample.php

cURL

curl -X POST "https://merchantapi.googleapis.com/accounts/v1/accounts/{ACCOUNT_ID}/developerRegistration:registerGcp" \
-H "Content-Type: application/json" \
-H "Authorization: Bearer {ACCESS_TOKEN}" \
-d '{
  "developerEmail": "{DEVELOPER_EMAIL}"
}'

Best Practices nach der Registrierung

Damit Sie von einer robusten Zugriffsverwaltung profitieren und künftige Dienstunterbrechungen vermeiden, empfehlen wir Ihnen, nach der ersten Registrierung einige Best Practices zu befolgen:

Zusätzliche Berechtigungen für den API-Entwickler erteilen

Wenn Sie einen Entwicklerkontakt registrieren, wird ihm automatisch die Rolle API_DEVELOPER zugewiesen. Diese Rolle umfasst nicht die anderen Berechtigungen, die zum Verwalten des Merchant Center-Kontos oder zum Ausführen aller API-Aufrufe erforderlich sind. Wir empfehlen, Ihren Entwicklern die Rollen ADMIN oder STANDARD zuzuweisen, um ihnen umfassenden Zugriff zu gewähren.

Verwenden Sie die Methode accounts.users.patch, um die Zugriffsrechte eines Nutzers zu ändern. Sie geben Zugriffsrechte im Feld „updateMask“ des Anfragetexts an, um Rollen hinzuzufügen oder zu entfernen:

PATCH https://merchantapi.googleapis.com/accounts/v1/{ACCOUNT_ID}/users/{DEVELOPER_EMAIL}?update_mask=access_rights
Content-Type: application/json
Authorization: Bearer {ACCESS_TOKEN}"

{
  "name": "accounts/{ACCOUNT_ID}/users/{DEVELOPER_EMAIL}",
  "access_rights": [ "ADMIN", "API_DEVELOPER" ]
}

Python

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

Java

import com.google.api.gax.core.FixedCredentialsProvider;
import com.google.auth.oauth2.GoogleCredentials;
import com.google.protobuf.FieldMask;
import com.google.shopping.merchant.accounts.v1.AccessRight;
import com.google.shopping.merchant.accounts.v1.UpdateUserRequest;
import com.google.shopping.merchant.accounts.v1.User;
import com.google.shopping.merchant.accounts.v1.UserName;
import com.google.shopping.merchant.accounts.v1.UserServiceClient;
import com.google.shopping.merchant.accounts.v1.UserServiceSettings;
import shopping.merchant.samples.utils.Authenticator;
import shopping.merchant.samples.utils.Config;

/** This class demonstrates how to update a user to make it an admin of the MC account. */
public class UpdateUserSample {

  public static void updateUser(Config config, String email, AccessRight accessRight)
      throws Exception {

    GoogleCredentials credential = new Authenticator().authenticate();

    UserServiceSettings userServiceSettings =
        UserServiceSettings.newBuilder()
            .setCredentialsProvider(FixedCredentialsProvider.create(credential))
            .build();

    // Creates user name to identify user.
    String name =
        UserName.newBuilder()
            .setAccount(config.getAccountId().toString())
            .setEmail(email)
            .build()
            .toString();

    // Create a user with the updated fields.
    User user = User.newBuilder().setName(name).addAccessRights(accessRight).build();

    FieldMask fieldMask = FieldMask.newBuilder().addPaths("access_rights").build();

    try (UserServiceClient userServiceClient = UserServiceClient.create(userServiceSettings)) {

      UpdateUserRequest request =
          UpdateUserRequest.newBuilder().setUser(user).setUpdateMask(fieldMask).build();

      System.out.println("Sending Update User request");
      User response = userServiceClient.updateUser(request);
      System.out.println("Updated User Name below");
      System.out.println(response.getName());
    } catch (Exception e) {
      System.out.println(e);
    }
  }

  public static void main(String[] args) throws Exception {
    Config config = Config.load();
    String email = "testUser@gmail.com";
    // Give the user admin rights. Note that all other rights, like
    // PERFORMANCE_REPORTING, would be overwritten in this example
    // if the user had those access rights before the update.
    AccessRight accessRight = AccessRight.ADMIN;

    updateUser(config, email, accessRight);
  }
}
UpdateUserSample.java

PHP

use Google\ApiCore\ApiException;
use Google\Protobuf\FieldMask;
use Google\Shopping\Merchant\Accounts\V1\AccessRight;
use Google\Shopping\Merchant\Accounts\V1\UpdateUserRequest;
use Google\Shopping\Merchant\Accounts\V1\User;
use Google\Shopping\Merchant\Accounts\V1\Client\UserServiceClient;


/**
 * Updates a user.
 *
 * @param array $config The configuration data.
 * @param string $email The email address of the user.
 * @param int $accessRight The access right to grant the user.
 * @return void
 */
function updateUser($config, $email, $accessRights): void
{
    // Gets the OAuth credentials to make the request.
    $credentials = Authentication::useServiceAccountOrTokenFile();

    // Creates options config containing credentials for the client to use.
    $options = ['credentials' => $credentials];

    // Creates a client.
    $userServiceClient = new UserServiceClient($options);

    // Creates user name to identify user.
    $name = 'accounts/' . $config['accountId'] . "/users/" . $email;

    $user = (new User())
        ->setName($name)
        ->setAccessRights($accessRights);

    $fieldMask = (new FieldMask())->setPaths(['access_rights']);

    // Calls the API and catches and prints any network failures/errors.
    try {
        $request = new UpdateUserRequest([
            'user' => $user,
            'update_mask' => $fieldMask,
        ]);

        print "Sending Update User request\n";
        $response = $userServiceClient->updateUser($request);
        print "Updated User Name below\n";
        print $response->getName() . "\n";
    } catch (ApiException $e) {
        print $e->getMessage();
    }
}


$config = Config::generateConfig();
$email = "testUser@gmail.com";
$accessRights = [AccessRight::ADMIN];

updateUser($config, $email, $accessRights);
UpdateUserSample.php

cURL

curl -X PATCH \
"https://merchantapi.googleapis.com/accounts/v1/{ACCOUNT_ID}/users/{USER_EMAIL}?update_mask=access_rights" \
-H "Content-Type: application/json" \
-H "Authorization: Bearer {ACCESS_TOKEN}" \
-d '{
  "access_rights": [
    "ADMIN",
    "API_DEVELOPER"
  ]
}'

Weitere Kontaktdaten des Entwicklers hinzufügen

Um Unterbrechungen des Geschäftsbetriebs zu vermeiden, wenn der primäre Entwicklerkontakt das Unternehmen verlässt oder den Zugriff verliert, ist es wichtig, redundante Kontakte zu haben. Wir empfehlen, mindestens einen zusätzlichen Nutzer mit der Rolle API_DEVELOPER im Merchant Center zu haben, der als Backup dienen kann.

Sie können einen Nutzer mit dem Dienst accounts.users in der Merchant API oder auf der Seite Zugriff und Dienste in der Merchant Center-Benutzeroberfläche hinzufügen oder einen vorhandenen Nutzer aktualisieren. Wenn Sie proaktiv Backup-Entwickler hinzufügen, schaffen Sie eine robustere Integration, die nicht von einer einzelnen Person abhängig ist.

PATCH https://merchantapi.googleapis.com/products/v1/accounts/{ACCOUNT_ID}/users
Content-Type: application/json
Authorization: Bearer {ACCESS_TOKEN}"
{
  "user_id": {USER_EMAIL},
  "user": { "access_rights": [ "API_DEVELOPER", "ADMIN" ] }
}

Python

from examples.authentication import configuration
from examples.authentication import generate_user_credentials
from google.shopping.merchant_accounts_v1 import AccessRight
from google.shopping.merchant_accounts_v1 import CreateUserRequest
from google.shopping.merchant_accounts_v1 import User
from google.shopping.merchant_accounts_v1 import UserServiceClient

_ACCOUNT = configuration.Configuration().read_merchant_info()


def get_parent(account_id):
  return f"accounts/{account_id}"


def create_user(user_email):
  """Creates a user for a Merchant Center account."""

  # Get OAuth credentials
  credentials = generate_user_credentials.main()

  # Create a UserServiceClient
  client = UserServiceClient(credentials=credentials)

  # Create parent string
  parent = get_parent(_ACCOUNT)

  # Create the request
  request = CreateUserRequest(
      parent=parent,
      user_id=user_email,
      user=User(
          access_rights=[AccessRight.ADMIN, AccessRight.PERFORMANCE_REPORTING]
      ),
  )

  try:
    print("Sending Create User request")
    response = client.create_user(request=request)
    print("Inserted User Name below")
    print(response.name)
  except RuntimeError as e:
    print(e)


if __name__ == "__main__":
  # Modify this email to create a new user
  email = "USER_MAIL_ACCOUNT"
  create_user(email)

create_user_sample.py

Java

import com.google.api.gax.core.FixedCredentialsProvider;
import com.google.auth.oauth2.GoogleCredentials;
import com.google.shopping.merchant.accounts.v1.AccessRight;
import com.google.shopping.merchant.accounts.v1.CreateUserRequest;
import com.google.shopping.merchant.accounts.v1.User;
import com.google.shopping.merchant.accounts.v1.UserServiceClient;
import com.google.shopping.merchant.accounts.v1.UserServiceSettings;
import shopping.merchant.samples.utils.Authenticator;
import shopping.merchant.samples.utils.Config;

/** This class demonstrates how to create a user for a Merchant Center account. */
public class CreateUserSample {

  private static String getParent(String accountId) {
    return String.format("accounts/%s", accountId);
  }

  public static void createUser(Config config, String email) throws Exception {

    // Obtains OAuth token based on the user's configuration.
    GoogleCredentials credential = new Authenticator().authenticate();

    // Creates service settings using the credentials retrieved above.
    UserServiceSettings userServiceSettings =
        UserServiceSettings.newBuilder()
            .setCredentialsProvider(FixedCredentialsProvider.create(credential))
            .build();

    // Creates parent to identify where to insert the user.
    String parent = getParent(config.getAccountId().toString());

    // Calls the API and catches and prints any network failures/errors.
    try (UserServiceClient userServiceClient = UserServiceClient.create(userServiceSettings)) {

      CreateUserRequest request =
          CreateUserRequest.newBuilder()
              .setParent(parent)
              // This field is the email address of the user.
              .setUserId(email)
              .setUser(
                  User.newBuilder()
                      .addAccessRights(AccessRight.ADMIN)
                      .addAccessRights(AccessRight.PERFORMANCE_REPORTING)
                      .build())
              .build();

      System.out.println("Sending Create User request");
      User response = userServiceClient.createUser(request);
      System.out.println("Inserted User Name below");
      // The last part of the user name will be the email address of the user.
      // Format: `accounts/{account}/user/{user}`
      System.out.println(response.getName());
    } catch (Exception e) {
      System.out.println(e);
    }
  }

  public static void main(String[] args) throws Exception {
    Config config = Config.load();
    // The email address of this user.
    String email = "testUser@gmail.com";

    createUser(config, email);
  }
}
CreateUserSample.java

PHP

use Google\ApiCore\ApiException;
use Google\Shopping\Merchant\Accounts\V1\AccessRight;
use Google\Shopping\Merchant\Accounts\V1\CreateUserRequest;
use Google\Shopping\Merchant\Accounts\V1\User;
use Google\Shopping\Merchant\Accounts\V1\Client\UserServiceClient;


/**
 * Creates a user.
 *
 * @param array $config The configuration data.
 * @param string $email The email address of the user.
 * @return void
 */
function createUser($config, $email): void
{
    // Gets the OAuth credentials to make the request.
    $credentials = Authentication::useServiceAccountOrTokenFile();

    // Creates options config containing credentials for the client to use.
    $options = ['credentials' => $credentials];

    // Creates a client.
    $userServiceClient = new UserServiceClient($options);

    // Creates parent to identify where to insert the user.
    $parent = sprintf("accounts/%s", $config['accountId']);

    // Calls the API and catches and prints any network failures/errors.
    try {
        $request = new CreateUserRequest([
            'parent' => $parent,
            'user_id' => $email,
            'user' => (new User())
                ->setAccessRights([AccessRight::ADMIN,AccessRight::PERFORMANCE_REPORTING])
        ]);

        print "Sending Create User request\n";
        $response = $userServiceClient->createUser($request);
        print "Inserted User Name below\n";
        print $response->getName() . "\n";
    } catch (ApiException $e) {
        print $e->getMessage();
    }
}

$config = Config::generateConfig();
$email = "testUser@gmail.com";

createUser($config, $email);
CreateUserSample.php

cURL

curl -X PATCH \
"https://merchantapi.googleapis.com/products/v1/accounts/{ACCOUNT_ID}/users/{USER_EMAIL}?update_mask=access_rights" \
-H "Content-Type: application/json" \
-H "Authorization: Bearer {ACCESS_TOKEN}" \
-d '{
  "access_rights": [
    "ADMIN",
    "API_DEVELOPER"
  ]
}'
Zurück
Set up authentication
Weiter
Insert your first product