Criar contas

É possível usar a API Merchant para criar contas do Merchant Center, que podem ser vinculadas a uma conta avançada usando accountAggregation, accountManagement ou comparisonShopping. O accounts.createAndConfigure método permite criar uma conta e, opcionalmente, configurá-la com usuários e vinculá-la a outras contas por meio de serviços.

Este guia explica como usar a API Merchant para criar contas usando serviços como accountManagement, comparisonShopping ou accountAggregation. Ao usar accounts.createAndConfigure, é necessário vincular a nova conta a um provedor especificando pelo menos um dos serviços accountAggregation, accountManagement ou comparisonShopping no campo service. É possível especificar accountAggregation e comparisonShopping na mesma solicitação, mas accountManagement não pode ser combinado com accountAggregation ou comparisonShopping. Se você especificar accountManagement, também será necessário adicionar pelo menos um usuário à nova conta usando o user ou users campo.

Pré-requisitos

Antes de criar contas usando a API Merchant, verifique se você atende aos seguintes requisitos, dependendo dos serviços usados:

  • Acesso de administrador: é necessário ter acesso de administrador à conta do provedor ao vincular uma nova conta usando accountManagement, comparisonShopping ou accountAggregation.
  • Conta avançada: se você usar accountAggregation, a conta do provedor precisará ser uma conta avançada configurada para agregação de contas. Se você for um provedor de serviços e precisar configurar uma conta avançada, entre em contato com o suporte para receber ajuda com a configuração.

Criar uma conta (usando o gerenciamento de contas ou a comparação de preços)

Para criar uma nova conta, chame accounts.createAndConfigure. Essa é a abordagem recomendada para parceiros que ajudam os comerciantes a gerenciar as contas, porque permite que eles mantenham o controle total e a propriedade da conta, concedendo permissões específicas aos parceiros.

No corpo da solicitação:

  1. Forneça os detalhes da conta que você quer criar no account campo.
  2. No campo accountName, não use pontuação repetida e desnecessária, letras maiúsculas, sublinhados, letras maiúsculas, emojis ou símbolos não alfanuméricos como / ou _. Evite sufixos comerciais (como "Inc." ou "Ltda"), texto promocional, informações pessoais ou linguagem inadequada. Use um nome curto, claro e profissional. Para mais informações, consulte Adicionar o nome de uma empresa.
  3. Se você estiver usando accountManagement, especifique pelo menos um usuário no user campo que terá acesso à conta.
  4. No service campo, especifique os serviços que você quer fornecer a essa conta, por exemplo, accountManagement, e defina o provider como o nome do recurso da sua conta (por exemplo, providers/{YOUR_ACCOUNT_ID}). Para uma lista de serviços disponíveis, como productsManagement ou campaignsManagement, consulte Gerenciar relações de contas.

Confira um exemplo de solicitação para criar uma conta chamada "merchantStore" e vinculá-la à conta {YOUR_ACCOUNT_ID} para gerenciamento de contas e produtos:

POST https://merchantapi.googleapis.com/accounts/v1/accounts:createAndConfigure

{
  "account": {
    "accountName": "merchantStore",
    "adultContent": false,
    "timeZone": {
      "id": "America/New_York"
    },
    "languageCode": "en-US"
  },
  "user": [
    {
      "userId": "test@example.com",
      "user": {
        "accessRights": ["ADMIN"]
      }
    }
  ],
  "service": [
    {
      "accountManagement": {},
      "provider": "providers/{YOUR_ACCOUNT_ID}"
    },
    {
      "productsManagement": {},
      "provider": "providers/{YOUR_ACCOUNT_ID}"
    }
  ]
}

Uma chamada bem-sucedida cria a nova conta e a vincula à sua para os serviços especificados. Se você especificar os serviços accountManagement, accountAggregation ou comparisonShopping durante a criação, eles serão aprovados automaticamente, e o estado do link será ESTABLISHED. Outros links de serviço podem estar no estado PENDING até serem aceitos pela conta criada. O corpo da resposta contém o recurso Account recém-criado.

Depois de criar uma conta, é necessário fazer a integração dela seguindo etapas como aceitar os Termos de Serviço, configurar informações comerciais, e verificar o site.

Suprimir a verificação de e-mail durante a criação da conta

Ao criar uma conta com accounts.createAndConfigure, você pode suprimir os e-mails de verificação para novos usuários adicionados usando o campo user, definindo verificationMailSettings.verificationMailMode como SUPPRESS_VERIFICATION_MAIL na solicitação para esse usuário. Isso é útil se você pretende verificar os usuários em nome do comerciante imediatamente após a criação usando o users.verifySelf método. Por padrão, verificationMailMode é SEND_VERIFICATION_MAIL, e os e-mails de verificação são enviados aos novos usuários adicionados durante a criação da conta.

POST https://merchantapi.googleapis.com/accounts/v1/accounts:createAndConfigure

{
  "account": {
    "accountName": "merchantStore",
    "adultContent": false,
    "timeZone": {
      "id": "America/New_York"
    },
    "languageCode": "en-US"
  },
  "user": [
    {
      "userId": "test@example.com",
      "user": {
        "accessRights": ["ADMIN"]
      },
      "verificationMailSettings": {
        "verificationMailMode": "SUPPRESS_VERIFICATION_MAIL"
      }
    }
  ],
  "service": [
    {
      "accountManagement": {},
      "provider": "providers/{YOUR_ACCOUNT_ID}"
    }
  ]
}

Se você definir verificationMailMode como SUPPRESS_VERIFICATION_MAIL, será necessário chamar users.verifySelf para cada usuário adicionado durante a criação para concluir a verificação. Essa chamada precisa ser autenticada como o usuário que está sendo verificado (o usuário especificado em userId), por exemplo, usando um token OAuth do usuário.

Especificar um alias durante a criação da conta

É possível especificar um alias para uma conta no contexto de um provedor em CreateAndConfigureAccountRequest usando o campo setAlias. O alias pode ser usado para identificar a conta no seu sistema. Se você for um provedor de serviços, poderá usar o alias para recuperar a conta usando GET /accounts/v1/accounts/{provider}~{alias}. O alias precisa ser exclusivo para um determinado provedor, e você precisa especificar um serviço com o mesmo provedor no campo service da solicitação. Para mais informações sobre os requisitos de alias, consulte Gerenciar relações de contas.

POST https://merchantapi.googleapis.com/accounts/v1/accounts:createAndConfigure

{
  "account": {
    "accountName": "merchantStore",
    "adultContent": false,
    "timeZone": {
      "id": "America/New_York"
    },
    "languageCode": "en-US"
  },
  "service": [
    {
      "accountManagement": {},
      "provider": "providers/{YOUR_ACCOUNT_ID}"
    }
  ],
  "setAlias": [
    {
      "provider": "providers/{YOUR_ACCOUNT_ID}",
      "accountIdAlias": "my-merchant-alias"
    }
  ]
}

Se você for um parceiro que está criando uma conta em nome de um comerciante, recomendamos o seguinte fluxo:

  1. Criar conta: chame accounts.createAndConfigure com suas credenciais de parceiro para criar uma nova conta.
    • Defina service para incluir accountManagement vinculando ao ID do provedor.
    • Adicione o comerciante como um usuário usando o campo user e defina verificationMailSettings.verificationMailMode como SUPPRESS_VERIFICATION_MAIL.
  2. Verificar usuário: com as credenciais do comerciante (por exemplo, usando um token OAuth), chame users.verifySelf para mudar o estado do usuário de PENDING para VERIFIED.
  3. Definir o país da empresa: com as credenciais do comerciante, defina o país da empresa atualizando address.regionCode usando accounts.updateBusinessInfo. Isso é necessário antes de aceitar os Termos de Serviço.
  4. Aceitar os Termos de Serviço: com as credenciais do comerciante, aceite os Termos de Serviço.

Esse fluxo permite que um comerciante seja integrado à sua plataforma sem receber e-mails de convite do Google.

Criar uma conta de cliente (usando a agregação de contas)

As contas de cliente são contas distintas do Merchant Center vinculadas à sua conta avançada usando o serviço accountAggregation, permitindo o gerenciamento centralizado, mantendo configurações, sites e feeds de dados separados. É possível usar a sub-API Merchant Accounts para criar novas contas de cliente.

Para criar contas de cliente, primeiro é necessário ter uma configuração de conta avançada. Você precisa ser um administrador da conta para converter sua conta do Merchant Center em uma conta avançada, e ela não pode ter problemas pendentes.

Para criar uma nova conta de cliente, chame accounts.createAndConfigure. No corpo da solicitação:

  1. Forneça os detalhes da conta que você quer criar no account campo.
  2. No campo accountName, não use pontuação, letras maiúsculas, sublinhados ou símbolos não alfanuméricos repetidos e desnecessários (como "/" ou "_"). Evite sufixos comerciais (como "Inc." ou "Ltda"), texto promocional, informações pessoais ou linguagem inadequada. Use um nome curto, claro e profissional. Para mais informações, consulte Adicionar o nome de uma empresa.
  3. Opcionalmente, especifique novos usuários autorizados no user campo. O acesso do usuário à conta também é herdado da conta avançada principal.
  4. No service campo, especifique accountAggregation e defina o provider como o nome do recurso da sua conta avançada (por exemplo, providers/{ADVANCED_ACCOUNT_ID}). Isso estabelece sua conta avançada como o agregador da nova conta.

Confira um exemplo de solicitação para criar uma conta de cliente chamada "merchantStore" vinculada à conta avançada {ADVANCED_ACCOUNT_ID}:

POST https://merchantapi.googleapis.com/accounts/v1/accounts:createAndConfigure

{
  "account": {
    "accountName": "merchantStore",
    "adultContent": false,
    "timeZone": {
      "id": "America/New_York"
    },
    "languageCode": "en-US"
  },
  "service": [
    {
      "accountAggregation": {},
      "provider": "providers/{ADVANCED_ACCOUNT_ID}"
    }
  ]
}

Uma chamada bem-sucedida cria a nova conta de cliente e a vincula à conta avançada especificada. O corpo da resposta vai conter o recurso recém-criado Account.

Os exemplos a seguir demonstram como usar o accounts.createAndConfigure para criar uma nova conta de cliente.

Java

import com.google.api.gax.core.FixedCredentialsProvider;
import com.google.auth.oauth2.GoogleCredentials;
import com.google.shopping.merchant.accounts.v1.Account;
import com.google.shopping.merchant.accounts.v1.AccountAggregation;
import com.google.shopping.merchant.accounts.v1.AccountsServiceClient;
import com.google.shopping.merchant.accounts.v1.AccountsServiceSettings;
import com.google.shopping.merchant.accounts.v1.CreateAndConfigureAccountRequest;
import com.google.shopping.merchant.accounts.v1.CreateAndConfigureAccountRequest.AddAccountService;
import com.google.type.TimeZone;
import shopping.merchant.samples.utils.Authenticator;
import shopping.merchant.samples.utils.Config;

/** This class demonstrates how to create a sub-account under an advanced account. */
public class CreateSubAccountSample {

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

  public static void createSubAccount(Config config) throws Exception {

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

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

    // Creates parent/provider to identify the advanced account into which to insert the subaccount.
    String parent = getParent(config.getAccountId().toString());

    // Calls the API and catches and prints any network failures/errors.
    try (AccountsServiceClient accountsServiceClient =
        AccountsServiceClient.create(accountsServiceSettings)) {

      CreateAndConfigureAccountRequest request =
          CreateAndConfigureAccountRequest.newBuilder()
              .setAccount(
                  Account.newBuilder()
                      .setAccountName("Demo Business")
                      .setAdultContent(false)
                      .setTimeZone(TimeZone.newBuilder().setId("America/New_York").build())
                      .setLanguageCode("en-US")
                      .build())
              .addService(
                  AddAccountService.newBuilder()
                      .setProvider(parent)
                      .setAccountAggregation(AccountAggregation.getDefaultInstance())
                      .build())
              .build();

      System.out.println("Sending Create SubAccount request");
      Account response = accountsServiceClient.createAndConfigureAccount(request);
      System.out.println("Inserted Account Name below");
      // Format: `accounts/{account}
      System.out.println(response.getName());
    } catch (Exception e) {
      System.out.println(e);
    }
  }

  public static void main(String[] args) throws Exception {
    Config config = Config.load();

    createSubAccount(config);
  }
}
CreateSubAccountSample.java

PHP

use Google\ApiCore\ApiException;
use Google\Shopping\Merchant\Accounts\V1\Account;
use Google\Shopping\Merchant\Accounts\V1\AccountAggregation;
use Google\Shopping\Merchant\Accounts\V1\Client\AccountsServiceClient;
use Google\Shopping\Merchant\Accounts\V1\CreateAndConfigureAccountRequest;
use Google\Shopping\Merchant\Accounts\V1\CreateAndConfigureAccountRequest\AddAccountService;
use Google\Type\TimeZone;

/**
 * This class demonstrates how to create a sub-account under an MCA account.
 */
class CreateSubAccount
{

    private static function getParent(string $accountId): string
    {
        return sprintf("accounts/%s", $accountId);
    }


    public static function createSubAccount(array $config): 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.
        $accountsServiceClient = new AccountsServiceClient($options);

        // Creates parent/provider to identify the MCA account into which to insert the subaccount.
        $parent = self::getParent($config['accountId']);

        // Calls the API and catches and prints any network failures/errors.
        try {
            $request = new CreateAndConfigureAccountRequest([
                'account' => (new Account([
                    'account_name' => 'Demo Business',
                    'adult_content' => false,
                    'time_zone' => (new TimeZone(['id' => 'America/New_York'])),
                    'language_code' => 'en-US',
                ])),
                'service' => [
                    (new AddAccountService([
                        'provider' => $parent,
                        'account_aggregation' => new AccountAggregation,
                    ])),
                ],
            ]);

            print "Sending Create SubAccount request\n";
            $response = $accountsServiceClient->createAndConfigureAccount($request);
            print "Inserted Account Name below\n";
            // Format: `accounts/{account}
            print $response->getName() . PHP_EOL;
        } catch (ApiException $e) {
            print $e->getMessage();
        }
    }
    public function callSample(): void
    {
        $config = Config::generateConfig();
        self::createSubAccount($config);
    }
}

$sample = new CreateSubAccount();
$sample->callSample();
CreateSubAccountSample.php

Python

from examples.authentication import configuration
from examples.authentication import generate_user_credentials
from google.shopping.merchant_accounts_v1 import Account
from google.shopping.merchant_accounts_v1 import AccountAggregation
from google.shopping.merchant_accounts_v1 import AccountsServiceClient
from google.shopping.merchant_accounts_v1 import CreateAndConfigureAccountRequest

_ACCOUNT = configuration.Configuration().read_merchant_info()


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


def create_sub_account():
  """Creates a sub-account under an advanced account."""

  # Get OAuth credentials.
  credentials = generate_user_credentials.main()

  # Create a client.
  client = AccountsServiceClient(credentials=credentials)

  # Get the parent advanced account ID.
  parent = get_parent(_ACCOUNT)

  # Create the request.
  request = CreateAndConfigureAccountRequest(
      account=Account(
          account_name="Demo Business",
          adult_content=False,
          time_zone={"id": "America/New_York"},
          language_code="en-US",
      ),
      service=[
          CreateAndConfigureAccountRequest.AddAccountService(
              provider=parent,
              account_aggregation=AccountAggregation(),
          )
      ],
  )

  # Make the request and print the response.
  try:
    print("Sending Create SubAccount request")
    response = client.create_and_configure_account(request=request)
    print("Inserted Account Name below")
    print(response.name)
  except RuntimeError as e:
    print(e)


if __name__ == "__main__":
  create_sub_account()

create_sub_account_sample.py

cURL

curl -X POST \
"https://merchantapi.googleapis.com/accounts/v1/accounts:createAndConfigure" \
-H "Authorization: Bearer {YOUR_ACCESS_TOKEN}" \
-H "Content-Type: application/json" \
-d '{
  "account": {
    "accountName": "Demo Business",
    "adultContent": false,
    "timeZone": {
      "id": "America/New_York"
    },
    "languageCode": "en-US"
  },
  "service": [
    {
      "accountAggregation": {},
      "provider": "providers/{ADVANCED_ACCOUNT_ID}"
    }
  ]
}'

Recuperar contas de cliente

Para listar todas as contas de cliente de uma determinada conta avançada, use o accounts.listSubaccounts método. Forneça o ID da sua conta avançada no campo provider do URL da solicitação.

Confira um exemplo de solicitação:

GET https://merchantapi.googleapis.com/accounts/v1/accounts/{ADVANCED_ACCOUNT_ID}:listSubaccounts

Confira um exemplo de resposta de uma chamada bem-sucedida:

{
"accounts": [
    {
      "name": "accounts/<var class=\"readonly\">{SUB_ACCOUNT_ID_1}</var>",
      "accountId": "<var class=\"readonly\">{SUB_ACCOUNT_ID_1}</var>",
      "accountName": "<var class=\"readonly\">{SUB_ACCOUNT_NAME_1}</var>",
      "timeZone": {
        "id": "America/Los_Angeles"
      },
      "languageCode": "en-US"
    },
    {
      "name": "accounts/<var class=\"readonly\">{SUB_ACCOUNT_ID_2}</var>",
      "accountId": "<var class=\"readonly\">{SUB_ACCOUNT_ID_2}</var>",
      "accountName": "<var class=\"readonly\">{SUB_ACCOUNT_NAME_2}</var>",
      "timeZone": {
        "id": "America/Los_Angeles"
      },
      "languageCode": "en-US"
    }
  ]
}

Os exemplos a seguir demonstram como listar todas as contas de cliente da sua conta avançada.

Java

import com.google.api.gax.core.FixedCredentialsProvider;
import com.google.auth.oauth2.GoogleCredentials;
import com.google.shopping.merchant.accounts.v1.Account;
import com.google.shopping.merchant.accounts.v1.AccountsServiceClient;
import com.google.shopping.merchant.accounts.v1.AccountsServiceClient.ListSubAccountsPagedResponse;
import com.google.shopping.merchant.accounts.v1.AccountsServiceSettings;
import com.google.shopping.merchant.accounts.v1.ListSubAccountsRequest;
import shopping.merchant.samples.utils.Authenticator;
import shopping.merchant.samples.utils.Config;

/** This class demonstrates how to list all the subaccounts of an advanced account. */
public class ListSubAccountsSample {

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

  public static void listSubAccounts(Config config) throws Exception {

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

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

    // Creates parent/provider to identify the advanced account from which to list all sub-accounts.
    String parent = getParent(config.getAccountId().toString());

    // Calls the API and catches and prints any network failures/errors.
    try (AccountsServiceClient accountsServiceClient =
        AccountsServiceClient.create(accountsServiceSettings)) {

      // The parent has the format: accounts/{account}
      ListSubAccountsRequest request =
          ListSubAccountsRequest.newBuilder().setProvider(parent).build();
      System.out.println("Sending list subaccounts request:");

      ListSubAccountsPagedResponse response = accountsServiceClient.listSubAccounts(request);

      int count = 0;

      // Iterates over all rows in all pages and prints the datasource in each row.
      // Automatically uses the `nextPageToken` if returned to fetch all pages of data.
      for (Account account : response.iterateAll()) {
        System.out.println(account);
        count++;
      }
      System.out.print("The following count of accounts were returned: ");
      System.out.println(count);
    } catch (Exception e) {
      System.out.println("An error has occured: ");
      System.out.println(e);
    }
  }

  public static void main(String[] args) throws Exception {
    Config config = Config.load();
    listSubAccounts(config);
  }
}
ListSubAccountsSample.java

PHP

use Google\ApiCore\ApiException;
use Google\Shopping\Merchant\Accounts\V1\Client\AccountsServiceClient;
use Google\Shopping\Merchant\Accounts\V1\ListSubAccountsRequest;

/**
 * This class demonstrates how to list all the subaccounts of an advanced account.
 */
class ListSubAccounts
{
    private static function getParent(string $accountId): string
    {
        return sprintf("accounts/%s", $accountId);
    }


    public static function listSubAccounts(array $config): 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.
        $accountsServiceClient = new AccountsServiceClient($options);

        // Creates parent/provider to identify the advanced account from which
        //to list all accounts.
        $parent = self::getParent($config['accountId']);

        // Calls the API and catches and prints any network failures/errors.
        try {

            // The parent has the format: accounts/{account}
            $request = new ListSubAccountsRequest(['provider' => $parent]);
            print "Sending list subaccounts request:\n";

            $response = $accountsServiceClient->listSubAccounts($request);

            $count = 0;

            // Iterates over all rows in all pages and prints the datasource in each row.
            // Automatically uses the `nextPageToken` if returned to fetch all pages of data.
            foreach ($response->iterateAllElements() as $account) {
                print_r($account);
                $count++;
            }
            print "The following count of accounts were returned: ";
            print $count . PHP_EOL;
        } catch (ApiException $e) {
            print "An error has occured: \n";
            print $e->getMessage();
        }
    }

    public function callSample(): void
    {
        $config = Config::generateConfig();
        self::listSubAccounts($config);
    }
}

$sample = new ListSubAccounts();
$sample->callSample();
ListSubAccountsSample.php

Python

from examples.authentication import configuration
from examples.authentication import generate_user_credentials
from google.shopping.merchant_accounts_v1 import AccountsServiceClient
from google.shopping.merchant_accounts_v1 import ListSubAccountsRequest

_ACCOUNT = configuration.Configuration().read_merchant_info()


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


def list_sub_accounts():
  """Lists all the subaccounts of an advanced account."""

  # Get OAuth credentials.
  credentials = generate_user_credentials.main()

  # Create a client.
  client = AccountsServiceClient(credentials=credentials)

  # Get the parent advanced account ID.
  parent = get_parent(_ACCOUNT)

  # Create the request.
  request = ListSubAccountsRequest(provider=parent)

  # Make the request and print the response.
  try:
    print("Sending list subaccounts request:")
    response = client.list_sub_accounts(request=request)

    count = 0
    for account in response:
      print(account)
      count += 1

    print(f"The following count of accounts were returned: {count}")

  except RuntimeError as e:
    print("An error has occured: ")
    print(e)


if __name__ == "__main__":
  list_sub_accounts()

list_sub_accounts_sample.py

cURL

curl -X GET \
"https://merchantapi.googleapis.com/accounts/v1/accounts/{ADVANCED_ACCOUNT_ID}:listSubaccounts" \
-H "Authorization: Bearer {YOUR_ACCESS_TOKEN}" \

Excluir uma conta de cliente

Se você não precisar mais gerenciar uma conta de cliente, poderá excluí-la usando o accounts.delete método.

A execução desse método exige acesso de administrador à conta que está sendo excluída.

Confira um exemplo de solicitação:

DELETE https://merchantapi.googleapis.com/accounts/v1/accounts/{SUB_ACCOUNT_ID}

Se não houver nenhum problema, o corpo da resposta será um objeto JSON vazio, indicando que a conta foi excluída.

Os exemplos a seguir demonstram como excluir uma conta de cliente.

Java

import com.google.api.gax.core.FixedCredentialsProvider;
import com.google.auth.oauth2.GoogleCredentials;
import com.google.shopping.merchant.accounts.v1.AccountName;
import com.google.shopping.merchant.accounts.v1.AccountsServiceClient;
import com.google.shopping.merchant.accounts.v1.AccountsServiceSettings;
import com.google.shopping.merchant.accounts.v1.DeleteAccountRequest;
import shopping.merchant.samples.utils.Authenticator;
import shopping.merchant.samples.utils.Config;

/** This class demonstrates how to delete a given Merchant Center account. */
public class DeleteAccountSample {

  // This method can delete a standalone, advanced account or sub-account. If you delete an advanced
  // account,
  // all sub-accounts will also be deleted.
  // Admin user access is required to execute this method.

  public static void deleteAccount(Config config) throws Exception {

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

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

    // Gets the account ID from the config file.
    String accountId = config.getAccountId().toString();

    // Creates account name to identify the account.
    String name =
        AccountName.newBuilder()
            .setAccount(accountId)
            .build()
            .toString();

    // Calls the API and catches and prints any network failures/errors.
    try (AccountsServiceClient accountsServiceClient =
        AccountsServiceClient.create(accountsServiceSettings)) {
      DeleteAccountRequest request =
          DeleteAccountRequest.newBuilder()
              .setName(name)
              // Optional. If set to true, the account will be deleted even if it has offers or
              // provides services to other accounts. Defaults to 'false'.
              .setForce(true)
              .build();

      System.out.println("Sending Delete Account request");
      accountsServiceClient.deleteAccount(request); // No response returned on success.
      System.out.println("Delete successful.");
    } catch (Exception e) {
      System.out.println(e);
    }
  }

  public static void main(String[] args) throws Exception {
    Config config = Config.load();
    deleteAccount(config);
  }
}
DeleteAccountSample.java

PHP

use Google\ApiCore\ApiException;
use Google\Shopping\Merchant\Accounts\V1\Client\AccountsServiceClient;
use Google\Shopping\Merchant\Accounts\V1\DeleteAccountRequest;


/**
 * This class demonstrates how to delete a given Merchant Center account.
 */
class DeleteAccount
{
    private static function getParent(string $accountId): string
    {
        return sprintf("accounts/%s", $accountId);
    }

    // This method can delete a standalone, advanced account or sub-account.
    // If you delete an advanced account, all sub-accounts will also be deleted.
    // Admin user access is required to execute this method.
    public static function deleteAccount(array $config): 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.
        $accountsServiceClient = new AccountsServiceClient($options);


        // Gets the account ID from the config file.
        $accountId = $config['accountId'];

        // Creates account name to identify the account.
        $name = self::getParent($accountId);

        // Calls the API and catches and prints any network failures/errors.
        try {
            $request = new DeleteAccountRequest([
                'name' => $name,
                // Optional. If set to true, the account will be deleted even if it has offers or
                // provides services to other accounts. Defaults to 'false'.
                'force' => true,
            ]);

            print "Sending Delete Account request\n";
            $accountsServiceClient->deleteAccount($request); // No response returned on success.
            print "Delete successful.\n";
        } catch (ApiException $e) {
            print $e->getMessage();
        }
    }

    public function callSample(): void
    {
        $config = Config::generateConfig();
        self::deleteAccount($config);
    }
}

$sample = new DeleteAccount();
$sample->callSample();
DeleteAccountSample.php

Python

from examples.authentication import configuration
from examples.authentication import generate_user_credentials
from google.shopping.merchant_accounts_v1 import AccountsServiceClient
from google.shopping.merchant_accounts_v1 import DeleteAccountRequest

_ACCOUNT = configuration.Configuration().read_merchant_info()


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


def delete_account():
  """Deletes a given Merchant Center account."""

  # Get OAuth credentials.
  credentials = generate_user_credentials.main()

  # Create a client.
  client = AccountsServiceClient(credentials=credentials)

  # Create the account name.
  name = get_parent(_ACCOUNT)

  # Create the request.
  request = DeleteAccountRequest(name=name, force=True)

  # Make the request and print the response.
  try:
    print("Sending Delete Account request")
    client.delete_account(request=request)
    print("Delete successful.")
  except RuntimeError as e:
    print(e)


if __name__ == "__main__":
  delete_account()

delete_account_sample.py

cURL

curl -X DELETE \
"https://merchantapi.googleapis.com/accounts/v1/accounts/{SUB_ACCOUNT_ID}?force=true" \
-H "Authorization: Bearer {YOUR_ACCESS_TOKEN}" \

Aceitar os Termos de Serviço

As contas de cliente herdam os Termos de Serviço (TOS) do Merchant Center assinados pela conta avançada principal.

Atualizar suas informações comerciais

É possível usar a sub-API Accounts para editar as informações comerciais das contas de cliente.

Anterior
Overview
Avançar
Manage Terms of Service