Vincule sus cuentas de Merchant Center y Google Ads

Si usas

Puedes cambiar el estado de las vinculaciones de Merchant Center en tu cuenta de Google Ads. Para ello, usa la interfaz web de Google Ads para aprobar o rechazar una invitación. También puedes actualizar las invitaciones o quitar las vinculaciones existentes con la API de Google Ads, tal como se explica a continuación.

Obtén una lista de todas las invitaciones de Merchant Center

Puedes ejecutar un informe de la API de Google Ads con la siguiente consulta de GAQL para recuperar una lista de todas las invitaciones pendientes para vincular un ID de cliente de Google Ads a una cuenta de Merchant Center.

SELECT
   product_link_invitation.merchant_center.merchant_center_id,
   product_link_invitation.type
FROM product_link_invitation
WHERE product_link_invitation.status = 'PENDING_APPROVAL'
  AND product_link_invitation.type = 'MERCHANT_CENTER'

Para recuperar todas las invitaciones, quita la condición de filtrado del campo product_link_invitation.status en la consulta anterior.

Cómo aceptar una invitación

Para aprobar la vinculación, configura el estado product_link_invitation como ACCEPTED.

1. Crea un objeto UpdateProductLinkInvitationRequest y establece el campo customer_id como el ID de cliente de Google Ads.

2. Establece el campo resource_name como el nombre del recurso de product_link_invitation.

3. Establece product_link_invitation_status en ACCEPTED.

4. Emite una llamada a la API de UpdateProductLinkInvitation.

Si un usuario que ya es administrador en ambas cuentas intenta el flujo de invitación, se genera un error NO_INVITATION_REQUIRED. En esos casos, puedes verificar este error y recurrir al flujo de vínculo directo.

Cómo rechazar una invitación

Rechazar una invitación es similar a aceptar una invitación, excepto que el campo product_link_invitation_status se establece en REJECTED. Si se rechaza una invitación, permanecerá en el estado REJECTED y no se podrá aceptar. Luego, debes crear una nueva invitación si es necesario.

Vinculación directa sin invitación

Si el usuario que intenta vincular la cuenta de Google Ads a la de Merchant Center es administrador de ambas cuentas, puedes omitir el paso de invitación y vincular ambas cuentas directamente con la API de Google Ads.

1. Crea un objeto CreateProductLinkRequest y establece el campo customer_id como el ID de cliente de Google Ads.

2. Crea un objeto ProductLink nuevo y configura su campo merchant_center_id con el ID de la cuenta de Merchant Center.

3. Establece ProductLink en el campo product_link del objeto de la solicitud.

4. Emite una llamada a la API CreateProductLink.

Si un usuario que no tiene los permisos suficientes intenta realizar la vinculación directa, se mostrará un error CREATION_NOT_PERMITTED. En esos casos, puedes revisar este error y recurrir al flujo de invitación.

Obtén una lista de todas las vinculaciones de Merchant Center

Puedes ejecutar un informe de la API de Google Ads con la siguiente consulta de GAQL para recuperar una lista de vínculos de un ID de cliente de Google Ads.

SELECT
  product_link.merchant_center.merchant_center_id,
  product_link.product_link_id
FROM product_link
WHERE product_link.type = 'MERCHANT_CENTER'

Cómo desvincular un vínculo

Sigue estos pasos para desvincular un vínculo:

1. Crea un objeto RemoveProductLinkRequest y establece el campo customer_id como el ID de cliente de Google Ads.

2. Establece resource_name como el nombre del recurso de product_link.

3. Emite una llamada a la API RemoveProductLink.

Si usas

Puedes cambiar el estado de las vinculaciones de Merchant Center en tu cuenta de Google Ads. Para ello, usa la interfaz web de Google Ads para aprobar o rechazar una solicitud de vinculación, o bien quitar una vinculación existente. Quita las vinculaciones existentes y actualiza las invitaciones con la API de Google Ads de la siguiente manera:

1. Si deseas recuperar todos los vínculos de Merchant Center, realiza una solicitud para recuperar objetos del recurso MerchantCenterLink.

2. Puedes verificar el campo MerchantCenterLinkStatus de cada objeto MerchantCenterLink para encontrar el estado del vínculo.

3. Para aprobar un vínculo de PENDING, establece el campo MerchantCenterLinkStatus en ENABLED.

   1. Para rechazar un vínculo de PENDING, quita el objeto MerchantCenterLink.
   2. Para desvincular un vínculo de ENABLED, quita el objeto MerchantCenterLink.

Paso 1: Obtén una lista de todas las vinculaciones de Merchant Center

Puedes usar el MerchantCenterLinkService para recuperar una lista de vinculaciones de un ID de cliente de Google Ads.

En el siguiente ejemplo de código, se muestra cómo usar ListMerchantCenterLinks para solicitar todos los vínculos de customer_id.

ListMerchantCenterLinksResponse response =
    merchantCenterLinkService.listMerchantCenterLinks(
        ListMerchantCenterLinksRequest.newBuilder()
            .setCustomerId(Long.toString(customerId))
            .build());

System.out.printf(
    "%d Merchant Center link(s) found with the following details:%n",
    response.getMerchantCenterLinksCount());
ApproveMerchantCenterLink.java
      

ListMerchantCenterLinksResponse response =
    merchantCenterLinkService.ListMerchantCenterLinks(customerId.ToString());

Console.WriteLine($"{response.MerchantCenterLinks.Count} Merchant Center link(s)" +
    $" found with the following details:");
ApproveMerchantCenterLink.cs
      

// Lists all merchant links of the specified customer ID.
$merchantCenterLinkServiceClient = $googleAdsClient->getMerchantCenterLinkServiceClient();
$response = $merchantCenterLinkServiceClient->listMerchantCenterLinks(
    ListMerchantCenterLinksRequest::build($customerId)
);
printf(
    "%d Merchant Center link(s) found with the following details:%s",
    $response->getMerchantCenterLinks()->count(),
    PHP_EOL
);
ApproveMerchantCenterLink.php
      

# Retrieve all the existing Merchant Center links.
response = merchant_center_link_service.list_merchant_center_links(
    customer_id=customer_id
)
print(
    f"{len(response.merchant_center_links)} Merchant Center link(s) "
    "found with the following details:"
)
approve_merchant_center_link.py
      

# Retrieve all the existing Merchant Center links.
response = client.service.v14.merchant_center_link.list_merchant_center_links(
  customer_id: customer_id,
)
approve_merchant_center_link.rb
      

# List all Merchant Center links of the specified customer ID.
my $merchant_center_link_service = $api_client->MerchantCenterLinkService();
my $response =
  $merchant_center_link_service->list({customerId => $customer_id});
printf
  "%d Merchant Center link(s) found with the following details:\n",
  scalar @{$response->{merchantCenterLinks}};
approve_merchant_center_link.pl
      

Paso 2: Busca el estado de vinculación de Merchant Center

Una vez que encuentres el MerchantCenterLinkService correspondiente a la cuenta de Merchant Center que quieres aprobar o rechazar, debes revisar el status. La enumeración MerchantCenterLinkStatus describe los estados posibles.

System.out.printf(
    "Link '%s' has status '%s'.%n",
    merchantCenterLink.getResourceName(), merchantCenterLink.getStatus());
ApproveMerchantCenterLink.java
      

Console.Write($"Link '{merchantCenterLink.ResourceName}' has status " +
    $"'{merchantCenterLink.Status}'.");
ApproveMerchantCenterLink.cs
      

printf(
    "Link '%s' has status '%s'.%s",
    $merchantCenterLink->getResourceName(),
    MerchantCenterLinkStatus::name($merchantCenterLink->getStatus()),
    PHP_EOL
);
ApproveMerchantCenterLink.php
      

print(
    f"Link '{merchant_center_link.resource_name}' has status "
    f"'{merchant_center_link.status.name}'."
)
approve_merchant_center_link.py
      

#  Iterate the results, and filter for links with pending status.
response.merchant_center_links.each do |link|
  # Enables the pending link.
  if link.status == :PENDING && link.id.to_s == merchant_center_account_id
    # Creates the update operation.
    update_operation = client.operation.v14.update_resource.merchant_center_link(
      link.resource_name) do |updated_link|
      updated_link.status = :ENABLED
    end

    # Updates the link.
    mutate_response = client.service.v14.merchant_center_link.mutate_merchant_center_link(
      customer_id: customer_id,
      operation: update_operation,
    )

    # Display the result.
    puts "Enabled a Merchant Center Link with resource name " \
      "#{mutate_response.result.resource_name} " \
      "to Google Ads account #{customer_id}"
  end
end
approve_merchant_center_link.rb
      

printf
  "Link '%s' has status '%s'.\n",
  $merchant_center_link->{resourceName},
  $merchant_center_link->{status};
approve_merchant_center_link.pl
      

Paso 3a: Aprueba una solicitud de vinculación

Si el estado del vínculo es PENDING, puedes aprobar la vinculación si configuras el estado como ENABLED. Puedes usar el objeto MerchantCenterLink existente para ayudar a construir un objeto MerchantCenterLink actualizado con el status establecido en ENABLED.

En el siguiente ejemplo de código, se muestra cómo construir la operación de mutación que se necesita para cambiar solo el estado.

private void updateMerchantCenterLinkStatus(
    MerchantCenterLinkServiceClient merchantCenterLinkServiceClient,
    long customerId,
    MerchantCenterLink merchantCenterLink,
    MerchantCenterLinkStatus status) {
  // Creates an updated MerchantCenterLink object derived from the original, but with the new
  // status.
  MerchantCenterLink updatedMerchantCenterLink =
      merchantCenterLink.toBuilder().setStatus(status).build();

  // Constructs an operation that will update the merchantCenterLink, using the FieldMasks compare
  // utility to derive the update mask from the changes. This mask tells the Google Ads API which
  // attributes of the merchantCenterLink to change. In this case we only want to change the
  // MerchantCenterLinkStatus.
  MerchantCenterLinkOperation operation =
      MerchantCenterLinkOperation.newBuilder()
          .setUpdate(updatedMerchantCenterLink)
          .setUpdateMask(FieldMasks.compare(merchantCenterLink, updatedMerchantCenterLink))
          .build();

  // Sends the operation in a mutate request.
  MutateMerchantCenterLinkResponse response =
      merchantCenterLinkServiceClient.mutateMerchantCenterLink(
          String.valueOf(customerId), operation);

  // Prints the resource name of the updated object.
  MutateMerchantCenterLinkResult merchantCenterLinkResult = response.getResult();
  System.out.printf(
      "Updated Merchant Center link with resource name: '%s'.%n",
      merchantCenterLinkResult.getResourceName());
}
ApproveMerchantCenterLink.java
      

private static void UpdateMerchantCenterLinkStatus(long customerId,
    MerchantCenterLinkServiceClient merchantCenterLinkService,
    MerchantCenterLink merchantCenterLink, MerchantCenterLinkStatus status)
{
    // Enables the pending link.
    MerchantCenterLink linkToUpdate = new MerchantCenterLink()
    {
        ResourceName = merchantCenterLink.ResourceName,
        Status = status
    };

    // Creates an operation.
    MerchantCenterLinkOperation operation = new MerchantCenterLinkOperation()
    {
        Update = linkToUpdate,
        UpdateMask = FieldMasks.AllSetFieldsOf(linkToUpdate)
    };

    // Updates the link.
    MutateMerchantCenterLinkResponse mutateResponse =
        merchantCenterLinkService.MutateMerchantCenterLink(
            customerId.ToString(), operation);

    // Displays the result.
    Console.WriteLine($"The status of Merchant Center Link with resource name " +
        $"'{mutateResponse.Result.ResourceName}' to Google Ads account : " +
        $"{customerId} was updated to {status}.");
}
ApproveMerchantCenterLink.cs
      

private static function updateMerchantCenterLinkStatus(
    MerchantCenterLinkServiceClient $merchantCenterLinkServiceClient,
    int $customerId,
    MerchantCenterLink $merchantCenterLink,
    int $newMerchantCenterLinkStatus
) {
    // Creates an updated MerchantCenterLink object derived from the original, but with the
    // specified status.
    $merchantCenterLinkToUpdate = new MerchantCenterLink([
        'resource_name' => $merchantCenterLink->getResourceName(),
        'status' => $newMerchantCenterLinkStatus
    ]);

    // Constructs an operation that will update the Merchant Center link,
    // using the FieldMasks utility to derive the update mask. This mask tells the
    // Google Ads API which attributes of the Merchant Center link you want to change.
    $merchantCenterLinkOperation = new MerchantCenterLinkOperation();
    $merchantCenterLinkOperation->setUpdate($merchantCenterLinkToUpdate);
    $merchantCenterLinkOperation->setUpdateMask(
        FieldMasks::allSetFieldsOf($merchantCenterLinkToUpdate)
    );

    // Issues a mutate request to update the Merchant Center link and prints some
    // information.
    $response = $merchantCenterLinkServiceClient->mutateMerchantCenterLink(
        MutateMerchantCenterLinkRequest::build($customerId, $merchantCenterLinkOperation)
    );
    printf(
        "Approved a Merchant Center Link with resource name '%s' to the Google Ads "
        . "account '%s'.%s",
        $response->getResult()->getResourceName(),
        $customerId,
        PHP_EOL
    );
}
ApproveMerchantCenterLink.php
      

def update_merchant_center_link_status(
    client,
    customer_id,
    merchant_center_link_service,
    merchant_center_link,
    status,
):
    """Updates the status of a Merchant Center link request.

    Args:
        client: An initialized GoogleAdsClient instance.
        customer_id: The client customer ID string.
        merchant_center_link_service: A merchant center link service instance.
        merchant_center_link: The merchant center link to be modified.
        status: The updated status to apply to the merchant center link.
    """
    # Creates an operation.
    operation = client.get_type("MerchantCenterLinkOperation")
    link_to_update = operation.update
    link_to_update.resource_name = merchant_center_link.resource_name
    # Enables the pending link.
    link_to_update.status = status
    client.copy_from(
        operation.update_mask,
        protobuf_helpers.field_mask(None, link_to_update._pb),
    )

    # Updates the link.
    mutate_response = merchant_center_link_service.mutate_merchant_center_link(
        customer_id=customer_id, operation=operation
    )

    # Displays the result.
    print(
        "The status of Merchant Center Link with resource name "
        f"'{mutate_response.result.resource_name}' to Google Ads account : "
        f"{customer_id} was updated to {status.name}."
    )
approve_merchant_center_link.py
      

#  Iterate the results, and filter for links with pending status.
response.merchant_center_links.each do |link|
  # Enables the pending link.
  if link.status == :PENDING && link.id.to_s == merchant_center_account_id
    # Creates the update operation.
    update_operation = client.operation.v14.update_resource.merchant_center_link(
      link.resource_name) do |updated_link|
      updated_link.status = :ENABLED
    end

    # Updates the link.
    mutate_response = client.service.v14.merchant_center_link.mutate_merchant_center_link(
      customer_id: customer_id,
      operation: update_operation,
    )

    # Display the result.
    puts "Enabled a Merchant Center Link with resource name " \
      "#{mutate_response.result.resource_name} " \
      "to Google Ads account #{customer_id}"
  end
end
approve_merchant_center_link.rb
      

foreach my $merchant_center_link (@{$response->{merchantCenterLinks}}) {
  printf
    "Link '%s' has status '%s'.\n",
    $merchant_center_link->{resourceName},
    $merchant_center_link->{status};

  # Approve a pending link request for a Google Ads account with the specified
  # customer ID from a Merchant Center account with the specified Merchant
  # Center account ID.
  if ( $merchant_center_link->{id} == $merchant_center_account_id
    && $merchant_center_link->{status} eq PENDING)
  {
    # Update the status of Merchant Center link to 'ENABLED' to approve the link.
    update_merchant_center_link_status(
      $merchant_center_link_service, $customer_id,
      $merchant_center_link,         ENABLED
    );
    # There is only one MerchantCenterLink object for a given Google Ads account
    # and Merchant Center account, so we can break early.
    last;
  }
}
approve_merchant_center_link.pl
      

Paso 3b: Rechaza una solicitud de vinculación

Para rechazar una solicitud de vinculación con un vínculo en el estado PENDING, quita el MerchantCenterLink. Para ello, construye una operación remove para el recurso con MutateMerchantCenterLinkRequest:

private void removeMerchantCenterLink(
    MerchantCenterLinkServiceClient merchantCenterLinkServiceClient,
    long customerId,
    MerchantCenterLink merchantCenterLink) {
  // Creates a single remove operation, specifying the Merchant Center link resource name.
  MerchantCenterLinkOperation operation =
      MerchantCenterLinkOperation.newBuilder()
          .setRemove(merchantCenterLink.getResourceName())
          .build();

  // Sends the operation in a mutate request.
  MutateMerchantCenterLinkResponse response =
      merchantCenterLinkServiceClient.mutateMerchantCenterLink(
          Long.toString(customerId), operation);
  MutateMerchantCenterLinkResult result = response.getResult();
  System.out.printf(
      "Removed Merchant Center link with resource name: '%s'.%n", result.getResourceName());
}
RejectMerchantCenterLink.java
      

private void RemoveMerchantCenterLink(
    MerchantCenterLinkServiceClient merchantCenterLinkServiceClient,
    long customerId, MerchantCenterLink merchantCenterLink)
{
    // Creates a single remove operation, specifying the Merchant Center link resource name.
    MerchantCenterLinkOperation operation = new MerchantCenterLinkOperation
    {
        Remove = merchantCenterLink.ResourceName
    };

    // Sends the operation in a mutate request.
    MutateMerchantCenterLinkResponse response =
        merchantCenterLinkServiceClient.MutateMerchantCenterLink(
            customerId.ToString(), operation);
    Console.WriteLine("Removed Merchant Center Link with resource name: " +
                      $"{response.Result.ResourceName}");
}
RejectMerchantCenterLink.cs
      

private static function removeMerchantCenterLink(
    MerchantCenterLinkServiceClient $merchantCenterLinkServiceClient,
    int $customerId,
    MerchantCenterLink $merchantCenterLink
) {
    // Creates a single remove operation, specifying the Merchant Center link resource name.
    $merchantCenterLinkOperation = new MerchantCenterLinkOperation();
    $merchantCenterLinkOperation->setRemove($merchantCenterLink->getResourceName());

    // Issues a mutate request to remove the link and prints the result info.
    $response = $merchantCenterLinkServiceClient->mutateMerchantCenterLink(
        MutateMerchantCenterLinkRequest::build(
            $customerId,
            $merchantCenterLinkOperation
        )
    );
    $mutateMerchantCenterLinkResult = $response->getResult();
    printf(
        "Removed Merchant Center link with resource name: '%s'.%s",
        $mutateMerchantCenterLinkResult->getResourceName(),
        PHP_EOL
    );
}
RejectMerchantCenterLink.php
      

def remove_merchant_center_link(
    client, merchant_center_link_service, customer_id, merchant_center_link
):
    """Removes a Merchant Center link from a Google Ads client customer account.

    Args:
        client: An initialized Google Ads client.
        merchant_center_link_service: An initialized
            MerchantCenterLinkService client.
        customer_id: The Google Ads customer ID of the account that has the link
            request.
        merchant_center_link: The MerchantCenterLink object to remove.
    """
    # Create a single remove operation, specifying the Merchant Center link
    # resource name.
    operation = client.get_type("MerchantCenterLinkOperation")
    operation.remove = merchant_center_link.resource_name

    # Send the operation in a mutate request.
    response = merchant_center_link_service.mutate_merchant_center_link(
        customer_id=customer_id, operation=operation
    )
    print(
        "Removed Merchant Center link with resource name "
        f"'{response.result.resource_name}'."
    )
reject_merchant_center_link.py
      

def remove_merchant_center_link(
  client,
  merchant_center_link_service,
  customer_id,
  link)
  # Creates a single remove operation, specifying the Merchant Center link
  # resource name.
  operation = client.operation.v14.remove_resource.merchant_center_link(link.resource_name)

  # Issues a mutate request to remove the link and prints the result info.
  response = merchant_center_link_service.mutate_merchant_center_link(
    customer_id: customer_id,
    operation: operation,
  )
  puts "Removed Merchant Center link with resource name: " \
    "#{response.result.resource_name}"
end
reject_merchant_center_link.rb
      

sub reject_merchant_center_link {
  my ($api_client, $customer_id, $merchant_center_account_id) = @_;

  my $merchant_center_link_service = $api_client->MerchantCenterLinkService();

  # Reject a pending link request or unlink an enabled link for a Google Ads
  # account with $customer_id from a Merchant Center account with $merchant_center_account_id.
  my $response =
    $merchant_center_link_service->list({customerId => $customer_id});
  printf
    "%d Merchant Center link(s) found with the following details:\n",
    scalar @{$response->{merchantCenterLinks}};

  foreach my $merchant_center_link (@{$response->{merchantCenterLinks}}) {
    printf
      "Link '%s' has status '%s'.\n",
      $merchant_center_link->{resourceName},
      $merchant_center_link->{status};

    # Check if there is a link for the Merchant Center account we are looking for.
    if ($merchant_center_account_id == $merchant_center_link->{id}) {
      # If the Merchant Center link is pending, reject it by removing the link.
      # If the Merchant Center link is enabled, unlink Merchant Center from Google
      # Ads by removing the link.
      # In both cases, the remove action is the same.
      remove_merchant_center_link($merchant_center_link_service, $customer_id,
        $merchant_center_link);
      # There is only one MerchantCenterLink object for a given Google Ads account
      # and Merchant Center account, so we can break early.
      last;
    }
  }
  return 1;
}
reject_merchant_center_link.pl
      

Paso 3c: Desvincula un vínculo

Para desvincular un vínculo en el estado ENABLED, quita el MerchantCenterLink construyendo una operación remove para el recurso con MutateMerchantCenterLinkRequest. Es lo mismo que rechazar una solicitud de vinculación.