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 Kontaktdaten als Entwickler bei Google registriert werden. So kann Google wichtige Servicemitteilungen und obligatorische Updates an die entsprechenden technischen Kontakte senden, die Sie angegeben haben.

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 Merchant API registrieren, müssen Sie die folgenden Anforderungen erfüllen:

  • Merchant Center-Konto: Sie benötigen ein bestehendes Merchant Center Konto. Die Registrierung wird nur für Produktionskonten unterstützt. Testkonten sind nicht für die Entwicklerregistrierung geeignet.
  • Bestätigte Startseite: Für Ihr Merchant Center-Konto muss eine bestätigte Website vorhanden sein. So weisen Sie nach, dass Sie Inhaber der mit Ihrem Unternehmen verknüpften Domain sind.
  • Administratorzugriff auf das Merchant Center-Konto: Das E‑Mail- oder Dienst konto, das Sie zum Autorisieren des Registrierungsaufrufs verwenden, muss im Merchant Center-Konto, für das Sie sich registrieren, den Zugriff typ ADMIN haben. Weitere Informationen finden Sie unter Anfragen an die Merchant API autorisieren.
  • Google Cloud-Projekt-ID: Ihre Anwendung muss mit einem bestimmten Google Cloud-Projekt verknüpft sein, um Anmeldedaten für die Authentifizierung bereitzustellen. Informationen dazu, wo Sie die Projekt-ID finden, finden Sie unter Projektname, ‑nummer und ‑ID ermitteln.
  • Eine gültige E‑Mail-Adresse, die mit einem Google-Konto verknüpft ist und die Sie als Kontakt für Entwickler für Updates von Google angeben. Dabei darf es sich nicht um die E‑Mail-Adresse eines Dienstkontos handeln. Sie können eine E‑Mail-Adresse verwenden, die bereits Teil des Merchant Center-Kontos ist, oder eine neue.

Als Entwickler für die Merchant API registrieren

Wenn Sie die Merchant API verwenden möchten, müssen Sie Ihre Kontaktdaten als Entwickler und Ihr Google Cloud-Projekt mit Ihrem Merchant Center Konto verknüpfen. Verwenden Sie dazu die Methode registerGcp.

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 für dasselbe Merchant Center-Konto registrieren.

Vorteile der Registrierung

Die Registrierung bietet folgende Vorteile:

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

Mit Ausnahme der Registrierung werden alle Aufrufe der Merchant API von einem nicht registrierten 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.
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 für ein Merchant Center-Konto registriert werden: Wenn Sie versuchen, ein Google Cloud-Projekt gleichzeitig für mehrere Merchant Center-Konten zu registrieren, wird der Fehler ALREADY_REGISTERED angezeigt. Verwenden Sie für die Registrierung dieselbe E‑Mail-Adresse für Entwickler. Beachten Sie, dass mehrere Google Cloud-Projekte für dasselbe Merchant Center-Konto registriert werden können.

  • Das richtige Konto für Drittanbieter festlegen, die mehrere Händler verwalten:Um langfristige Stabilität zu gewährleisten und Dienstunterbrechungen zu vermeiden, müssen Drittanbieter, die mehrere Händler vertreten oder verwalten, die entsprechende Kontostruktur im Google-Ökosystem verwenden. Wir empfehlen, das Konto zu registrieren, das Ihre Unternehmensidentität repräsentiert. Das hängt von Ihrem Unternehmenstyp ab:

    • Marktplätze mit einem bestehenden erweiterten Konto: Wenn Ihr Unternehmen als Marktplatz fungiert und bereits ein erweitertes Konto vorhanden ist, das die gesamte Plattform repräsentiert, sollten Sie diese Konto-ID verwenden.
    • Preisvergleichsportale : Wenn Sie ein Preisvergleichsportal sind, sollten Sie Ihre eindeutige Konto-ID für das Preisvergleichsportal oder die Konto-ID für die Preisvergleichsportal-Gruppe verwenden.
    • Agenturen, Entwickler und andere Drittanbieter: Wenn Sie ein Drittanbieterunternehmen sind, z. B. eine Agentur oder ein Drittanbieterentwickler, der mehrere Händlerkonten verwaltet, und keine einzelne Merchant Center-ID haben, 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 sie bieten die erforderliche Struktur für Drittanbietervorgänge.

    Die folgende Tabelle enthält Empfehlungen für verschiedene Partnertypen:

    Partnertyp Empfohlenes Konto für die Registrierung
    Marktplätze Ihr primäres (oder größtes) erweitertes Konto.
    Werbeagenturen Ein eigenständiges Konto oder ein erweitertes Konto, das Ihr Unternehmen repräsentiert. Wenn Sie gerade erst mit der Merchant API beginnen, empfehlen wir, ein eigenständiges Konto zu erstellen.
    Preisvergleichsportale Ihre Konto-ID für die Preisvergleichsportal-Gruppe oder eine bestimmte Konto-ID für das Preisvergleichsportal, je nachdem, ob das Konto die gesamte Preisvergleichsportal-Gruppe oder nur ein bestimmtes Preisvergleichsportal innerhalb einer Gruppe repräsentiert. Verwenden Sie kein erweitertes Konto für ein Preisvergleichsportal.
    Händler oder Marken Ihr Hauptkonto, das Ihre Marke repräsentiert. Kann ein eigenständiges oder ein erweitertes Konto sein.
    Kassen-/Inventar-Datenanbieter Ihr primäres (oder größtes) erweitertes Konto.
    Andere Drittanbieter Wenn Sie ein Merchant Center-Konto haben, können Sie es für die Registrierung verwenden. Andernfalls erstellen Sie ein eigenständiges Unternehmenskonto. Bestätigen Sie dann Ihre Website.

  • Registrierung nur für Ihr primäres Merchant Center durchführen: Sie führen die Entwicklerregistrierung nur mit Ihrem primären Merchant Center Konto durch und werden zum Kontakt für Entwickler für alle verknüpften Merchant Center-Unterkonten. Führen Sie die Registrierung nicht für jedes Ihrer Merchant Center-Unterkonten durch.

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.

  • Authentifizierungsanforderung: Bei der Registrierung muss das authentifizierte Merchant Center-Konto (das Konto, in dem sich Ihre Anmeldedaten befinden) mit dem imitierten Merchant Center-Konto (das Konto, für das Sie sich registrieren) übereinstimmen. Sie können sich nicht für ein Unterkonto registrieren, wenn Sie mit einem separaten übergeordneten Konto oder Verwaltungskonto authentifiziert sind.

  • Nur bestätigte Websitekonten: Die Registrierung ist nur für Merchant Center-Konten mit einer bestätigten Website zulässig.

  • Keine Registrierung für Testkonten: Sie können keine Registrierung für Testkonten durchführen.

  • 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 bestehenden Merchant Center-Nutzer gehört, erhält dieser die Rolle API developer. Andernfalls wird ein neuer Nutzer im Merchant Center erstellt und muss eine Einladung innerhalb von 14 Tagen annehmen, damit sie nicht abläuft und der Registrierungsvorgang nicht neu gestartet werden muss. Sie schließen den Registrierungsvorgang erst ab, nachdem der Nutzer auf den Einladungslink geklickt hat.

Registrierungsaufruf durchführen

Sie registrieren sich, indem Sie die Methode registerGcp aufrufen. Dabei haben Sie zwei Möglichkeiten:

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

Autorisierung für den Registrierungsaufruf

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?

Registrierungsaufruf

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

Sie führen den Registrierungsaufruf mit der 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

Ein erfolgreicher Aufruf gibt eine DeveloperRegistration-Ressource zurück, 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 den 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)

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);
  }
}

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();

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}"
}'

Um die Registrierung abzuschließen, muss mindestens ein Nutzer in Merchant Center die API developer Rolle haben. Dazu haben Sie folgende Möglichkeiten:

  • Geben Sie die developerEmail für die Methode registerGcp an.
  • Fügen Sie in der Merchant Center-Benutzeroberfläche einen neuen Nutzer mit der API developer Rolle hinzu.
  • Weisen Sie einem vorhandenen Nutzer in der Merchant Center-Benutzeroberfläche die Rolle API developer zu.
  • Rufen Sie die Methode accounts.users.create auf, um einen neuen Nutzer zu erstellen und ihm die Rolle API developer zuzuweisen.
  • Weisen Sie einem vorhandenen Nutzer mit der accounts.users.patch Methode die API developer Rolle zu.

Best Practices nach der Registrierung

Um von einer robusten Zugriffsverwaltung zu profitieren und zukünftige Dienstunterbrechungen zu vermeiden, empfehlen wir, nach Abschluss der ersten Registrierung eine Reihe von Best Practices zu beachten:

Zusätzliche Berechtigungen für den API developer erteilen

Wenn Sie einen Kontakt für Entwickler registrieren, wird ihm automatisch die API developer Rolle zugewiesen. Diese Rolle enthält keine anderen Berechtigungen, die für die Verwaltung des Merchant Center-Kontos oder für alle API-Aufrufe erforderlich sind. Wir empfehlen, Ihren Entwicklern die Rollen ADMIN oder STANDARD zuzuweisen, um umfassenden Zugriff zu gewähren.

Verwenden Sie die accounts.users.patch Methode, um die Zugriffsrechte eines Nutzers zu ändern. Sie geben die 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)

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);
  }
}

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);

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 Kontakte für Entwickler hinzufügen

Um Dienstunterbrechungen zu vermeiden, wenn der primäre Kontakt für Entwickler das Unternehmen verlässt oder den Zugriff verliert, sind redundante Kontakte unerlässlich. Wir empfehlen, mindestens einen zusätzlichen Nutzer mit der Rolle API developer im Merchant Center als Backup zu haben.

Sie können einen Nutzer hinzufügen oder einen vorhandenen Nutzer mit dem accounts.users Dienst in der Merchant API oder auf der Seite Zugriff und Dienste in der Merchant Center-Benutzeroberfläche 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)

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);
  }
}

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);

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