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 hacer lo siguiente:

  • Verificar el estado actual del acuerdo de CDS de una cuenta
  • Guiar a los comerciantes para que acepten las CDS necesarias
  • Administrar las CDS como proveedor de servicios para las cuentas de clientes

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 Cómo crear cuentas.

Cómo verificar el estado del acuerdo de CDS de una cuenta

Antes de que un comerciante 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 termsOfServiceAgreementStates.retrieveForApplication método para obtener el estado del acuerdo de CDS de la aplicación principal de Merchant Center. Este método muestra tus CDS actuales, si las tienes, y, si se actualizaron desde la última vez que las aceptaste, la versión más reciente que debes aceptar.

Aquí encontrarás una solicitud de ejemplo:

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

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

  • name: Es el identificador de este estado del acuerdo.
  • regionCode: Es el país al que se aplica este estado del 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 CDS que la cuenta ya aceptó, incluido el nombre del recurso termsOfService (por ejemplo, termsOfService/132) y quién las acceptedBy. También puede incluir una fecha validUntil si se required una versión más reciente de las CDS.
  • required: Son los detalles sobre una versión de las CDS que la cuenta debe aceptar. Esto incluye el nombre del recurso termsOfService y un tosFileUri que apunta al documento de las CDS 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 se required una nueva CDS, debes guiar al comerciante para que la acepte.

Aquí encontrarás un ejemplo que puedes usar para recuperar el estado del acuerdo de Condiciones del Servicio de 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);
  }
}

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

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

Aceptar las Condiciones del Servicio

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

Cómo aceptar las CDS para tu propia cuenta

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

  1. Llama a termsOfServiceAgreementStates.retrieveForApplication para identificar si se required alguna CDS.
  2. Si se requiere una CDS, anota el termsOfService nombre del required campo (por ejemplo, termsOfService/132).

  3. Llama a termsOfService.accept para aceptar las CDS. Necesitarás el nombre de las CDS, tu ACCOUNT_ID y el regionCode que muestra retrieveForApplication.

    Aquí encontrarás una solicitud de ejemplo:

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

    Una llamada correcta muestra un cuerpo de respuesta vacío y actualiza el estado del acuerdo de CDS de la cuenta.

Cómo guiar a los comerciantes para que acepten las CDS (para proveedores externos)

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

  1. Recuperar las Condiciones del Servicio más recientes: Llama a termsOfService.retrieveLatest para el regionCode y el tipo MERCHANT_CENTER del comerciante para obtener los detalles de la versión más reciente de las Condiciones del Servicio 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. Mostrar las CDS: Usa el fileUri de la respuesta para mostrar el texto completo de las Condiciones del Servicio al comerciante en la IU de tu aplicación.

  3. Obtener la aceptación del comerciante: El comerciante debe aceptar explícitamente las condiciones en tu IU.

  4. Registrar la aceptación con la API: Después de que el comerciante acepte, llama a termsOfService.accept con el name de las CDS obtenidas en el paso 1, el ACCOUNT_ID del comerciante, 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}"
}

Aquí encontrarás un ejemplo que puedes usar para aceptar el acuerdo de Condiciones del Servicio de una cuenta determinada (después de que el comerciante 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");
  }
}

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

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

Consideraciones especiales para los proveedores externos

Como proveedor externo, puedes administrar las CDS de las cuentas de clientes.

Cómo administrar las CDS de las cuentas de clientes

Si operas una cuenta avanzada y creas cuentas de clientes para diferentes empresas, ten en cuenta lo siguiente:

  • Aceptación de la cuenta avanzada: Si una cuenta avanzada proporciona el servicio de agregación de cuentas a las cuentas de clientes, las CDS aceptadas por la cuenta avanzada también se aplicarán a todas sus cuentas de clientes con ese servicio.
  • Visualización y consentimiento: Incluso si la aceptación de la cuenta avanzada cubre las cuentas de clientes, es una práctica recomendada (y podría ser una expectativa legal) mostrar las CDS pertinentes de Google Merchant Center al propietario real de cada una de esas empresas. Debes obtener su consentimiento explícito de que comprenden y aceptan 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 de cliente: Usa termsOfServiceAgreementStates.retrieveForApplication en una cuenta de cliente específica para verificar su estado de CDS y ver si está cubierta por el acuerdo de la cuenta avanzada o si se necesita alguna acción directa.

Cómo administrar las CDS de otras cuentas

Como se detalla en Cómo guiar a los comerciantes para que acepten las CDS, cuando ayudas a una empresa a crear o administrar su propia cuenta, esa empresa (el propietario de la cuenta) debe aceptar personalmente las Condiciones del Servicio . Para facilitar esto, recupera y muestra las CDS y, luego, llama al método termsOfService.accept en su nombre después de que hayan dado su consentimiento explícito a través de tu interfaz.

Anterior
Manage business identity
Siguiente
Create and update regions