A API Merchant v1beta foi descontinuada e desativada em 28 de fevereiro de 2026. Para saber como fazer a transição para a versão estável mais recente, consulte Migrar da v1beta para a v1.

Registrar-se como um desenvolvedor

O registro como desenvolvedor é um processo de configuração obrigatório e único que vincula seu projeto na nuvem do Google à sua conta do Merchant Center e registra suas informações de contato de desenvolvedor no Google. Isso permite que o Google envie avisos de serviço críticos e atualizações obrigatórias aos contatos técnicos relevantes que você fornecer.

Este documento faz parte de uma série sobre como começar a usar a API Merchant. Se você já se registrou na API Merchant, pule para a próxima seção: Inserir seu primeiro produto

Pré-requisitos

Antes de se registrar para usar a API Merchant, verifique se você atende aos seguintes requisitos:

Conta do Merchant Center: você precisa ter uma conta do Merchant Center.
Acesso de administrador na conta do Merchant Center: o e-mail ou a conta de serviço usada para autorizar a chamada de registro precisa ter o tipo de acesso ADMIN na conta do Merchant Center em que você está se registrando. Para mais informações, consulte Como autorizar solicitações para a API Merchant.
ID do projeto do Google Cloud: seu aplicativo precisa estar associado a um projeto dedicado do Google Cloud para fornecer credenciais de autenticação. Para detalhes sobre onde encontrar o ID do projeto, consulte Encontrar o nome, o número e o ID do projeto.
Um endereço de e-mail válido associado a uma Conta do Google que você forneceu como ponto de contato do desenvolvedor para receber atualizações do Google. Não pode ser um e-mail de conta de serviço. Você pode usar um endereço de e-mail que já faz parte da conta do Merchant Center ou um novo.

Registrar-se como desenvolvedor com a API Merchant

Para usar a API Merchant, você precisa registrar as informações de contato do desenvolvedor e o projeto do Google Cloud com sua conta do Merchant Center usando o método registerGcp.

Você realiza a operação de registro uma vez para cada projeto na nuvem do Google Cloud que pretende usar, esteja ou não trabalhando com várias contas do comerciante. Se você estiver trabalhando com vários projetos do Google Cloud, poderá registrar qualquer um ou todos na mesma conta do Merchant Center.

Benefícios do registro

O registro oferece os seguintes benefícios:

Criação de contato técnico: cria um contato técnico no Merchant Center. O Google envia atualizações importantes específicas da API para o contato técnico, como anúncios de serviço e informações sobre novos recursos.
Gerenciamento de várias contas de comerciante: permite representar o ponto de contato do desenvolvedor para todas as contas de comerciante que você gerencia.

Com exceção do registro, todas as chamadas para a API Merchant de um projeto na nuvem não registrado do Google Cloud são bloqueadas, retornando um código de erro 401 com status UNAUTHENTICATED e a seguinte mensagem de erro:

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.

Considerações importantes

Configuração única para cada projeto do Google Cloud: o registro é uma configuração única para cada projeto do Google Cloud e se aplica a todos os usuários e contas de serviço dentro do projeto. Verifique se a API Merchant está ativada no seu projeto do Google Cloud.
Cada projeto do Google Cloud só pode ser registrado em uma conta do Merchant Center por vez: se você tentar registrar um projeto do Google Cloud em várias contas do Merchant Center simultaneamente, vai receber um erro ALREADY_REGISTERED. Use o mesmo endereço de e-mail do desenvolvedor para o registro. Vários projetos do Google Cloud podem ser registrados na mesma conta do Merchant Center.
Designar a conta correta para terceiros (3Ps) que gerenciam vários comerciantes:os terceiros que representam ou gerenciam vários comerciantes precisam usar a estrutura de conta adequada no ecossistema do Google. O ID correto a ser usado depende do tipo de empresa:
- Marketplaces com uma conta avançada:se sua empresa opera como um marketplace e já tem uma conta avançada que representa toda a plataforma, use o ID dessa conta.
- Serviços de comparação de preços (CSS): se você for um CSS, use seu ID de conta exclusivo ou o ID da conta do grupo do CSS.
- Agências, desenvolvedores e outros terceiros:se você é uma empresa terceirizada, como uma agência ou um desenvolvedor terceirizado, gerencia várias contas de comerciante e não tem um único ID do Merchant Center que represente sua empresa, crie uma conta principal do Merchant Center e peça para convertê-la em uma conta avançada. As contas avançadas podem gerenciar subcontas e fornecer a estrutura necessária para operações de terceiros.
Faça o registro apenas para seu Merchant Center principal: você faz o registro de desenvolvedor usando apenas sua conta principal do Merchant Center e se torna o contato de desenvolvedor de todas as subcontas vinculadas do Merchant Center. Não faça o registro para cada uma das suas subcontas do Merchant Center.

Texto alternativo para acessibilidade

O diagrama anterior mostra a configuração de registro ao usar vários projetos do Google Cloud e uma conta principal do Merchant Center com várias subcontas opcionais do Merchant Center.

Depois de registrar um endereço de e-mail de desenvolvedor:
- É possível fazer chamadas da API Merchant em até 5 minutos após o registro.
- Se o e-mail pertencer a um usuário do Merchant Center, ele vai receber a função API_DEVELOPER. Caso contrário, um novo usuário será criado no Merchant Center, e ele precisará aceitar um convite em até 14 dias para evitar que ele expire e que seja necessário reiniciar o processo de registro. Você só conclui o processo de registro depois que o usuário clica no link do convite.

Faça a ligação de registro

Para registrar, chame o método registerGcp. Você tem duas opções para fazer a ligação de registro:

Opção 1: chamadas diretas de API Você faz solicitações brutas diretamente aos endpoints da API, geralmente por HTTP(S). Você processa manualmente aspectos como a formação do corpo da solicitação, a definição de cabeçalhos (incluindo autenticação) e a análise da resposta.
Opção 2: bibliotecas de cliente. Use as bibliotecas pré-criadas que oferecem uma maneira mais conveniente e idiomática de interagir com a API Merchant. Eles processam a autenticação e a autorização e oferecem uma maneira conveniente de abstrair a comunicação HTTP subjacente. Exemplos de código oficiais estão disponíveis para você começar rapidamente.

Autorização para a chamada de registro

Conforme descrito na etapa Autorizar solicitações para a API Merchant, você tem dois cenários de autenticação distintos:

OAuth 2.0: para provedores terceirizados ou agências que gerenciam várias contas de comerciante
Contas de serviço: para acessar sua própria conta do Merchant Center

Para mais informações sobre a autorização da chamada de registro, consulte Como realizar a autenticação e a autorização da chamada de registro?

Chamada de registro

Nos exemplos a seguir, você faz a chamada de registro usando chamadas diretas de API ou bibliotecas de cliente.

Você faz a chamada de registro usando o 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}"
}

Substitua:

ACCOUNT_ID: seu ID do Merchant Center
ACCESS_TOKEN: o token de autorização para fazer a chamada de API.
DEVELOPER_EMAIL: o endereço de e-mail do contato técnico principal.

Uma chamada bem-sucedida retorna um recurso DeveloperRegistration, confirmando o status de vinculação:

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

Python

Baixe as amostras e siga as orientações das amostras em Python da API Google Merchant para configurar as bibliotecas de cliente 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

Faça o download dos exemplos e siga as orientações em Exemplos em Java da API Google Merchant para configurar as bibliotecas de cliente 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

Faça o download das amostras e siga as orientações das amostras PHP da API Google Merchant para configurar as bibliotecas de cliente 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áticas recomendadas após o registro

Para aproveitar o gerenciamento de acesso robusto e evitar interrupções futuras no serviço, recomendamos seguir um conjunto de práticas recomendadas após concluir o registro inicial:

Conceder outras permissões ao desenvolvedor de API

Quando você registra um contato de desenvolvedor, ele recebe automaticamente a função de API_DEVELOPER. Essa função não inclui outras permissões necessárias para gerenciar a conta do Merchant Center ou fazer todas as chamadas de API. Recomendamos adicionar as funções ADMIN ou STANDARD aos seus desenvolvedores para fornecer acesso abrangente.

Para modificar os direitos de acesso de um usuário, use o método accounts.users.patch. Especifique os direitos de acesso no campo "updateMask" do corpo da solicitação para adicionar ou remover papéis:

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

Adicionar mais contatos de desenvolvedores

Para evitar interrupções nos negócios se o contato principal do desenvolvedor sair ou perder o acesso, é fundamental ter contatos redundantes. Recomendamos ter pelo menos um usuário adicional com a função API_DEVELOPER no Merchant Center para servir como backup.

É possível adicionar um usuário ou atualizar um existente com o serviço accounts.users na API Merchant ou na página Acesso e serviços na interface do Merchant Center. Ao adicionar desenvolvedores de backup de forma proativa, você cria uma integração mais resiliente que não depende de uma única pessoa.

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

Avançar

Insert your first product

Registrar-se como um desenvolvedor Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Pré-requisitos

Registrar-se como desenvolvedor com a API Merchant

Benefícios do registro

Considerações importantes

Faça a ligação de registro

Autorização para a chamada de registro

Chamada de registro

Python

Java

PHP

cURL

Práticas recomendadas após o registro

Conceder outras permissões ao desenvolvedor de API

Python

Java

PHP

cURL

Adicionar mais contatos de desenvolvedores

Python

Java

PHP

cURL

Registrar-se como um desenvolvedor