Administra los acuerdos de las Condiciones del Servicio de Merchant Center

Para usar Merchant Center y sus funciones, debes aceptar las Condiciones del Servicio (CdS) de Merchant Center para la ubicación de tu empresa. En estos acuerdos, se describen las condiciones legales para usar los servicios de Merchant Center.

En esta guía, se explica cómo puedes usar la API de Merchant para administrar estos acuerdos, ya sea para tu propia cuenta o para las cuentas que administras como proveedor externo (3P).

Puedes lograr lo siguiente:

  • Verifica el estado actual del acuerdo de las C.G.U. de una cuenta.
  • Guiar a los comercios para que acepten las condiciones del servicio necesarias
  • Administrar las C.S. como proveedor externo para cuentas de cliente o cuentas independientes

Requisitos previos

Para usar la API de Merchant, necesitas una cuenta de Merchant Center. Una vez que la crees con la interfaz de usuario (IU) de Merchant Center, podrás realizar cambios en la cuenta (por ejemplo, actualizar la información de tu empresa, administrar usuarios, etcétera) con la IU o la API.

Si necesitas administrar varias cuentas, puedes crear cuentas de cliente con la API de Merchant. Consulta Crea y administra cuentas secundarias.

Cómo verificar el estado del acuerdo de las condiciones del servicio de una cuenta

Antes de que un comercio pueda utilizar Merchant Center por completo, o si necesitas verificar el estado actual de su acuerdo, puedes recuperar el estado de su acuerdo de Condiciones del Servicio.

Usa el método termsOfServiceAgreementStates.retrieveForApplication para obtener el estado del acuerdo de las condiciones del servicio de la aplicación principal de Merchant Center. Este método muestra las C.S. actuales, si las hay, y, si se actualizaron desde la última vez que las aceptaste, la versión más reciente que debes aceptar.

A continuación, se muestra una solicitud de ejemplo:

GET https://merchantapi.googleapis.com/accounts/v1/accounts/{ACCOUNT_ID}/termsOfServiceAgreementStates:retrieveForApplication

Una llamada correcta devuelve un recurso TermsOfServiceAgreementState. Este recurso contiene lo siguiente:

  • name: Es el identificador de este estado del acuerdo.
  • regionCode: Es el país al que se aplica el estado de este acuerdo, que suele ser el país de la empresa de la cuenta.
  • termsOfServiceKind: Será MERCHANT_CENTER.
  • accepted: Son los detalles sobre la versión de las condiciones del servicio que la cuenta ya aceptó, incluido el nombre del recurso termsOfService (como termsOfService/132) y quién lo acceptedBy. También puede incluir una fecha de validUntil si se required una versión más reciente de las CDS.
  • required: Son los detalles sobre una versión de las C. del S. que la cuenta debe aceptar. Esto incluye el nombre del recurso termsOfService y un tosFileUri que apunta al documento de las condiciones del servicio legible por humanos.

Ejemplo de respuesta:

{
  "name": "accounts/{ACCOUNT_ID}/termsOfServiceAgreementStates/MERCHANT_CENTER-{REGION_CODE}",
  "regionCode": "{REGION_CODE}",
  "termsOfServiceKind": "MERCHANT_CENTER",
  "accepted": {
    "termsOfService": "termsOfService/132",
    "acceptedBy": "accounts/{ACCOUNT_ID}"
  },
  "required": {
    "termsOfService": "termsOfService/132",
    "tosFileUri": "https://www.google.com/intl/{REGION_CODE}/policies/merchants/terms/"
  }
}

Si hay nuevas CdS required, debes guiar al comercio para que las acepte.

Aquí tienes un ejemplo que puedes usar para recuperar el estado del acuerdo de Condiciones del Servicio para una cuenta y un país específicos:

Java

import com.google.api.gax.core.FixedCredentialsProvider;
import com.google.auth.oauth2.GoogleCredentials;
import com.google.shopping.merchant.accounts.v1.GetTermsOfServiceAgreementStateRequest;
import com.google.shopping.merchant.accounts.v1.TermsOfServiceAgreementState;
import com.google.shopping.merchant.accounts.v1.TermsOfServiceAgreementStateName;
import com.google.shopping.merchant.accounts.v1.TermsOfServiceAgreementStateServiceClient;
import com.google.shopping.merchant.accounts.v1.TermsOfServiceAgreementStateServiceSettings;
import shopping.merchant.samples.utils.Authenticator;
import shopping.merchant.samples.utils.Config;

/**
 * This class demonstrates how to get a TermsOfServiceAgreementState for a specific
 * TermsOfServiceKind and country.
 */
public class GetTermsOfServiceAgreementStateSample {

  public static void getTermsOfServiceAgreementState(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.
    TermsOfServiceAgreementStateServiceSettings termsOfServiceAgreementStateServiceSettings =
        TermsOfServiceAgreementStateServiceSettings.newBuilder()
            .setCredentialsProvider(FixedCredentialsProvider.create(credential))
            .build();

    // Creates TermsOfServiceAgreementState name to identify TermsOfServiceAgreementState.
    String name =
        TermsOfServiceAgreementStateName.newBuilder()
            .setAccount(config.getAccountId().toString())
            // The Identifier is: "{TermsOfServiceKind}-{country}"
            .setIdentifier("MERCHANT_CENTER-US")
            .build()
            .toString();

    System.out.println(name);

    // Calls the API and catches and prints any network failures/errors.
    try (TermsOfServiceAgreementStateServiceClient termsOfServiceAgreementStateServiceClient =
        TermsOfServiceAgreementStateServiceClient.create(
            termsOfServiceAgreementStateServiceSettings)) {

      // The name has the format:
      // accounts/{account}/termsOfServiceAgreementStates/{TermsOfServiceKind}-{country}
      GetTermsOfServiceAgreementStateRequest request =
          GetTermsOfServiceAgreementStateRequest.newBuilder().setName(name).build();

      System.out.println("Sending Get TermsOfServiceAgreementState request:");
      TermsOfServiceAgreementState response =
          termsOfServiceAgreementStateServiceClient.getTermsOfServiceAgreementState(request);

      System.out.println("Retrieved TermsOfServiceAgreementState below");
      // If the terms of service needs to be accepted, the "required" field will include the
      // specific version of the terms of service which needs to be accepted, alongside a link to
      // the terms of service itself.
      System.out.println(response);
    } catch (Exception e) {
      System.out.println(e);
    }
  }


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

    getTermsOfServiceAgreementState(config);
  }
}
GetTermsOfServiceAgreementStateSample.java

PHP

use Google\ApiCore\ApiException;
use Google\Shopping\Merchant\Accounts\V1\Client\TermsOfServiceAgreementStateServiceClient;
use Google\Shopping\Merchant\Accounts\V1\GetTermsOfServiceAgreementStateRequest;

/**
 * Demonstrates how to get a TermsOfServiceAgreementState.
 */
class GetTermsOfServiceAgreementState
{

    /**
     * Gets a TermsOfServiceAgreementState.
     *
     * @param array $config The configuration data.
     * @return void
     */
    public static function getTermsOfServiceAgreementState($config): void
    {
        // Get OAuth credentials.
        $credentials = Authentication::useServiceAccountOrTokenFile();

        // Create client options.
        $options = ['credentials' => $credentials];

        // Create a TermsOfServiceAgreementStateServiceClient.
        $termsOfServiceAgreementStateServiceClient = new TermsOfServiceAgreementStateServiceClient($options);

        // Service agreeement identifier
        $identifier = "MERCHANT_CENTER-US";

        // Create TermsOfServiceAgreementState name.
        $name = "accounts/" . $config['accountId'] . "/termsOfServiceAgreementStates/" . $identifier;

        print $name . PHP_EOL;

        try {
            // Prepare the request.
            $request = new GetTermsOfServiceAgreementStateRequest([
                'name' => $name,
            ]);

            print "Sending Get TermsOfServiceAgreementState request:" . PHP_EOL;
            $response = $termsOfServiceAgreementStateServiceClient->getTermsOfServiceAgreementState($request);

            print "Retrieved TermsOfServiceAgreementState below\n";
            print $response->serializeToJsonString() . PHP_EOL;
        } catch (ApiException $e) {
            print $e->getMessage();
        }
    }

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

        self::getTermsOfServiceAgreementState($config);
    }

}

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

Python

from examples.authentication import configuration
from examples.authentication import generate_user_credentials
from google.shopping.merchant_accounts_v1 import GetTermsOfServiceAgreementStateRequest
from google.shopping.merchant_accounts_v1 import TermsOfServiceAgreementStateServiceClient

# Replace with your actual value.
_ACCOUNT_ID = configuration.Configuration().read_merchant_info()
_IDENTIFIER = "MERCHANT_CENTER-US"  # Replace with your identifier


def get_terms_of_service_agreement_state():
  """Gets a TermsOfServiceAgreementState for a specific TermsOfServiceKind and country."""

  credentials = generate_user_credentials.main()
  client = TermsOfServiceAgreementStateServiceClient(credentials=credentials)

  name = (
      "accounts/"
      + _ACCOUNT_ID
      + "/termsOfServiceAgreementStates/"
      + _IDENTIFIER
  )

  print(name)

  request = GetTermsOfServiceAgreementStateRequest(name=name)

  try:
    print("Sending Get TermsOfServiceAgreementState request:")
    response = client.get_terms_of_service_agreement_state(request=request)
    print("Retrieved TermsOfServiceAgreementState below")
    print(response)
  except RuntimeError as e:
    print(e)


if __name__ == "__main__":
  get_terms_of_service_agreement_state()

get_terms_of_service_agreement_state_sample.py

Aceptar las Condiciones del Servicio

Los comercios deben aceptar las Condiciones del Servicio más recientes para mantener el acceso a las funciones de Merchant Center.

Acepta las Condiciones del Servicio para tu propia cuenta

Si administras tu propia cuenta de Merchant Center, haz lo siguiente:

  1. Llama al termsOfServiceAgreementStates.retrieveForApplication para identificar si alguna de las condiciones del servicio es required.
  2. Si se requieren C.S., anota el nombre de termsOfService del campo required (por ejemplo, termsOfService/132).

  3. Llama a termsOfService.accept para aceptar las condiciones del servicio. Necesitarás el nombre de las C.S., tu ACCOUNT_ID y el regionCode que devuelve retrieveForApplication.

    A continuación, se muestra una solicitud de ejemplo:

    POST https://merchantapi.googleapis.com/accounts/v1/{name={termsOfService/VERSION}}:accept
{
  "account": "accounts/{ACCOUNT_ID}",
  "regionCode": "{REGION_CODE}"
}

    Una llamada exitosa muestra un cuerpo de respuesta vacío y actualiza el estado del acuerdo de las condiciones del servicio de la cuenta.

Guía a los comercios para que acepten las C.S. (para proveedores externos)

Si eres un proveedor externo (3P) que administra cuentas independientes de Merchant Center para otras empresas, no debes aceptar las CdeC en su nombre. En su lugar, debes hacer lo siguiente:

  1. Recupera las C.S. más recientes: Llama a termsOfService.retrieveLatest para obtener el tipo regionCode y MERCHANT_CENTER del comercio y obtener los detalles de la versión más reciente de las C.S. que podría necesitar aceptar.

    Solicitud de muestra:

    GET https://merchantapi.googleapis.com/accounts/v1/termsOfService:retrieveLatest?regionCode={REGION_CODE}&kind=MERCHANT_CENTER

    Respuesta de muestra:

    {
    "name": "{termsOfService/VERSION}",
    "regionCode": "{REGION_CODE}",
    "kind": "MERCHANT_CENTER",
    "fileUri": "https://www.google.com/intl/{REGION_CODE}/policies/merchants/terms/"
}

  2. Muestra las C.S.: Usa el objeto fileUri de la respuesta para mostrar el texto completo de las Condiciones del Servicio al comercio en la IU de tu aplicación.

  3. Obtén la aceptación del comercio: El comercio debe aceptar explícitamente las condiciones en tu IU.

  4. Registra la aceptación con la API: Después de que el comercio acepte, llama a termsOfService.accept con el name de las CdC que obtuviste en el paso 1, el ACCOUNT_ID del comercio y su regionCode.

    Solicitud de muestra:

    POST https://merchantapi.googleapis.com/accounts/v1/{name={termsOfService/VERSION}}:accept
{
  "account": "accounts/{MERCHANT_ACCOUNT_ID}",
  "regionCode": "{REGION_CODE}"
}

A continuación, se incluye un ejemplo que puedes usar para aceptar el acuerdo de Condiciones del Servicio de una cuenta determinada (después de que el comercio haya aceptado):

Java

import com.google.api.gax.core.FixedCredentialsProvider;
import com.google.auth.oauth2.GoogleCredentials;
import com.google.shopping.merchant.accounts.v1.AcceptTermsOfServiceRequest;
import com.google.shopping.merchant.accounts.v1.TermsOfServiceServiceClient;
import com.google.shopping.merchant.accounts.v1.TermsOfServiceServiceSettings;
import shopping.merchant.samples.utils.Authenticator;
import shopping.merchant.samples.utils.Config;

/** This class demonstrates how to accept the TermsOfService agreement in a given account. */
public class AcceptTermsOfServiceSample {

  public static void acceptTermsOfService(String accountId, String tosVersion, String regionCode)
      throws Exception {

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

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

    // Calls the API and catches and prints any network failures/errors.
    try (TermsOfServiceServiceClient tosServiceClient =
        TermsOfServiceServiceClient.create(tosServiceSettings)) {

      // The parent has the format: accounts/{account}
      AcceptTermsOfServiceRequest request =
          AcceptTermsOfServiceRequest.newBuilder()
              .setName(String.format("termsOfService/%s", tosVersion))
              .setAccount(String.format("accounts/%s", accountId))
              .setRegionCode(regionCode)
              .build();

      System.out.println("Sending request to accept terms of service...");
      tosServiceClient.acceptTermsOfService(request);

      System.out.println("Successfully accepted terms of service.");
    } catch (Exception e) {
      System.out.println(e);
    }
  }

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

    // See GetTermsOfServiceAgreementStateSample to understand how to check which version of the
    // terms of service needs to be accepted, if any.
    // Likewise, if you know that the terms of service needs to be accepted, you can also simply
    // call RetrieveLatestTermsOfService to get the latest version of the terms of service.
    // Region code is either a country when the ToS applies specifically to that country or 001 when
    // it applies globally.
    acceptTermsOfService(config.getAccountId().toString(), "VERSION_HERE", "REGION_CODE_HERE");
  }
}
AcceptTermsOfServiceSample.java

PHP

use Google\ApiCore\ApiException;
use Google\Shopping\Merchant\Accounts\V1\AcceptTermsOfServiceRequest;
use Google\Shopping\Merchant\Accounts\V1\Client\TermsOfServiceServiceClient;

/**
 * Demonstrates how to accept the TermsOfService agreement in a given account.
 */
class AcceptTermsOfService
{

    /**
     * Accepts the Terms of Service agreement.
     *
     * @param string $accountId The account ID.
     * @param string $tosVersion The Terms of Service version.
     * @param string $regionCode The region code.
     * @return void
     */
    public static function acceptTermsOfService($accountId, $tosVersion, $regionCode): void
    {
        // Get OAuth credentials.
        $credentials = Authentication::useServiceAccountOrTokenFile();

        // Create client options.
        $options = ['credentials' => $credentials];

        // Create a TermsOfServiceServiceClient.
        $tosServiceClient = new TermsOfServiceServiceClient($options);

        try {
            // Prepare the request.
            $request = new AcceptTermsOfServiceRequest([
                'name' => sprintf("termsOfService/%s", $tosVersion),
                'account' => sprintf("accounts/%s", $accountId),
                'region_code' => $regionCode,
            ]);

            print "Sending request to accept terms of service...\n";
            $tosServiceClient->acceptTermsOfService($request);

            print "Successfully accepted terms of service.\n";
        } catch (ApiException $e) {
            print $e->getMessage();
        }
    }

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

        // Replace with actual values.
        $tosVersion = "132";
        $regionCode = "US";

        self::acceptTermsOfService($config['accountId'], $tosVersion, $regionCode);
    }
}

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

Python

from examples.authentication import configuration
from examples.authentication import generate_user_credentials
from google.shopping.merchant_accounts_v1 import AcceptTermsOfServiceRequest
from google.shopping.merchant_accounts_v1 import TermsOfServiceServiceClient

# Replace with your actual values.
_ACCOUNT_ID = configuration.Configuration().read_merchant_info()
_TOS_VERSION = (  # Replace with the Terms of Service version to accept
    "VERSION_HERE"
)
_REGION_CODE = "US"  # Replace with the region code


def accept_terms_of_service():
  """Accepts the Terms of Service agreement for a given account."""

  credentials = generate_user_credentials.main()
  client = TermsOfServiceServiceClient(credentials=credentials)

  # Construct the request
  request = AcceptTermsOfServiceRequest(
      name=f"termsOfService/{_TOS_VERSION}",
      account=f"accounts/{_ACCOUNT_ID}",
      region_code=_REGION_CODE,
  )

  try:
    print("Sending request to accept terms of service...")
    client.accept_terms_of_service(request=request)
    print("Successfully accepted terms of service.")
  except RuntimeError as e:
    print(e)


if __name__ == "__main__":
  accept_terms_of_service()

accept_terms_of_service_sample.py

Consideraciones especiales para los proveedores externos

Como proveedor externo, puedes administrar las C.S. de las cuentas de cliente o las cuentas independientes.

Administra las C.S. de las cuentas de cliente

Si administras una cuenta avanzada y creas cuentas de cliente para diferentes empresas, haz lo siguiente:

  • Aceptación avanzada de la cuenta: Si una cuenta avanzada proporciona el servicio de agregación de cuentas a las cuentas de cliente, las condiciones del servicio aceptadas por la cuenta avanzada también se aplicarán a todas sus cuentas de cliente con ese servicio.
  • Visualización y consentimiento: Incluso si la aceptación de la cuenta avanzada abarca las cuentas de cliente, es una práctica recomendada (y podría ser una expectativa legal) mostrar las Condiciones del Servicio pertinentes de Google Merchant Center al propietario real de cada cuenta de cliente. Debes obtener su consentimiento explícito para que comprendan y acepten estas condiciones, incluso si la llamada a la API para la aceptación se realiza a nivel de la cuenta avanzada.
  • Verificación del estado de la cuenta del cliente: Usa termsOfServiceAgreementStates.retrieveForApplication en una cuenta de cliente específica para verificar su estado de las C.S. y ver si está cubierta por el acuerdo de la cuenta avanzada o si se necesita alguna acción directa.

Administra las C.S. de cuentas independientes

Como se detalla en la Guía para ayudar a los comercios a aceptar las C. del S., cuando ayudes a una empresa a crear o administrar una cuenta independiente de Merchant Center, esa empresa (el propietario de la cuenta) debe aceptar personalmente las Condiciones del Servicio. Para facilitar esto, recupera y muestra las C.S. y, luego, llama al método termsOfService.accept en su nombre después de que haya dado su consentimiento explícito a través de tu interfaz.

Anterior
Overview
Siguiente
Create and manage sub-accounts