Conferir os problemas que afetam uma conta do comerciante

Os problemas na conta afetam a visibilidade dos produtos e a capacidade de participar de vários programas do Merchant Center. A sub-API Account permite recuperar uma lista de problemas que afetam sua conta de comerciante. Isso ajuda a identificar e resolver problemas de forma proativa.

Você é responsável por obedecer às políticas de anúncios do Shopping e listagens sem custo financeiro. O Google Shopping se reserva o direito de aplicar essas políticas e responder adequadamente se encontrarmos conteúdo ou comportamento que as viole.

Cada AccountIssue fornece detalhes como:

• title: um resumo do problema.
• severity: a gravidade do problema. Por exemplo:
  • CRITICAL: um problema que impede a veiculação de ofertas.
  • ERROR: um problema que pode afetar as ofertas ou indicar um problema.
  • SUGGESTION: uma recomendação de melhoria.
• impactedDestinations: os programas (como anúncios do Shopping ou listagens sem custo financeiro) e as regiões afetadas pelo problema, além da gravidade nesses contextos.
• detail: uma mensagem com mais contexto sobre o problema.
• documentationUri: um link para o artigo da Central de Ajuda sobre como resolver o problema.

Considerações especiais

• Internacionalização (i18n): ao listar problemas da conta, é possível especificar um language_code (por exemplo, "en-US", "fr-FR") e um time_zone (como "America/Los_Angeles", "Europe/Paris") na sua solicitação. Isso verifica se as strings legíveis na resposta, como o problema detail, estão localizadas corretamente. Se esses campos não forem fornecidos, a API vai usar o inglês ("en-US") e o fuso horário "America/Los_Angeles" (horário do Pacífico) por padrão.
• Paginação: a API oferece suporte à paginação usando os parâmetros page_size e page_token no ListAccountIssuesRequest. Isso permite recuperar problemas em partes gerenciáveis. O máximo de page_size é 1.000, e o padrão é 50.
• Ordenação: os problemas retornados pela API geralmente são ordenados por gravidade e uma prioridade interna, semelhante à forma como são exibidos no Merchant Center. A API não é compatível com a classificação personalizada.
• Fonte de dados: a sub-API Account Issues recupera dados do mesmo back-end usado pela página de diagnóstico no Merchant Center.

Recuperar problemas da sua conta

Para listar problemas da conta, envie uma solicitação GET para o método accounts.issues.list:

GET https://merchantapi.googleapis.com/accounts/v1beta/accounts/{ACCOUNT_ID}/issues?language_code=en-GB&time_zone.id=Europe/London&page_size=10

Confira um exemplo de resposta para uma subconta suspensa por uma violação de "página de destino não funcionando".

{
  "accountIssues": [
    {
      "name": "accounts/ACCOUNT_ID/issues/home-page-issue",
      "title": "Online store not confirmed",
      "severity": "CRITICAL",
      "impactedDestinations": [
        {
          "reportingContext": "SHOPPING_ADS",
          "impacts": [
            {
              "regionCode": "001",
              "severity": "CRITICAL"
            }
          ]
        }
      ],
      "detail": "The ownership of the online store must be verified through Merchant Center",
      "documentationUri": "https://support.google.com/merchants/answer/176793?hl=en-US"
    },
    {
      "name": "accounts/ACCOUNT_ID/issues/editorial-and-professional-standards-destination-url-down-policy",
      "title": "Landing page not working",
      "severity": "CRITICAL",
      "impactedDestinations": [
        {
          "reportingContext": "SHOPPING_ADS",
          "impacts": [
            {
              "regionCode": "ES",
              "severity": "CRITICAL"
            }
          ]
        },
        {
          "reportingContext": "DEMAND_GEN_ADS",
          "impacts": [
            {
              "regionCode": "ES",
              "severity": "CRITICAL"
            }
          ]
        },
        {
          "reportingContext": "VIDEO_ADS",
          "impacts": [
            {
              "regionCode": "ES",
              "severity": "CRITICAL"
            }
          ]
        }
      ],
      "detail": "Broken landing pages or broken links in your online store are not allowed",
      "documentationUri": "https://support.google.com/merchants/answer/12079604?hl=en-US"
    },
    {
      "name": "accounts/ACCOUNT_ID/issues/pending-phone-verification",
      "title": "Your phone number needs to be verified",
      "severity": "CRITICAL",
      "detail": "Verify your phone number to confirm your identity",
      "documentationUri": "https://support.google.com/merchants/answer/12471579?hl=en-US"
    },
    {
      "name": "accounts/ACCOUNT_ID/issues/pending-address-and-phone",
      "title": "Missing business address",
      "severity": "CRITICAL",
      "detail": "Provide a valid business address in Merchant Center",
      "documentationUri": "https://support.google.com/merchants/answer/12471579?hl=en-US"
    }
  ]
}

Listar problemas de uma conta específica

Este caso de uso mostra como recuperar todos os problemas no nível da conta de uma determinada conta do Merchant Center. As informações retornadas podem ajudar você a identificar e resolver problemas que afetam a performance e a qualificação da sua conta para vários programas.

AppsScript

/**
 * Lists all issues for a given Merchant Center account.
 */
function listAccountIssues() {
  // IMPORTANT:
  // Enable the Merchant API Accounts sub-API Advanced Service and call it
  // "MerchantApiAccounts"

  // Replace this with your Merchant Center ID.
  const accountId = "<MERCHANT_CENTER_ID>";

  // Construct the parent name
  const parent = 'accounts/' + accountId;

  try {
    console.log('Sending list Account Issues request');
    // Set pageSize to the maximum value (default: 50)
    let pageSize = 100;
    let pageToken;
    let count = 0;
    // Call the Account.Issues.list API method. Use the pageToken to iterate
    // through all pages of results.
    do {
      response = MerchantApiAccounts.Accounts.Issues.list(parent, {pageSize, pageToken});
      for (const issue of response.accountIssues) {
        console.log(issue);
        count++;
      }
      pageToken = response.nextPageToken;
    } while (pageToken);  // Exits when there is no next page token.
    console.log('The following count of Account Issues were returned: ', count);
  } catch (e) {
    console.log('ERROR!');
    console.log(e);
  }
}
list_account_issues_sample.gs

Java

import com.google.api.gax.core.FixedCredentialsProvider;
import com.google.auth.oauth2.GoogleCredentials;
import com.google.shopping.merchant.accounts.v1beta.AccountIssue;
import com.google.shopping.merchant.accounts.v1beta.AccountIssueServiceClient;
import com.google.shopping.merchant.accounts.v1beta.AccountIssueServiceClient.ListAccountIssuesPagedResponse;
import com.google.shopping.merchant.accounts.v1beta.AccountIssueServiceSettings;
import com.google.shopping.merchant.accounts.v1beta.AccountName;
import com.google.shopping.merchant.accounts.v1beta.ListAccountIssuesRequest;
import shopping.merchant.samples.utils.Authenticator;
import shopping.merchant.samples.utils.Config;

/**
 * This class demonstrates how to list all the account issues of an account.
 *
 * <p>If you want to query the account issues of all the sub-accounts of an advanced account, see
 * ListAdvancedAccountIssuesSampleAsync.
 */
public class ListAccountIssuesSample {

  public static void listAccountIssues(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.
    AccountIssueServiceSettings accountIssueServiceSettings =
        AccountIssueServiceSettings.newBuilder()
            .setCredentialsProvider(FixedCredentialsProvider.create(credential))
            .build();

    // Calls the API and catches and prints any network failures/errors.
    try (AccountIssueServiceClient accountIssueServiceClient =
        AccountIssueServiceClient.create(accountIssueServiceSettings)) {

      // Gets the account ID from the config file.
      String accountId = config.getAccountId().toString();

      // Creates account name to identify account.
      String name = AccountName.newBuilder().setAccount(accountId).build().toString();
      ListAccountIssuesRequest request =
          ListAccountIssuesRequest.newBuilder().setParent(name).build();

      System.out.println("Sending list account issues request:");
      ListAccountIssuesPagedResponse response =
          accountIssueServiceClient.listAccountIssues(request);

      int count = 0;

      // Iterates over all rows in all pages and prints the issue in each row.
      // Automatically uses the `nextPageToken` if returned to fetch all pages of data.
      for (AccountIssue accountIssue : response.iterateAll()) {
        System.out.println(accountIssue);
        count++;
      }
      System.out.print("The following count of account issues were returned: ");
      System.out.println(count);
    } catch (Exception e) {
      System.out.println("An error has occured: ");
      System.out.println(e);
    }
  }

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

PHP

use Google\ApiCore\ApiException;
use Google\Shopping\Merchant\Accounts\V1beta\Client\AccountIssueServiceClient;
use Google\Shopping\Merchant\Accounts\V1beta\ListAccountIssuesRequest;

/**
 * Lists all the account issues of an account.
 */
class ListAccountIssues
{
    /**
     * A helper function to create the parent string.
     *
     * @param array $accountId
     *      The account.
     *
     * @return string The parent has the format: `accounts/{account_id}`
     */
    private static function getParent($accountId)
    {
        return sprintf("accounts/%s", $accountId);
    }

    /**
     * Lists all the account issues for a given Merchant Center account.
     *
     * @param array $config
     *      The configuration data used for authentication and getting the acccount ID.
     * @return void
     */
    public static function listAccountIssuesSample($config): void
    {
        // Gets the OAuth credentials.
        $credentials = Authentication::useServiceAccountOrTokenFile();

        // Creates options config.
        $options = ['credentials' => $credentials];

        // Creates a client.
        $accountIssueServiceClient = new AccountIssueServiceClient($options);

        // Creates parent.
        $parent = self::getParent($config['accountId']);

        // Creates the request.
        $request = new ListAccountIssuesRequest(['parent' => $parent]);

        // Calls the API and catches and prints any network failures/errors.
        try {
            print "Sending list account issues request:\n";
            $response = $accountIssueServiceClient->listAccountIssues($request);

            $count = 0;
            // Iterates over all elements and prints the issue in each row.
            foreach ($response->iterateAllElements() as $accountIssue) {
                print_r($accountIssue);
                $count++;
            }
            print "The following count of account issues were returned: ";
            print $count . "\n";
        } catch (ApiException $e) {
            print "An error has occured: \n";
            print $e->getMessage() . "\n";
        }
    }

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

        // Lists the account issues.
        self::listAccountIssuesSample($config);
    }
}

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

Python

from examples.authentication import configuration
from examples.authentication import generate_user_credentials
from google.shopping.merchant_accounts_v1beta import AccountIssueServiceClient
from google.shopping.merchant_accounts_v1beta import ListAccountIssuesRequest

_ACCOUNT = configuration.Configuration().read_merchant_info()
_PARENT = f"accounts/{_ACCOUNT}"


def list_account_issues():
  """Lists all the account issues of an account."""

  # Gets OAuth Credentials.
  credentials = generate_user_credentials.main()

  # Creates a client.
  client = AccountIssueServiceClient(credentials=credentials)

  request = ListAccountIssuesRequest(parent=_PARENT)

  print("Sending list account issues request:")

  # Makes the request and catches and prints any error messages.
  try:
    response = client.list_account_issues(request=request)
    count = 0

    for account_issue in response:
      print(account_issue)
      count += 1
    print("The following count of account issues were returned: ")
    print(count)

  except RuntimeError as e:
    print("An error has occured: ")
    print(e)


if __name__ == "__main__":
  list_account_issues()
list_account_issues_sample.py

cURL

curl -X GET \
"https://merchantapi.googleapis.com/accounts/v1beta/accounts/{ACCOUNT_ID}/issues?language_code=en-US&time_zone.id=America/Los_Angeles&page_size=50" \
--header "Authorization: Bearer {YOUR_ACCESS_TOKEN}" \
--header "Accept: application/json"

Listar problemas de conta para todas as subcontas de uma conta avançada

Se você gerencia uma conta avançada, talvez seja necessário verificar problemas em todas as suas subcontas. Este exemplo demonstra como listar subcontas e, para cada uma delas, recuperar de forma assíncrona os problemas da conta. Essa abordagem é eficiente para gerenciar várias contas.

Java

import static com.google.api.core.ApiFutures.transform;

import com.google.api.core.ApiFuture;
import com.google.api.core.ApiFutureCallback;
import com.google.api.core.ApiFutures;
import com.google.api.gax.core.FixedCredentialsProvider;
import com.google.auth.oauth2.GoogleCredentials;
import com.google.common.util.concurrent.MoreExecutors;
import com.google.shopping.merchant.accounts.v1beta.AccountIssueServiceClient;
import com.google.shopping.merchant.accounts.v1beta.AccountIssueServiceSettings;
import com.google.shopping.merchant.accounts.v1beta.AccountName;
import com.google.shopping.merchant.accounts.v1beta.AccountsServiceClient;
import com.google.shopping.merchant.accounts.v1beta.AccountsServiceClient.ListSubAccountsPagedResponse;
import com.google.shopping.merchant.accounts.v1beta.AccountsServiceSettings;
import com.google.shopping.merchant.accounts.v1beta.ListAccountIssuesRequest;
import com.google.shopping.merchant.accounts.v1beta.ListAccountIssuesResponse;
import com.google.shopping.merchant.accounts.v1beta.ListSubAccountsRequest;
import java.io.IOException;
import java.util.AbstractMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.concurrent.Executor;
import java.util.stream.Collectors;
import java.util.stream.StreamSupport;
import shopping.merchant.samples.utils.Authenticator;
import shopping.merchant.samples.utils.Config;

/**
 * This class demonstrates how to list the account issues of all the sub-accounts of an advanced
 * account.
 */
public class ListAdvancedAccountIssuesAsyncSample {

  /** Returns the list of issues for the given account. */
  private static ApiFuture<ListAccountIssuesResponse> getAccountIssues(
      AccountIssueServiceClient accountIssueServiceClient, String account) {
    return accountIssueServiceClient
        .listAccountIssuesCallable()
        .futureCall(ListAccountIssuesRequest.newBuilder().setParent(account).build());
  }

  /**
   * Returns a map of account issues where key is the sub-account resource name and the value is the
   * list of issues for each sub-account. Takes the API clients and the name of the advanced account
   * as input.
   */
  private static ApiFuture<Map<String, ListAccountIssuesResponse>> getSubAccountIssues(
      AccountsServiceClient accountsServiceClient,
      AccountIssueServiceClient accountIssueServiceClient,
      String advancedAccount)
      throws IOException {

    // Creates a direct executor to run the transform functions.
    Executor executor = MoreExecutors.directExecutor();

    // The parent has the format: accounts/{account}
    ListSubAccountsRequest request =
        ListSubAccountsRequest.newBuilder().setProvider(advancedAccount).build();
    System.out.println("Sending list subaccounts request:");

    // Lists all sub-accounts of the advanced account.
    ListSubAccountsPagedResponse listSubAccountsResponse =
        accountsServiceClient.listSubAccounts(request);

    // Iterates over all subAccounts and lists account issues for each.
    // Automatically uses the `nextPageToken` if returned to fetch all pages of data.
    List<ApiFuture<AbstractMap.SimpleEntry<String, ListAccountIssuesResponse>>>
        accountIssuesFutures =
            StreamSupport.stream(listSubAccountsResponse.iterateAll().spliterator(), false)
                .map(
                    account ->
                        transform(
                            getAccountIssues(accountIssueServiceClient, account.getName()),
                            (ListAccountIssuesResponse response) ->
                                new AbstractMap.SimpleEntry<>(account.getName(), response),
                            executor))
                .collect(Collectors.toList());

    // Collects all the responses into a single future.
    ApiFuture<List<AbstractMap.SimpleEntry<String, ListAccountIssuesResponse>>> accountIssuesList =
        ApiFutures.allAsList(accountIssuesFutures);

    // Transforms the list of responses into a map.
    return transform(
        accountIssuesList,
        (List<AbstractMap.SimpleEntry<String, ListAccountIssuesResponse>> list) ->
            list.stream()
                .collect(
                    Collectors.toMap(
                        AbstractMap.SimpleEntry::getKey,
                        AbstractMap.SimpleEntry::getValue,
                        (a, b) -> a)),
        executor);
  }

  public static void listAccountIssues(Config config) throws Exception {

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

    // Gets the account ID from the config file.
    // Make sure to use the advanced account ID here, otherwise the API will return an error.
    String accountId = config.getAccountId().toString();

    // Creates account name to identify account.
    String parent = AccountName.newBuilder().setAccount(accountId).build().toString();

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

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

    // Calls the API and catches and prints any network failures/errors.
    try (AccountsServiceClient accountsServiceClient =
            AccountsServiceClient.create(accountsServiceSettings);
        AccountIssueServiceClient accountIssueServiceClient =
            AccountIssueServiceClient.create(accountIssueServiceSettings)) {

      ApiFuture<Map<String, ListAccountIssuesResponse>> subAccountIssues =
          getSubAccountIssues(accountsServiceClient, accountIssueServiceClient, parent);

      ApiFutures.addCallback(
          subAccountIssues,
          new ApiFutureCallback<Map<String, ListAccountIssuesResponse>>() {
            @Override
            public void onSuccess(Map<String, ListAccountIssuesResponse> results) {
              System.out.println("Account Issues");
              for (Entry<String, ListAccountIssuesResponse> entry : results.entrySet()) {
                System.out.println("Issues for account " + entry.getKey());
                System.out.println(entry.getValue());
              }
            }

            @Override
            public void onFailure(Throwable throwable) {
              System.out.println(throwable);
            }
          },
          MoreExecutors.directExecutor());
    } catch (Exception e) {
      System.out.println("An error has occured: ");
      System.out.println(e);
    }
  }

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

cURL

Para listar problemas de subcontas de uma conta avançada, primeiro liste as subcontas (por exemplo, usando accounts.listSubaccounts) e depois itere por cada ID de subconta para chamar o método accounts.issues.list. O exemplo de curl a seguir mostra como listar problemas de uma única subconta. Repita essa solicitação para cada ID de subconta.

 curl -X GET \
 "https://merchantapi.googleapis.com/accounts/v1beta/accounts/{SUB_ACCOUNT_ID}/issues?language_code=en-US&time_zone.id=America/Los_Angeles&page_size=50" \
 --header "Authorization: Bearer {YOUR_ACCESS_TOKEN}" \
 --header "Accept: application/json"
 ```