Administra las relaciones de la cuenta

Puedes usar la API de Accounts para administrar las relaciones entre tu cuenta de Merchant Center y otros proveedores de servicios. Una relación es una conexión formal que permite que un proveedor ofrezca servicios específicos a tu empresa. Un servicio define los permisos y las capacidades que se otorgan al proveedor, como la administración de productos o de campañas. Por ejemplo, vincular tu cuenta de Merchant Center a una cuenta de Google Ads permite que la cuenta de anuncios use tus datos de productos para publicar campañas publicitarias.

Una relación se compone de los siguientes atributos:

  • La cuenta de Merchant Center que recibe el servicio
  • El proveedor de servicios
  • Es el servicio o conjunto de servicios que se proporcionan a la cuenta de Merchant Center.

Alias

Los proveedores de servicios pueden asociar un alias con las cuentas a las que prestan servicios (esto equivale al campo seller_id que estaba presente en el recurso account en Content API for Shopping). El alias se puede asignar con el campo opcional account_id_alias dentro del recurso AccountRelationship y funciona como un identificador personalizado. El alias debe tener entre 1 y 50 caracteres elegidos entre letras ASCII, dígitos decimales, guiones, guiones bajos, puntos o virgulillas ([A-Za-z0-9_~.-]{1,50}).

La estructura de la URL para acceder a una cuenta con su alias es GET /accounts/v1/accounts/{provider}~{account_id_alias}.

Servicios

En la API de Accounts, las cuentas pueden recibir los siguientes servicios. Puedes agregar muchos de estos servicios durante la creación de la cuenta.

  • Agregación de cuentas: Este servicio vincula una cuenta avanzada a otra cuenta, lo que le otorga a la cuenta avanzada acceso completo y sin restricciones. Por lo general, lo usan los mercados, los minoristas de varias marcas o los minoristas internacionales que necesitan un control centralizado de las cuentas anidadas. Si eres una plataforma de comercio electrónico o un socio de canal, te recomendamos que uses accountManagement en su lugar. Cuando creas una cuenta con la agregación de cuentas, se debe omitir el externalAccountId.

  • Administración de campañas: Este servicio modela la vinculación entre una cuenta de Merchant Center y una cuenta de Google Ads, lo que le otorga a la cuenta de anuncios acceso a los datos de la cuenta y de productos que se necesitan para publicar campañas publicitarias. En este caso, el proveedor de servicios es GOOGLE_ADS y externalAccountId es el ID de la cuenta de Google Ads. Este servicio también se puede proponer a una cuenta existente.

  • Comparación de productos: Representa la relación con un Servicio de comparación de productos (CSS) que opera la cuenta de Merchant Center.

  • Administración de fichas locales: Representa la relación con un administrador de tienda para administrar el inventario local y las fichas con un Perfil de Negocio de Google.

  • Administración de cuentas: Este servicio permite que el proveedor realice acciones administrativas en la cuenta de Merchant Center, como establecer la configuración de la cuenta, administrar usuarios o actualizar la información de la empresa. La empresa también puede restringir el acceso otorgado. Cuando se usa durante la creación de la cuenta, este servicio crea una cuenta vinculada al proveedor, que es el enfoque recomendado para las plataformas de comercio electrónico y los socios de canal. También se puede proponer a una cuenta existente.

  • Administración de productos: Este servicio permite que los proveedores administren productos y funciones relacionadas, como las fuentes de datos y las reglas. Cuando se agrega durante la creación de la cuenta, suele ser en combinación con accountManagement o accountAggregation. Este servicio también se puede proponer a una cuenta existente.

Apretón de manos

Para establecer un servicio, tanto la cuenta que lo proporciona como la que lo recibe deben autorizar la conexión. Este proceso de autorización se denomina protocolo de enlace.

El protocolo de enlace es un proceso de dos pasos:

  1. Una parte propone un vínculo de servicio.
  2. La otra parte aprueba o rechaza la propuesta.

Una vez que se acepta una propuesta, el servicio se aprueba y se considera completamente establecido. Cualquier derecho de acceso otorgado al proveedor de servicios ahora se otorga a los usuarios calificados (consulta los derechos de acceso a continuación).

Ten en cuenta que el usuario que crea, rechaza o aprueba una propuesta debe tener derechos de acceso de ADMIN en la cuenta que inicia el proceso. Por lo tanto, si el proveedor de servicios propone un servicio, el usuario que realiza la propuesta debe ser un ADMIN en la cuenta del proveedor de servicios, y el usuario que acepta o rechaza la propuesta debe ser un ADMIN en la cuenta receptora.

En los siguientes ejemplos, se muestra cómo proponer un servicio de cuenta:

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);
  }
}

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();

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_)

Comportamiento de protocolo de enlace específico del servicio

A continuación, se describen los requisitos específicos de protocolo de enlace para cada servicio individual:

  • Agregación de cuentas: Este servicio solo se puede establecer como parte de la creación de la cuenta. Se espera que el proveedor de servicios sea una cuenta avanzada, y el servicio se aprueba automáticamente, ya que los usuarios de la cuenta avanzada tienen acceso completo de ADMIN a la cuenta que se crea.

  • Comparación de precios: Este servicio se aprueba automáticamente cuando se agrega durante la creación de la cuenta con createAndConfigure.

  • Administración de campañas: Si bien esto sigue el proceso de protocolo de enlace normal, las propuestas se realizan en un sistema (por ejemplo, Google Ads) y las aprobaciones se realizan en el otro sistema (por ejemplo, en Merchant Center o a través de la API de Merchant).

  • Administración de fichas locales: Para este servicio, el protocolo de enlace se propone en un método dedicado y las aprobaciones se realizan en el otro sistema (por ejemplo, el Perfil de Negocio de Google). Los pasos detallados se encuentran en la Guía para vincular un Perfil de Negocio de Google.

  • Administración de cuentas: Para este servicio, se aplica el proceso de protocolo de enlace habitual cuando se usa propose. Si el servicio se agrega durante la creación de la cuenta con createAndConfigure, se aprueba automáticamente.

  • Administración de productos: Para este servicio, se aplica el proceso de protocolo de enlace habitual (propuesto por una parte y seguido de la aceptación de la otra).

Derechos de acceso

Cada tipo de servicio proporciona un nivel de acceso determinado para los usuarios del proveedor de servicios en la cuenta que se administra:

  • Agregación de cuentas: Este servicio proporciona derechos de ADMIN completos.

  • Administración de campañas: Este servicio proporciona un derecho de acceso restringido, lo que permite que la cuenta de Google Ads asociada acceda a los productos y a la información básica de la cuenta.

  • Comparación de productos: Este servicio proporciona, de forma predeterminada, derechos de ADMIN completos. Sin embargo, la empresa puede restringir el acceso otorgado en Merchant Center.

  • Administración de fichas locales: Este servicio no proporciona ningún derecho de acceso directo. En cambio, permite que la ficha sincronice sus productos con la cuenta de Merchant Center.

Importante: Los derechos de acceso descritos para los siguientes tipos de servicio se aplican solo a los proveedores de servicios aprobados. Comunícate con nuestro equipo de asistencia al cliente si eres proveedor de servicios y quieres usar esta función. Si ya se te aprobó anteriormente el método accounts.link para la administración de productos en Content API for Shopping, puedes usar este servicio en la API de Merchant sin aprobaciones adicionales.

  • Administración de cuentas: De forma predeterminada, este servicio proporciona derechos de ADMIN completos.

  • Administración de productos: Este servicio proporciona derechos de ADMIN completos. Ten en cuenta que, en el futuro, esto se limitará solo a los derechos de acceso relacionados con el producto.

Cómo se aplican las relaciones para las plataformas de terceros

Si eres una plataforma de terceros que administra cuentas en nombre de otras empresas, a continuación, se muestra cómo se asignan los diferentes conceptos a la estructura de tu cuenta:

  1. Proveedor de servicios: Tu cuenta avanzada.
  2. Cuenta que recibe el servicio: Es una cuenta de Merchant Center que representa la empresa que administras.
  3. Servicio:
    • accountManagement: Este es el servicio recomendado para las plataformas de comercio electrónico y los socios de canal que crean cuentas nuevas en nombre de los comercios. Se crea una cuenta que pertenece al comercio y que está vinculada a ti para su administración. Esto se alinea con la estructura preferida de Merchant Center para este caso de uso.
    • accountAggregation: Este servicio vincula tu cuenta avanzada con otra cuenta. Si bien es compatible, no se recomienda para plataformas de comercio electrónico ni socios de canal.

Para obtener detalles sobre cómo configurar una cuenta avanzada y vincularla a cuentas nuevas de Merchant Center, consulta Crea cuentas.

Anterior
Create accounts
Siguiente
Control access to your account