Créer des comptes

Vous pouvez utiliser l'API Merchant pour créer des comptes Merchant Center, qui peuvent être associés à un compte avancé à l'aide de accountAggregation, accountManagement ou comparisonShopping. La méthode accounts.createAndConfigure vous permet de créer un compte et, éventuellement, de le configurer avec des utilisateurs et de l'associer à d'autres comptes via des services.

Ce guide explique comment utiliser l'API Merchant pour créer des comptes à l'aide de services tels que accountManagement, comparisonShopping ou accountAggregation. Lorsque vous utilisez accounts.createAndConfigure, vous devez associer le nouveau compte à un fournisseur en spécifiant au moins l'un des champs accountAggregation, accountManagement ou comparisonShopping dans le champ service. Vous pouvez spécifier accountAggregation et comparisonShopping dans la même requête, mais accountManagement ne peut pas être combiné avec accountAggregation ni comparisonShopping. Si vous spécifiez accountManagement, vous devez également ajouter au moins un utilisateur au nouveau compte à l'aide du champ user ou users.

Prérequis

Avant de pouvoir créer des comptes à l'aide de l'API Merchant, assurez-vous de remplir les conditions suivantes en fonction des services que vous utilisez :

• Accès administrateur : vous devez disposer d'un accès administrateur au compte du fournisseur lorsque vous associez un nouveau compte à l'aide de accountManagement, comparisonShopping ou accountAggregation.
• Compte avancé : si vous utilisez accountAggregation, votre compte de fournisseur doit être un compte avancé configuré pour l'agrégation de comptes. Si vous êtes un fournisseur de services et que vous devez configurer un compte avancé, contactez l'assistance pour obtenir de l'aide.

Créer un compte (à l'aide de la gestion de compte ou de la comparaison de prix)

Pour créer un compte, appelez accounts.createAndConfigure. Il s'agit de l'approche recommandée pour les partenaires qui aident les marchands à gérer leurs comptes, car elle permet aux marchands de conserver le contrôle total et la propriété de leur compte tout en accordant des autorisations spécifiques aux partenaires.

Dans le corps de la requête :

1. Indiquez les détails du compte que vous souhaitez créer dans le champ account.
2. Si vous utilisez accountManagement, spécifiez au moins un utilisateur dans le champ user qui aura accès au compte.
3. Dans le champ service, spécifiez les services que vous souhaitez fournir à ce compte (par exemple, accountManagement) et définissez provider sur le nom de ressource de votre compte (par exemple, providers/{YOUR_ACCOUNT_ID}). Consultez Gérer les relations entre les comptes pour obtenir la liste des services disponibles, tels que productsManagement ou campaignsManagement.

Voici un exemple de demande de création d'un compte nommé "merchantStore" et d'association à {YOUR_ACCOUNT_ID} pour la gestion des comptes et des produits :

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

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

Si l'appel réussit, le nouveau compte est créé et associé à votre compte pour les services spécifiés. Si vous spécifiez les services accountManagement, accountAggregation ou comparisonShopping lors de la création, ils sont automatiquement approuvés et l'état de l'association est ESTABLISHED. D'autres liens de service peuvent être à l'état PENDING jusqu'à ce qu'ils soient acceptés par le compte créé. Le corps de la réponse contient la ressource Account nouvellement créée.

Après avoir créé un tel compte, vous devez l'intégrer en effectuant des étapes telles que l'acceptation des conditions d'utilisation, la configuration des informations sur l'entreprise et la validation du site Web.

Supprimer la validation de l'adresse e-mail lors de la création d'un compte

Lorsque vous créez un compte avec accounts.createAndConfigure, vous pouvez éventuellement supprimer les e-mails de validation pour les nouveaux utilisateurs ajoutés à l'aide du champ user en définissant verificationMailSettings.verificationMailMode sur SUPPRESS_VERIFICATION_MAIL dans la demande pour cet utilisateur. Cela peut être utile si vous prévoyez de valider les utilisateurs pour le compte du marchand immédiatement après leur création à l'aide de la méthode users.verifySelf. Par défaut, verificationMailMode est défini sur SEND_VERIFICATION_MAIL et des e-mails de validation sont envoyés aux nouveaux utilisateurs ajoutés lors de la création du compte.

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

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

Si vous définissez verificationMailMode sur SUPPRESS_VERIFICATION_MAIL, vous devez appeler users.verifySelf pour chaque utilisateur ajouté lors de la création afin de terminer la validation. Cet appel doit être authentifié en tant qu'utilisateur à valider (l'utilisateur spécifié dans userId), par exemple à l'aide d'un jeton OAuth de l'utilisateur.

Spécifier un alias lors de la création d'un compte

Vous pouvez spécifier un alias pour un compte dans le contexte d'un fournisseur dans CreateAndConfigureAccountRequest à l'aide du champ setAlias. L'alias peut être utilisé pour identifier le compte dans votre système. Si vous êtes un fournisseur de services, vous pouvez utiliser l'alias pour récupérer le compte à l'aide de GET /accounts/v1/accounts/{provider}~{alias}. L'alias doit être unique pour un fournisseur donné. Vous devez spécifier un service avec le même fournisseur dans le champ service de la demande. Pour en savoir plus sur les exigences concernant les alias, consultez Gérer les relations entre les comptes.

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

Flux d'intégration recommandé

Si vous êtes un partenaire et que vous créez un compte au nom d'un marchand, nous vous recommandons de suivre la procédure suivante :

1. Créer un compte : appelez accounts.createAndConfigure avec vos identifiants de partenaire pour créer un compte.
   • Définissez service pour inclure l'association accountManagement à l'ID de votre fournisseur.
   • Ajoutez le marchand en tant qu'utilisateur à l'aide du champ user et définissez verificationMailSettings.verificationMailMode sur SUPPRESS_VERIFICATION_MAIL.
2. Valider l'utilisateur : avec les identifiants du marchand (par exemple, à l'aide d'un jeton OAuth), appelez users.verifySelf pour faire passer l'état de l'utilisateur de PENDING à VERIFIED.
3. Définissez le pays de l'entreprise : avec les identifiants du marchand, définissez le pays de l'entreprise en mettant à jour address.regionCode à l'aide de accounts.updateBusinessInfo. Cette étape est obligatoire avant d'accepter les conditions d'utilisation.
4. Accepter les conditions d'utilisation : avec les identifiants du marchand, acceptez les conditions d'utilisation.

Ce flux permet à un marchand d'être intégré de manière fluide à votre plate-forme sans recevoir d'e-mails d'invitation de Google.

Créer un compte client (à l'aide de l'agrégation de comptes)

Les comptes clients sont des comptes Merchant Center distincts associés à votre compte avancé à l'aide du service accountAggregation. Ils permettent une gestion centralisée tout en conservant des paramètres, des sites Web et des flux de données distincts. Vous pouvez utiliser la sous-API Merchant Accounts pour créer des comptes client.

Pour créer des comptes client, vous devez d'abord configurer un compte avancé. Vous devez être administrateur du compte pour convertir votre compte Merchant Center en compte avancé. De plus, votre compte ne doit présenter aucun problème en attente.

Pour créer un compte client, appelez accounts.createAndConfigure. Dans le corps de la requête :

1. Indiquez les détails du compte que vous souhaitez créer dans le champ account.
2. Vous pouvez éventuellement spécifier de nouveaux utilisateurs autorisés dans le champ user. L'accès utilisateur au compte est également hérité du compte avancé parent.
3. Dans le champ service, spécifiez accountAggregation et définissez provider sur le nom de ressource de votre compte avancé (par exemple, providers/{ADVANCED_ACCOUNT_ID}). Cela définit votre compte avancé comme agrégateur du nouveau compte.

Voici un exemple de requête permettant de créer un compte client nommé "merchantStore" associé au compte avancé {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}"
    }
  ]
}

Si l'appel aboutit, le nouveau compte client est créé et associé au compte avancé que vous avez spécifié. Le corps de la réponse contient la ressource Account nouvellement créée.

Les exemples suivants montrent comment utiliser accounts.createAndConfigure pour créer un compte client.

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

Récupérer des comptes client

Pour lister tous les comptes clients d'un compte avancé donné, utilisez la méthode accounts.listSubaccounts. Indiquez l'ID de votre compte avancé dans le champ provider de l'URL de la requête.

Voici un exemple de requête :

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

Voici un exemple de réponse à un appel réussi :

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

Remarque : La requête accounts.get, lorsqu'elle est utilisée pour récupérer des informations sur un compte client, n'inclut pas d'informations sur le compte avancé parent.

Les exemples suivants montrent comment lister tous les comptes client de votre compte avancé.

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

Supprimer un compte client

Si vous n'avez plus besoin de gérer un compte client, vous pouvez le supprimer à l'aide de la méthode accounts.delete.

Pour exécuter cette méthode, vous devez disposer d'un accès administrateur au compte à supprimer.

Voici un exemple de requête :

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

Si la requête aboutit, le corps de la réponse est un objet JSON vide, indiquant que le compte a été supprimé.

Les exemples suivants montrent comment supprimer un compte client.

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

Accepter les conditions d'utilisation

Les comptes clients héritent des Conditions d'utilisation de Merchant Center signées par le compte avancé parent.

Mettre à jour les informations sur votre établissement

Vous pouvez utiliser l'API Merchant Accounts pour modifier les informations sur l'entreprise de vos comptes clients.

• Pour afficher les informations sur l'entreprise d'un compte, appelez accounts.getBusinessInfo.
  • Pour modifier les informations sur l'entreprise d'un compte, appelez accounts.updateBusinessInfo.