Gérer les associations de comptes

Vous pouvez utiliser l'API Accounts pour gérer les relations entre votre compte Merchant Center et d'autres fournisseurs de services. Une relation est une connexion formelle qui permet à un fournisseur de proposer des services spécifiques à votre entreprise. Un service définit les autorisations et les capacités accordées au fournisseur, telles que la gestion des produits ou des campagnes. Par exemple, associer votre compte Merchant Center à un compte Google Ads permet à ce dernier d'utiliser vos données produit pour diffuser des campagnes publicitaires.

Une relation se compose des attributs suivants :

• Compte Merchant Center recevant le service
• Le fournisseur de services
• Service ou ensemble de services fournis au compte Merchant Center

Alias

Les fournisseurs de services peuvent associer un alias aux comptes qu'ils gèrent (cela équivaut au champ seller_id qui était présent dans la ressource account de Content API for Shopping). L'alias peut être attribué à l'aide du champ facultatif account_id_alias de la ressource AccountRelationship et sert d'identifiant personnalisé. L'alias doit comporter entre 1 et 50 caractères choisis parmi les lettres ASCII, les chiffres décimaux, les tirets courts, les traits de soulignement, les points ou les tildes ([A-Za-z0-9_~.-]{1,50}).

La structure d'URL permettant d'accéder à un compte à l'aide de son alias est GET /accounts/v1/accounts/{provider}~{account_id_alias}.

Services

Dans l'API Accounts, les comptes peuvent recevoir les services suivants. Vous pouvez ajouter de nombreux services lors de la création de votre compte.

• Agrégation de comptes : ce service associe un compte avancé à un autre compte, ce qui permet au compte avancé d'y accéder de manière complète et sans restriction. Il est généralement utilisé par les places de marché, les marchands multimarques ou les marchands internationaux qui ont besoin d'un contrôle centralisé sur les comptes imbriqués. Si vous êtes une plate-forme d'e-commerce ou un partenaire de distribution, nous vous recommandons d'utiliser plutôt accountManagement. Lorsque vous créez un compte à l'aide de l'agrégation de comptes, le externalAccountId doit être omis.

• Gestion des campagnes : ce service modélise l'association entre un compte Merchant Center et un compte Google Ads, ce qui permet au compte Ads d'accéder aux données produit et de compte nécessaires pour diffuser des campagnes publicitaires. Dans ce cas, le fournisseur de services est GOOGLE_ADS et externalAccountId correspond à l'ID du compte Google Ads. Ce service peut également être proposé à un compte existant.

Remarque : Pour les marchands/ places de marché qui utilisent le réseau Commerce Media dans leurs comptes Google Ads :

• Ce service permet de créer des filtres de produits spécifiques aux partenaires lorsque vous diffusez des campagnes sur des réseaux Commerce Media.
• Pour le moment, vous devez utiliser la version alpha de la sous-API Accounts.
• L'utilisation de cette fonctionnalité nécessite une autorisation spécifique dans GMC.

Pour en savoir plus, contactez l'équipe chargée de la gestion de votre compte Google Ads.

• Comparateur de prix : représente la relation avec un service de comparateur de prix (CSS) qui gère le compte Merchant Center.

• Gestion des fiches locales : cela représente la relation avec un responsable de magasin pour gérer l'inventaire et les fiches locales à l'aide d'une fiche d'établissement Google.

• Gestion du compte : ce service permet au fournisseur d'effectuer des actions administratives sur le compte Merchant Center, comme configurer les paramètres du compte, gérer les utilisateurs ou mettre à jour les informations sur l'entreprise. L'entreprise peut également restreindre l'accès accordé. Lorsqu'il est utilisé lors de la création d'un compte, ce service crée un compte associé au fournisseur, ce qui est l'approche recommandée pour les plates-formes d'e-commerce et les partenaires de chaîne. Il peut également être proposé à un compte existant.

• Gestion des produits : ce service permet aux fournisseurs de gérer les produits et les fonctionnalités associées, comme les sources de données et les règles. Lorsqu'il est ajouté lors de la création du compte, il est généralement associé à accountManagement ou accountAggregation. Ce service peut également être proposé à un compte existant.

Poignée de mains

Pour établir un service, le compte qui le fournit et celui qui le reçoit doivent autoriser la connexion. Ce processus d'autorisation est appelé "handshake" (poignée de main).

Le handshake se déroule en deux étapes :

1. Une partie propose un lien de service.
2. L'autre partie approuve ou refuse la proposition.

Une fois la proposition acceptée, le service est approuvé et considéré comme entièrement établi. Tous les droits d'accès accordés au fournisseur de services sont désormais accordés aux utilisateurs qualifiés (voir Droits d'accès ci-dessous).

Notez que l'utilisateur qui crée une proposition, la refuse ou l'approuve doit disposer des droits d'accès ADMIN sur le compte à l'origine du processus. Ainsi, si le fournisseur de services propose un service, l'utilisateur qui fait la proposition doit être ADMIN sur le compte du fournisseur de services, et l'utilisateur qui accepte ou refuse la proposition doit être ADMIN sur le compte destinataire.

Les exemples suivants montrent comment proposer un service de compte :

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.AccountService;
import com.google.shopping.merchant.accounts.v1.AccountServicesServiceClient;
import com.google.shopping.merchant.accounts.v1.AccountServicesServiceSettings;
import com.google.shopping.merchant.accounts.v1.ProductsManagement;
import com.google.shopping.merchant.accounts.v1.ProposeAccountServiceRequest;
import shopping.merchant.samples.utils.Authenticator;

/** This class demonstrates how to propose a service to an existing Merchant Center account. */
public class ProposeServiceSample {

  public static void proposeService(long accountId, long providerId, String externalAccountId)
      throws Exception {

    // Obtains OAuth token based on the user's configuration.
    // The user that authenticates should have access to the account.
    GoogleCredentials credential = new Authenticator().authenticate();

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

    // Calls the API and catches and prints any network failures/errors.
    try (AccountServicesServiceClient accountServicesServiceClient =
        AccountServicesServiceClient.create(accountServicesServiceSettings)) {

      // The service to be proposed.
      // This sample shows how to propose product management.
      // For more information about the different services, see:
      // https://developers.google.com/merchant/api/guides/accounts/services
      AccountService accountService =
          AccountService.newBuilder()
              .setProductsManagement(ProductsManagement.newBuilder().build())
              .setExternalAccountId(externalAccountId)
              .build();

      String accountName =
          AccountName.newBuilder().setAccount(String.valueOf(accountId)).build().toString();

      ProposeAccountServiceRequest request =
          ProposeAccountServiceRequest.newBuilder()
              .setParent(accountName)
              .setProvider("accounts/" + providerId)
              .setAccountService(accountService)
              .build();

      System.out.println("Sending Propose Service request:");
      AccountService response = accountServicesServiceClient.proposeAccountService(request);

      System.out.println("Proposed Service below");
      System.out.println(response);
    } catch (Exception e) {
      System.out.println(e);
    }
  }

  public static void main(String[] args) throws Exception {
    // The ID of the account to propose the service to.
    long accountId = 123L;
    // This is the provider ID of the e-commerce platform.
    long providerId = 456L;
    // An external ID that uniquely identifies the account service.
    String externalAccountId = "ext-acc-id-123";
    proposeService(accountId, providerId, externalAccountId);
  }
}
ProposeServiceSample.java

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\AccountAggregation;
use Google\Shopping\Merchant\Accounts\V1\AccountService;
use Google\Shopping\Merchant\Accounts\V1\Client\AccountServicesServiceClient;
use Google\Shopping\Merchant\Accounts\V1\ProposeAccountServiceRequest;

/**
 * This class demonstrates how to propose an account service.
 */
class ProposeAccountServiceSample
{
    /**
     * A helper function to create the account name string.
     *
     * @param string $accountId The ID of the account.
     *
     * @return string The account name has the format: `accounts/{account_id}`
     */
    private static function toAccountName(string $accountId): string
    {
        return sprintf('accounts/%s', $accountId);
    }

    /**
     * Proposes a new account service.
     *
     * @param array $config The configuration data used for authentication and
     *     getting the account ID.
     * @param string $providerId The ID of the provider account.
     */
    public static function proposeAccountService(
        array $config,
        string $providerId
    ): void {
        // Gets the OAuth credentials to make the request.
        $credentials = Authentication::useServiceAccountOrTokenFile();

        // Creates options containing credentials for the client to use.
        $options = ['credentials' => $credentials];

        // Creates a client.
        $accountServicesServiceClient = new AccountServicesServiceClient($options);

        // Calls the API and catches and prints any network failures/errors.
        try {
            $accountAggregation = new AccountAggregation();
            $accountService = (new AccountService())
                ->setAccountAggregation($accountAggregation);

            $request = (new ProposeAccountServiceRequest())
                ->setParent(self::toAccountName($config['accountId']))
                ->setProvider(self::toAccountName($providerId))
                ->setAccountService($accountService);

            print "Sending Propose AccountService request\n";
            $response = $accountServicesServiceClient->proposeAccountService($request);
            print "Proposed AccountService below\n";
            print $response->serializeToJsonString(true) . PHP_EOL;
        } catch (ApiException $e) {
            printf("An error has occurred: %s%s", $e->getMessage(), PHP_EOL);
        }
    }

    /**
     * Helper to execute the sample.
     */
    public function callSample(): void
    {
        $config = Config::generateConfig();

        // Update this with the Merchant Center provider ID you want to get the
        // relationship for.
        $providerId = 111;
        self::proposeAccountService($config, $providerId);
    }
}

// Run the script
$sample = new ProposeAccountServiceSample();
$sample->callSample();
ProposeAccountServiceSample.php

Python

"""This class demonstrates how to propose an account service."""

from examples.authentication import configuration
from examples.authentication import generate_user_credentials
from google.shopping.merchant_accounts_v1 import AccountAggregation
from google.shopping.merchant_accounts_v1 import AccountService
from google.shopping.merchant_accounts_v1 import AccountServicesServiceClient
from google.shopping.merchant_accounts_v1 import ProposeAccountServiceRequest

_ACCOUNT = configuration.Configuration().read_merchant_info()
_PARENT = f"accounts/{_ACCOUNT}"


def propose_account_service(provider_id: int) -> None:
  """Proposes an account service.

  Args:
    provider_id: The Merchant Center ID of the provider.
  """
  # Gets OAuth Credentials.
  credentials = generate_user_credentials.main()

  # Creates a client.
  client = AccountServicesServiceClient(credentials=credentials)

  # Creates the provider resource name from the provider ID.
  provider = f"accounts/{provider_id}"

  # Creates an AccountService object.
  # For this request, only `account_aggregation` is needed.
  account_service = AccountService()
  account_service.account_aggregation = AccountAggregation()

  # Creates the request.
  request = ProposeAccountServiceRequest(
      parent=_PARENT,
      provider=provider,
      account_service=account_service,
  )

  # Makes the request and catches and prints any error messages.
  try:
    print("Sending Propose AccountService request")
    response = client.propose_account_service(request=request)
    print("Proposed AccountService below")
    print(response)
  except RuntimeError as e:
    print(e)


if __name__ == "__main__":
  # Update this with the Merchant Center provider ID you want to get the
  # relationship for.
  provider_id_ = 111
  propose_account_service(provider_id_)
propose_account_service_sample.py

Comportement de handshake spécifique au service

Vous trouverez ci-dessous une description des exigences spécifiques à chaque service concernant l'établissement de la liaison :

• Agrégation de comptes : ce service ne peut être établi que lors de la création d'un compte. Le fournisseur de services doit être un compte avancé. Le service est automatiquement approuvé, car les utilisateurs du compte avancé disposent d'un accès ADMIN complet au compte en cours de création.

• Comparison Shopping : ce service est automatiquement approuvé lorsqu'il est ajouté lors de la création du compte à l'aide de createAndConfigure.

• Gestion des campagnes : bien que ce processus suive la procédure d'établissement de la connexion habituelle, les propositions sont faites dans un système (par exemple, Google Ads) et les approbations dans l'autre (par exemple, dans Merchant Center ou via l'API Merchant).

• Gestion des fiches locales : pour ce service, la poignée de main est proposée dans une méthode dédiée et les approbations sont effectuées dans l'autre système (par exemple, la fiche d'établissement Google). Pour en savoir plus, consultez le guide sur l'association d'une fiche d'établissement Google.

• Gestion des comptes : pour ce service, le processus d'établissement de connexion habituel s'applique lors de l'utilisation de propose. Si le service est ajouté lors de la création du compte à l'aide de createAndConfigure, il est automatiquement approuvé.

• Gestion des produits : pour ce service, la procédure d'établissement de la connexion habituelle s'applique (proposition d'une partie, suivie de l'acceptation de l'autre).

Droits d'accès

Chaque type de service offre un certain niveau d'accès aux utilisateurs du fournisseur de services sur le compte concerné :

• Agrégation de comptes : ce service fournit des droits ADMIN complets.

• Gestion des campagnes : ce service fournit un droit d'accès limité, permettant au compte Ads associé d'accéder aux produits et aux informations de base du compte.

• Comparateur de prix : ce service fournit, par défaut, des droits ADMIN complets. Toutefois, l'entreprise peut limiter l'accès accordé dans Merchant Center.

• Gestion des fiches locales : ce service ne fournit aucun droit d'accès direct. Il permet plutôt à la fiche de synchroniser ses produits avec le compte Merchant Center.

Important : Les droits d'accès décrits pour les types de services suivants ne s'appliquent qu'aux fournisseurs de services approuvés. Si vous êtes un fournisseur de services et que vous souhaitez utiliser cette fonctionnalité, contactez notre équipe d'assistance. Si vous avez déjà été approuvé pour la méthode accounts.link pour la gestion des produits dans Content API for Shopping, vous pouvez utiliser ce service dans Merchant API sans autre approbation.

• Gestion de compte : ce service fournit, par défaut, des droits ADMIN complets.

• Gestion des produits : ce service fournit des droits ADMIN complets. Notez que, à l'avenir, cela sera limité aux droits d'accès liés aux produits.

Comment les relations s'appliquent aux plates-formes tierces

Si vous êtes une plate-forme tierce qui gère des comptes pour le compte d'autres entreprises, vous trouverez ci-dessous la correspondance entre les différents concepts et la structure de votre compte :

1. Fournisseur de services : votre compte avancé.
2. Compte bénéficiant du service : compte Merchant Center représentant l'entreprise que vous gérez.
3. Service :
   • accountManagement : il s'agit du service recommandé pour les plates-formes d'e-commerce et les partenaires de distribution qui créent des comptes pour le compte de marchands. Il crée un compte dont le marchand est propriétaire et qui est associé à vous pour la gestion. Cela correspond à la structure Merchant Center recommandée pour ce cas d'utilisation.
   • accountAggregation : ce service associe votre compte avancé à un autre compte. Bien qu'il soit compatible, il n'est pas recommandé pour les plates-formes d'e-commerce et les partenaires de distribution.

Pour savoir comment configurer un compte avancé et l'associer à de nouveaux comptes Merchant Center, consultez Créer des comptes.