La API de Merchant v1beta se descontinuó y se dio de baja el 28 de febrero de 2026. Para conocer los pasos para realizar la transición a la versión estable más reciente, consulta Migra de v1beta a v1.

Registrarse como desarrollador

El registro como desarrollador es un proceso de configuración obligatorio y único que vincula tu proyecto de Google Cloud a tu cuenta de Merchant Center y registra tu información de contacto de desarrollador con Google. Esto permite que Google envíe anuncios de servicio importantes y actualizaciones obligatorias a los contactos técnicos pertinentes que proporciones.

Este documento forma parte de una serie de varias partes sobre cómo comenzar a usar la API de Merchant. Si ya te registraste en la API de Merchant, puedes pasar a la siguiente sección: Inserta tu primer producto

Requisitos previos

Antes de registrarte para usar la API de Merchant, asegúrate de cumplir con los siguientes requisitos:

Cuenta de Merchant Center: Necesitas una cuenta de Merchant Center existente.
Acceso de administrador a la cuenta de Merchant Center: La cuenta de servicio o el correo electrónico que usas para autorizar la llamada de registro deben tener el tipo de acceso ADMIN en la cuenta de Merchant Center en la que te registras. Para obtener más información, consulta Autoriza solicitudes a la API de Merchant.
ID del proyecto de Google Cloud: Tu aplicación debe estar asociada a un proyecto de Google Cloud dedicado para proporcionar credenciales de autenticación. Para obtener detalles sobre dónde encontrar el ID del proyecto, consulta Cómo encontrar el nombre, el número y el ID del proyecto.
Una dirección de correo electrónico válida asociada a una Cuenta de Google que proporciones como punto de contacto del desarrollador para recibir actualizaciones de Google No debe ser el correo electrónico de una cuenta de servicio. Puedes usar una dirección de correo electrónico que ya forme parte de la cuenta de Merchant Center o una nueva.

Regístrate como desarrollador con la API de Merchant

Para usar la API de Merchant, debes registrar tu información de contacto del desarrollador y tu proyecto de Google Cloud en tu cuenta de Merchant Center a través del método registerGcp.

Ya sea que trabajes con varias cuentas de comerciante o no, debes realizar la operación de registro una vez para cada proyecto de Google Cloud que planees usar. Si trabajas con varios proyectos de Google Cloud, puedes registrar todos o cualquiera de ellos en la misma cuenta de Merchant Center.

Beneficios del registro

El registro proporciona los siguientes beneficios:

Creación de contacto técnico: Crea un contacto técnico en Merchant Center. Google envía actualizaciones importantes específicas de la API al contacto técnico, como anuncios de servicio y novedades.
Administración de varias cuentas de comerciante: Te permite representar al punto de contacto del desarrollador para todas las cuentas de comerciante que administras.

A excepción del registro, se bloquean todas las llamadas a la API de Merchant desde un proyecto de Google Cloud no registrado, y se devuelve un código de error 401 con el estado UNAUTHENTICATED y el siguiente mensaje de error:

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.

Consideraciones importantes

Configuración única para cada proyecto de Google Cloud: El registro es una configuración única para cada proyecto de Google Cloud y se aplica a todos los usuarios y cuentas de servicio dentro del proyecto de Google Cloud. Asegúrate de que la API de Merchant esté habilitada en tu proyecto de Google Cloud.
Cada proyecto de Google Cloud solo se puede registrar en una sola cuenta de Merchant Center en un momento determinado: Si intentas registrar un proyecto de Google Cloud en varias cuentas de Merchant Center de forma simultánea, recibirás un error ALREADY_REGISTERED. Usa la misma dirección de correo electrónico del desarrollador para el registro. Ten en cuenta que se pueden registrar varios proyectos de Google Cloud en la misma cuenta de Merchant Center.
Designa la cuenta correcta para los terceros que administran varios comercios: Los terceros que representan o administran varios comercios deben usar la estructura de cuenta adecuada dentro del ecosistema de Google. El ID correcto que debes usar depende del tipo de empresa:
- Mercados con una cuenta avanzada existente: Si tu empresa opera como mercado y ya tiene una cuenta avanzada que representa a toda la plataforma, debes usar este ID de cuenta existente.
- Servicios de comparación de productos (CSS): Si eres un CSS, debes usar tu ID de cuenta de CSS único o el ID de cuenta del grupo de CSS.
- Agencias, desarrolladores y otros terceros: Si eres una empresa externa, como una agencia o un desarrollador externo, que administra varias cuentas de comerciante y no tiene un solo ID de Merchant Center que represente a tu empresa, debes crear una cuenta principal nueva de Merchant Center y solicitar que se convierta en una cuenta avanzada. Las cuentas avanzadas pueden administrar subcuentas y proporcionar la estructura necesaria para las operaciones de terceros.
Realiza el registro solo para tu cuenta principal de Merchant Center: Realizas el registro de desarrollador solo con tu cuenta principal de Merchant Center y te conviertes en el contacto del desarrollador para todas las subcuentas vinculadas de Merchant Center. No registres cada una de tus cuentas secundarias de Merchant Center.

Texto alternativo para la accesibilidad

En el diagrama anterior, se muestra la configuración del registro cuando se usan varios proyectos de Google Cloud y una cuenta principal de Merchant Center con varias subcuentas de Merchant Center opcionales.

Una vez que registres una dirección de correo electrónico del desarrollador, haz lo siguiente:
- Puedes realizar llamadas a la API de Merchant en un plazo de 5 minutos después del registro.
- Si el correo electrónico pertenece a un usuario existente de Merchant Center, se le otorga el rol de API_DEVELOPER. De lo contrario, se creará un usuario nuevo en Merchant Center, y este deberá aceptar la invitación en un plazo de 14 días para evitar que venza y tener que reiniciar el proceso de registro. Solo completas el proceso de registro después de que el usuario hace clic en el vínculo de invitación.

Realiza la llamada de registro

Para registrarte, llama al método registerGcp. Tienes dos opciones para hacer la llamada de registro:

Opción 1: Llamadas directas a la API Realizas solicitudes sin procesar directamente a los extremos de la API, por lo general, a través de HTTP(S). Controlas manualmente aspectos como la formación del cuerpo de la solicitud, la configuración de encabezados (incluida la autenticación) y el análisis de la respuesta.
Opción 2: Bibliotecas cliente: Usas las bibliotecas prediseñadas que ofrecen una forma más conveniente y idiomática de interactuar con la API de Merchant. Manejan la autenticación y la autorización, y ofrecen una forma conveniente de abstraer la comunicación HTTP subyacente. Hay muestras de código oficiales disponibles para que comiences rápidamente.

Autorización para la llamada de registro

Como se describe en el paso Autoriza solicitudes a la API de Merchant, tienes dos situaciones de autenticación distintas:

OAuth 2.0: Para proveedores externos o agencias que administran varias cuentas de comerciante
Cuentas de servicio: Para acceder a tu propia cuenta de Merchant Center

Para obtener más información sobre la autorización de la llamada de registro, consulta ¿Cómo realizo la autenticación y la autorización para la llamada de registro?

Llamada de registro

En los siguientes ejemplos, realizarás la llamada de registro con llamadas directas a la API o bibliotecas cliente.

Realizas la llamada de registro con el método registerGcp.

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

{
  "developerEmail": "{DEVELOPER_EMAIL}"
}

Reemplaza lo siguiente:

ACCOUNT_ID: Tu ID de Merchant Center
ACCESS_TOKEN: Es el token de autorización para realizar la llamada a la API.
DEVELOPER_EMAIL: La dirección de correo electrónico del contacto técnico principal

Una llamada correcta devuelve un recurso DeveloperRegistration, lo que confirma el estado de vinculación correcto:

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

Python

Descarga las muestras y sigue las instrucciones de las muestras de Python de la API de Google Merchant para configurar las bibliotecas cliente de 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

Descarga las muestras y sigue las instrucciones de las muestras de Java de la API de Google Merchant para configurar las bibliotecas cliente de 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

Descarga las muestras y sigue las instrucciones de las muestras de la API de Google Merchant en PHP para configurar las bibliotecas cliente de 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}"
}'

Prácticas recomendadas después del registro

Para beneficiarte de una administración de acceso sólida y evitar futuras interrupciones del servicio, te recomendamos que sigas un conjunto de prácticas recomendadas después de completar el registro inicial:

Otorga permisos adicionales al desarrollador de la API

Cuando registras un contacto de desarrollador, se le asigna automáticamente el rol de API_DEVELOPER. Este rol no incluye otros permisos necesarios para administrar la cuenta de Merchant Center o realizar todas las llamadas a la API. Te recomendamos que agregues los roles ADMIN o STANDARD a tus desarrolladores para brindarles acceso integral.

Para modificar los derechos de acceso de un usuario, usa el método accounts.users.patch. Especifica los derechos de acceso en el campo updateMask del cuerpo de la solicitud para agregar o quitar roles:

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

Agrega más contactos de desarrolladores

Para evitar interrupciones en la empresa si el contacto principal del desarrollador se va o pierde el acceso, es fundamental tener contactos redundantes. Te recomendamos que tengas al menos un usuario adicional con el rol de API_DEVELOPER en Merchant Center para que actúe como respaldo.

Puedes agregar un usuario o actualizar uno existente con el servicio accounts.users en la API de Merchant Center o en la página Acceso y servicios en la IU de Merchant Center. Si agregas desarrolladores de respaldo de forma proactiva, crearás una integración más resiliente que no dependa de una sola persona.

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

Registrarse como desarrollador Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

Requisitos previos

Regístrate como desarrollador con la API de Merchant

Beneficios del registro

Consideraciones importantes

Realiza la llamada de registro

Autorización para la llamada de registro

Llamada de registro

Python

Java

PHP

cURL

Prácticas recomendadas después del registro

Otorga permisos adicionales al desarrollador de la API

Python

Java

PHP

cURL

Agrega más contactos de desarrolladores

Python

Java

PHP

cURL

Registrarse como desarrollador