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 (accountAggregation) vincula una cuenta avanzada de varios clientes a una cuenta secundaria, lo que otorga a la cuenta avanzada acceso completo y sin restricciones, y hace que la cuenta secundaria sea visible en la IU de Merchant Center. La IU de Merchant Center convierte automáticamente las cuentas en cuentas avanzadas con accountAggregation para creadores de tiendas (plataformas de comercio electrónico), socios de canal, mercados, minoristas de varias marcas y minoristas internacionales cuando se crean cuentas secundarias nuevas. Si eres una agencia, usa 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.

  • Este servicio permite crear filtros de productos específicos de socios cuando se ejecutan campañas de red de commerce media.
  • En este momento, debes usar la versión Alfa de la sub-API de Accounts.
  • Para usar esta función, se requiere una lista de entidades permitidas específica de GMC.

Comunícate con tu equipo de administración de cuentas de Google Ads para obtener más detalles.

  • 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 (accountManagement) permite que el proveedor realice acciones administrativas en una cuenta externa independiente de Merchant Center, como configurar los parámetros de la cuenta, administrar los 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 independiente vinculada al proveedor. También se puede proponer a una cuenta existente. Las agencias que usan este tipo de servicio pueden ver las cuentas que administran en Merchant Center para agencias. Los creadores de tiendas y los socios de canal pueden usar la API de Merchant para extraer información sobre los comercios que administran a través de accountManagement.

  • 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.

  • Administración de confirmación de compra de UCP (v1alpha, acceso limitado): El servicio ucpCheckoutManagement permite que un proveedor de servicios aprobado administre las integraciones, la configuración y la participación en el programa de confirmación de compra de UCP en nombre de un comercio. Este servicio solo se puede proponer a una cuenta de Merchant Center existente o aprobarlo por ella.

    Nota: La confirmación de compra de UCP es una función alfa con acceso limitado. Obtén más información sobre los proveedores de servicios y la confirmación de compra de UCP en Merchant Center para proveedores de servicios.

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

  • Administración de confirmación de compra de UCP (v1alpha, acceso limitado): Para este servicio, el comercio puede completar el protocolo de enlace a través del diálogo de vinculación de cuentas alojado en Google en el portal del proveedor de servicios o con el proceso de protocolo de enlace estándar (propose seguido de approve). Para obtener detalles de la integración, consulta la documentación de los proveedores de servicios de Merchant Center.

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.

  • Administración de confirmación de compra con UCP (v1alpha, acceso limitado): 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 la confirmación de la compra de UCP.

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:
    • accountAggregation: Lo usan los creadores de tiendas (plataformas de comercio electrónico), los socios de canal, los mercados y los minoristas de varias marcas que crean cuentas secundarias nuevas en nombre de los comercios. La IU de Merchant Center configura automáticamente a los creadores de tiendas y a los socios de canal como cuentas avanzadas con accountAggregation, lo que les permite ver y administrar cuentas secundarias en la IU de Merchant Center.
    • accountManagement: Lo usan las agencias que crean cuentas de cliente independientes que pertenecen al comercio o se vinculan a ellas, y que pueden ver en Merchant Center para agencias. Otros tipos de proveedores de servicios usan el método accounts.list en la API de Merchant para ver la información de las cuentas vinculadas.

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