La version v1beta de l'API Merchant a été abandonnée et arrêtée le 28 février 2026. Pour savoir comment passer à la dernière version stable, consultez Migrer de v1beta vers v1.

S'inscrire comme développeur

L'inscription en tant que développeur est une procédure de configuration unique et obligatoire qui associe votre projet Google Cloud à votre compte Merchant Center et enregistre vos coordonnées de développeur auprès de Google. Cela permet à Google d'envoyer des annonces de service critiques et des mises à jour obligatoires aux contacts techniques concernés que vous fournissez.

Ce document fait partie d'une série d'articles sur la prise en main de l'API Merchant. Si vous êtes déjà inscrit à l'API Merchant, vous pouvez passer à la section suivante : Insérer votre premier produit

Prérequis

Avant de vous inscrire pour utiliser l'API Merchant, assurez-vous de remplir les conditions suivantes :

Compte Merchant Center : vous devez disposer d'un compte Merchant Center.
Accès administrateur au compte Merchant Center : l'adresse e-mail ou le compte de service que vous utilisez pour autoriser l'appel d'enregistrement doit disposer d'un accès de type ADMIN dans le compte Merchant Center auquel vous vous enregistrez. Pour en savoir plus, consultez Autoriser les requêtes envoyées à l'API Merchant.
ID du projet Google Cloud : votre application doit être associée à un projet Google Cloud dédié pour fournir des identifiants d'authentification. Pour savoir où trouver l'ID du projet, consultez Trouver le nom, le numéro et l'ID du projet.
Une adresse e-mail valide associée à un compte Google que vous fournissez comme point de contact du développeur pour recevoir les informations de Google. Ne doit pas être une adresse e-mail de compte de service. Vous pouvez utiliser une adresse e-mail qui fait déjà partie du compte Merchant Center ou en créer une.

S'inscrire en tant que développeur avec l'API Merchant

Pour utiliser l'API Merchant, vous devez enregistrer vos coordonnées de développeur et votre projet Google Cloud avec votre compte Merchant Center à l'aide de la méthode registerGcp.

Que vous travailliez ou non avec plusieurs comptes de marchand, vous effectuez l'opération d'enregistrement une seule fois pour chaque projet Google Cloud que vous comptez utiliser. Si vous travaillez sur plusieurs projets Google Cloud, vous pouvez tous les enregistrer dans le même compte Merchant Center.

Avantages de l'inscription

L'enregistrement offre les avantages suivants :

Création d'un contact technique : crée un contact technique dans Merchant Center. Google envoie des informations importantes spécifiques à l'API au contact technique, comme des annonces de service et des informations sur les nouvelles fonctionnalités.
Gestion de plusieurs comptes de marchand : vous pouvez indiquer le développeur comme point de contact pour tous les comptes de marchand que vous gérez.

À l'exception de l'enregistrement, tous les appels à l'API Merchant depuis un projet Google Cloud non enregistré sont bloqués et renvoient un code d'erreur 401 avec l'état UNAUTHENTICATED et le message d'erreur suivant :

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.

Remarques importantes

Configuration unique pour chaque projet Google Cloud : l'enregistrement est une configuration unique pour chaque projet Google Cloud. Il s'applique à tous les utilisateurs et comptes de service du projet Google Cloud. Assurez-vous que l'API Merchant est activée dans votre projet Google Cloud.
Chaque projet Google Cloud ne peut être enregistré qu'avec un seul compte Merchant Center à la fois : si vous essayez d'enregistrer un projet Google Cloud avec plusieurs comptes Merchant Center simultanément, vous recevrez une erreur ALREADY_REGISTERED. Utilisez la même adresse e-mail de développeur pour l'inscription. Notez que plusieurs projets Google Cloud peuvent être enregistrés dans le même compte Merchant Center.
Désignez le bon compte pour les tiers gérant plusieurs marchands : les tiers qui représentent ou gèrent plusieurs marchands doivent utiliser la structure de compte appropriée dans l'écosystème Google. L'ID à utiliser dépend de votre type d'entreprise :
- Places de marché disposant d'un compte avancé : si votre entreprise fonctionne comme une place de marché et dispose déjà d'un compte avancé représentant l'ensemble de la plate-forme, vous devez utiliser l'ID de compte existant.
- Services de comparaison de prix (CSS) : si vous êtes un CSS, vous devez utiliser votre ID de compte CSS ou votre ID de compte de groupe CSS unique.
- Agences, développeurs et autres tiers : si vous êtes une entreprise tierce (agence ou développeur tiers, par exemple) qui gère plusieurs comptes marchands et ne dispose pas d'un seul ID Merchant Center représentant votre entreprise, vous devez créer un compte Merchant Center principal et demander à le convertir en compte avancé. Les comptes avancés peuvent gérer les sous-comptes et fournir la structure nécessaire aux opérations tierces.
Inscrivez-vous uniquement avec votre compte Merchant Center principal : vous vous inscrivez en tant que développeur uniquement avec votre compte Merchant Center principal. Vous devenez alors le contact du développeur pour tous les sous-comptes Merchant Center associés. N'enregistrez pas chacun de vos sous-comptes Merchant Center.

Texte alternatif pour l'accessibilité

Le schéma précédent montre la configuration de l'enregistrement lorsque vous utilisez plusieurs projets Google Cloud et un compte Merchant Center principal avec éventuellement plusieurs sous-comptes Merchant Center.

Une fois que vous avez enregistré une adresse e-mail de développeur :
- Vous pouvez effectuer des appels à l'API Merchant dans les cinq minutes suivant votre inscription.
- Si l'adresse e-mail appartient à un utilisateur Merchant Center existant, le rôle API_DEVELOPER lui est attribué. Sinon, un nouvel utilisateur est créé dans Merchant Center. Il doit accepter l'invitation dans les 14 jours pour éviter qu'elle n'expire et qu'il doive recommencer la procédure d'enregistrement. Vous ne devez terminer la procédure d'inscription qu'une fois que l'utilisateur a cliqué sur le lien d'invitation.

Appeler l'enregistrement

Pour vous inscrire, appelez la méthode registerGcp. Vous avez deux options pour passer l'appel d'enregistrement :

Option 1 : Appels d'API directs Vous effectuez des requêtes brutes directement aux points de terminaison de l'API, généralement via HTTP(S). Vous gérez manuellement des aspects tels que la création du corps de la requête, la définition des en-têtes (y compris l'authentification) et l'analyse de la réponse.
Option 2 : Bibliothèques clientes Vous utilisez les bibliothèques prédéfinies qui offrent un moyen plus pratique et idiomatique d'interagir avec l'API Merchant. Ils gèrent l'authentification et l'autorisation, et offrent un moyen pratique d'abstraire la communication HTTP sous-jacente. Des exemples de code officiels sont disponibles pour vous aider à démarrer rapidement.

Autorisation pour l'appel d'enregistrement

Comme décrit dans l'étape Autoriser les requêtes envoyées à l'API Merchant, vous avez le choix entre deux scénarios d'authentification distincts :

OAuth 2.0 : pour les fournisseurs ou agences tiers qui gèrent plusieurs comptes marchands
Comptes de service : pour accéder à votre propre compte Merchant Center

Pour en savoir plus sur l'autorisation de l'appel d'enregistrement, consultez Comment effectuer l'authentification et l'autorisation pour l'appel d'enregistrement ?

Appel d'inscription

Dans les exemples suivants, vous effectuez l'appel d'enregistrement à l'aide d'appels d'API directs ou de bibliothèques clientes.

Vous effectuez l'appel d'enregistrement à l'aide de la méthode registerGcp.

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

{
  "developerEmail": "{DEVELOPER_EMAIL}"
}

Remplacez les éléments suivants :

ACCOUNT_ID : votre ID Merchant Center
ACCESS_TOKEN : jeton d'autorisation pour effectuer l'appel d'API
DEVELOPER_EMAIL : adresse e-mail du contact technique principal

Un appel réussi renvoie une ressource DeveloperRegistration, confirmant que l'association a bien été effectuée :

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

Python

Téléchargez les exemples et suivez les instructions des exemples Python de l'API Google Merchant pour configurer les bibliothèques clientes Python.

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

Téléchargez les exemples et suivez les instructions de la page Exemples Java de l'API Google Merchant pour configurer les bibliothèques clientes Java.

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

Téléchargez les exemples et suivez les instructions des exemples PHP de l'API Google Merchant pour configurer les bibliothèques clientes PHP.

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

Bonnes pratiques après l'inscription

Pour bénéficier d'une gestion des accès robuste et éviter de futures interruptions de service, nous vous recommandons de suivre un ensemble de bonnes pratiques une fois l'enregistrement initial terminé :

Accorder des autorisations supplémentaires au développeur de l'API

Lorsque vous enregistrez un contact de développeur, le rôle API_DEVELOPER lui est automatiquement attribué. Ce rôle n'inclut pas les autres autorisations nécessaires pour gérer le compte Merchant Center ou effectuer tous les appels d'API. Nous vous recommandons d'ajouter les rôles ADMIN ou STANDARD à vos développeurs pour leur fournir un accès complet.

Pour modifier les droits d'accès d'un utilisateur, utilisez la méthode accounts.users.patch. Vous spécifiez les droits d'accès dans le champ updateMask du corps de la requête pour ajouter ou supprimer des rôles :

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

Ajouter d'autres contacts de développeur

Pour éviter toute interruption de l'activité si le contact principal du développeur quitte l'entreprise ou perd l'accès, il est essentiel d'avoir des contacts redondants. Nous vous recommandons d'avoir au moins un utilisateur supplémentaire avec le rôle API_DEVELOPER dans Merchant Center pour servir de sauvegarde.

Vous pouvez ajouter un utilisateur ou en modifier un existant à l'aide du service accounts.users dans l'API Merchant ou de la page Accès et services dans l'UI Merchant Center. En ajoutant de manière proactive des développeurs de sauvegarde, vous créez une intégration plus résiliente qui ne dépend pas d'une seule personne.

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

Set up authentication

Insert your first product

S'inscrire comme développeur Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Prérequis

S'inscrire en tant que développeur avec l'API Merchant

Avantages de l'inscription

Remarques importantes

Appeler l'enregistrement

Autorisation pour l'appel d'enregistrement

Appel d'inscription

Python

Java

PHP

cURL

Bonnes pratiques après l'inscription

Accorder des autorisations supplémentaires au développeur de l'API

Python

Java

PHP

cURL

Ajouter d'autres contacts de développeur

Python

Java

PHP

cURL

S'inscrire comme développeur