API de Avaliações do Google Meu Negócio: Guia Completo de Integração

The API de Avaliações do Google Meu Negócio permite que os desenvolvedores gerenciem programaticamente as avaliações de clientes em locais do Google Business Profile. Seja você um desenvolvedor criando um painel de gestão de reputação, automatizando respostas a avaliações ou agregando feedback de múltiplos locais, esta API oferece a base para uma gestão de avaliações escalável.

Este guia abrange tudo o que você precisa para integrar a API GBP em sua aplicação: desde a configuração inicial até a autenticação OAuth, recuperação de avaliações, resposta programática e tratamento dos inevitáveis casos extremos que surgem com as implementações em produção.

Introdução à API do Google Business Profile

As APIs de negócios do Google evoluíram significativamente ao longo dos anos. A implementação atual utiliza uma combinação de endpoints de API:

• API de Gestão de Conta Empresarial (mybusinessaccountmanagement.googleapis.com/v1): Gerencia contas e permissões
• API de Informação Empresarial do Meu Negócio (mybusinessbusinessinformation.googleapis.com/v1): Gerencia dados de localização
• Minha API de Negócios v4 (mybusiness.googleapis.com/v4): Gerencia avaliações e publicações locais (ainda ativas para esses recursos)

The Avaliações da API do Google Meu Negócio a funcionalidade específica reside na API v4. Embora o Google tenha migrado muitos recursos para os novos endpoints v1, a gestão de avaliações permanece na v4, sem data de descontinuação anunciada.

Nota: O Google atualiza frequentemente a estrutura da sua API. Os endpoints v4 para avaliações são estáveis, mas sempre consulte a documentação oficial para as últimas alterações.

O que Você Pode Fazer com a API de Avaliações

A API GBP suporta estas operações principais de revisão:

Não é possível deletar avaliações de clientes através da API. Apenas o avaliador ou o Google (em caso de violações de políticas) podem remover avaliações.

Configuração do Projeto Google Cloud

Antes de escrever qualquer código, é necessário ter um projeto do Google Cloud configurado corretamente com as APIs adequadas ativadas.

Passo 1: Crie um Projeto no Google Cloud

1. Navegar para Google Cloud Console
2. Crie um novo projeto ou selecione um existente.
3. Anote o ID do seu projeto para uso posterior.

Passo 2: Ative as APIs Necessárias

Ative estas APIs no seu projeto:

# Usando o gcloud CLI
gcloud services enable mybusinessaccountmanagement.googleapis.com
gcloud services enable mybusinessbusinessinformation.googleapis.com
gcloud services enable mybusiness.googleapis.com

Ou habilite-os através do Console da Nuvem:

• API de Gestão de Conta Empresarial
• API de Informação Empresarial do Meu Negócio
• Google Meu Negócio API

Passo 3: Configure a Tela de Consentimento OAuth

1. Ir para APIs & Serviços > Tela de consentimento OAuth
2. Select External tipo de utilizador (a menos que tenha uma organização do Google Workspace)
3. Preencha os campos obrigatórios:
   • Nome do aplicativo
   • Email de suporte ao utilizador
   • Email de contato para desenvolvedores
4. Adicione o escopo necessário: https://www.googleapis.com/auth/business.manage
5. Adicione usuários de teste (obrigatório durante o modo de teste)

Passo 4: Crie Credenciais OAuth

1. Ir para APIs & Serviços > Credenciais
2. Click Criar Credenciais > ID do cliente OAuth
3. Select Aplicação web
4. Adicione suas URIs de redirecionamento autorizadas
5. Guarde o seu ID do Cliente e o Segredo do Cliente.

// Armazene isso em variáveis de ambiente
const config = {
  clientId: process.env.GOOGLE_BUSINESS_CLIENT_ID,
  clientSecret: process.env.GOOGLE_BUSINESS_CLIENT_SECRET,
  redirectUri: process.env.GOOGLE_BUSINESS_REDIRECT_URI,
};

OAuth 2.0 para Google Business

O Google Business Profile requer OAuth 2.0 com acesso offline para obter tokens de atualização. Isso permite que sua aplicação acesse a API sem que os usuários precisem se reautenticar.

Gerando a URL de Autorização

function getGoogleBusinessAuthUrl(state?: string): string {
  const scopes = [
    'https://www.googleapis.com/auth/business.manage',
    'https://www.googleapis.com/auth/userinfo.profile',
    'https://www.googleapis.com/auth/userinfo.email'
  ];

  const params = new URLSearchParams({
    client_id: process.env.GOOGLE_BUSINESS_CLIENT_ID!,
    redirect_uri: process.env.GOOGLE_BUSINESS_REDIRECT_URI!,
    scope: scopes.join(' '),
    response_type: 'code',
    access_type: 'offline',
    prompt: 'consent', // Força a tela de consentimento para garantir o token de atualização
  });

  if (state) {
    params.append('state', state);
  }

  return `https://accounts.google.com/o/oauth2/auth?${params.toString()}`;
}

The consentimento o parâmetro é crítico. Sem ele, o Google pode não retornar um token de atualização em autorizações subsequentes.

Trocando o Código de Autorização

Após o usuário autorizar sua aplicação, o Google o redireciona de volta com um código de autorização:

interface TokenResponse {
  access_token: string;
  refresh_token?: string;
  expires_in: number;
  token_type: string;
  scope: string;
}

async function exchangeCodeForToken(code: string): Promise {
  const response = await fetch('https://oauth2.googleapis.com/token', {
    method: 'POST',
    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
    body: new URLSearchParams({
      code,
      client_id: process.env.GOOGLE_BUSINESS_CLIENT_ID!,
      client_secret: process.env.GOOGLE_BUSINESS_CLIENT_SECRET!,
      redirect_uri: process.env.GOOGLE_BUSINESS_REDIRECT_URI!,
      grant_type: 'authorization_code',
    }),
  });

  if (!response.ok) {
    const errorText = await response.text();
    throw new Error(`Falha na troca do token: ${response.status} ${errorText}`);
  }

  return response.json();
}

Nota: Armazene o token de atualização de forma segura. Ele é retornado apenas na autorização inicial (ou ao usar consentimento).

Estrutura de Conta e Localização

A API GBP utiliza uma estrutura hierárquica: os Usuários possuem Contas, e as Contas contêm Localizações. Você precisa de ambos os IDs para acessar as avaliações.

Buscando Contas de Usuário

interface GBPAccount {
  name: string; // Formato: "accounts/123456789"
  accountName: string;
  type: string;
  role: string;
  state: { status: string };
}

async function getAccounts(accessToken: string): Promise {
  const allAccounts: GBPAccount[] = [];
  let pageToken: string | undefined;

  do {
    const url = new URL('https://mybusinessaccountmanagement.googleapis.com/v1/accounts');
    url.searchParams.set('pageSize', '100');
    if (pageToken) {
      url.searchParams.set('pageToken', pageToken);
    }

    const response = await fetch(url.toString(), {
      headers: { Authorization: `Bearer ${accessToken}` },
    });

    if (!response.ok) {
      throw new Error(`Falha ao buscar contas: ${response.status}`);
    }

    const data = await response.json();
    if (data.accounts) {
      allAccounts.push(...data.accounts);
    }
    pageToken = data.nextPageToken;
  } while (pageToken);

  return allAccounts;
}

Buscando Localizações para uma Conta

interface GBPLocation {
  name: string; // Formato: "locations/987654321"
  title: string;
  storefrontAddress?: {
    addressLines: string[];
    locality: string;
    administrativeArea: string;
    postalCode: string;
    regionCode: string;
  };
  websiteUri?: string;
}

async function getLocations(
  accessToken: string,
  accountId: string
): Promise {
  const allLocations: GBPLocation[] = [];
  let pageToken: string | undefined;

  do {
    const url = new URL(
      `https://mybusinessbusinessinformation.googleapis.com/v1/${accountId}/locations`
    );
    url.searchParams.set('readMask', 'name,title,storefrontAddress,websiteUri');
    url.searchParams.set('pageSize', '100');
    if (pageToken) {
      url.searchParams.set('pageToken', pageToken);
    }

    const response = await fetch(url.toString(), {
      headers: { Authorization: `Bearer ${accessToken}` },
    });

    if (!response.ok) {
      throw new Error(`Falha ao buscar locais: ${response.status}`);
    }

    const data = await response.json();
    if (data.locations) {
      allLocations.push(...data.locations);
    }
    pageToken = data.nextPageToken;
  } while (pageToken);

  return allLocations;
}

Buscando Avaliações com a API de Avaliações do Google Meu Negócio

Com os IDs de conta e localização em mãos, você pode buscar avaliações. O API de Avaliações do Google Meu Negócio retorna as avaliações em ordem cronológica inversa por padrão.

Basic Review Fetching

interface ReviewReply {
  comment: string;
  updateTime: string;
}

interface Review {
  id: string;
  name: string;
  reviewer: {
    displayName: string;
    profilePhotoUrl?: string;
    isAnonymous: boolean;
  };
  rating: number;
  starRating: 'UM' | 'DOIS' | 'TRÊS' | 'QUATRO' | 'CINCO';
  comment?: string;
  createTime: string;
  updateTime: string;
  reviewReply?: ReviewReply;
}

interface ReviewsResponse {
  reviews: Review[];
  averageRating?: number;
  totalReviewCount?: number;
  nextPageToken?: string;
}

async function getReviews(
  accessToken: string,
  accountId: string,
  locationId: string,
  options?: { pageSize?: number; pageToken?: string }
): Promise {
  const accId = accountId.includes('/') ? accountId.split('/').pop() : accountId;
  const locId = locationId.includes('/') ? locationId.split('/').pop() : locationId;

  const pageSize = Math.min(options?.pageSize || 50, 50); // Máximo de 50 por solicitação
  const url = new URL(
    `https://mybusiness.googleapis.com/v4/accounts/${accId}/locations/${locId}/reviews`
  );
  url.searchParams.set('pageSize', String(pageSize));

  if (options?.pageToken) {
    url.searchParams.set('pageToken', options.pageToken);
  }

  const response = await fetch(url.toString(), {
    headers: { Authorization: `Bearer ${accessToken}` },
  });

  if (!response.ok) {
    const errorBody = await response.text();
    throw new Error(`Falha ao buscar avaliações: ${response.status} ${errorBody}`);
  }

  const data = await response.json();

  const starRatingMap: Record = {
    UM: 1,
    DOIS: 2,
    TRÊS: 3,
    QUATRO: 4,
    CINCO: 5,
  };

  const reviews = (data.reviews || []).map((review: any) => ({
    id: review.reviewId || review.name?.split('/').pop(),
    name: review.name,
    reviewer: {
      displayName: review.reviewer?.display

Buscando Todas as Avaliações com Paginação

Para locais com muitas avaliações, será necessário gerenciar a paginação:

async function getAllReviews(
  accessToken: string,
  accountId: string,
  locationId: string
): Promise<Review[]> {
  const allReviews: Review[] = [];
  let pageToken: string | undefined;

  do {
    const response = await getReviews(accessToken, accountId, locationId, {
      pageSize: 50,
      pageToken,
    });

    allReviews.push(...response.reviews);
    pageToken = response.nextPageToken;

    // Adicione um pequeno atraso para evitar limitação de taxa
    if (pageToken) {
      await new Promise((resolve) => setTimeout(resolve, 100));
    }
  } while (pageToken);

  return allReviews;
}

Respondendo a Avaliações de Forma Programática

A capacidade de responder à API de avaliações do Google Programaticamente é essencial para empresas que gerenciam múltiplas localizações. Respostas rápidas a avaliações melhoram a percepção dos clientes e podem impactar positivamente o SEO local.

Criando uma Resposta a uma Avaliação

async function responderAvaliacao(
  tokenAcesso: string,
  nomeAvaliacao: string,
  textoResposta: string
): Promise<{ sucesso: boolean }> {
  // formato do nomeAvaliacao: contas/{idConta}/locais/{idLocal}/avaliacoes/{idAvaliacao}
  const resposta = await fetch(
    `https://mybusiness.googleapis.com/v4/${nomeAvaliacao}/responder`,
    {
      method: 'PUT',
      headers: {
        Authorization: `Bearer ${tokenAcesso}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({
        comentario: textoResposta,
      }),
    }
  );

  if (!resposta.ok) {
    const corpoErro = await resposta.text();
    throw new Error(`Falha ao responder à avaliação: ${resposta.status} ${corpoErro}`);
  }

  return { sucesso: true };
}

Atualizando uma Resposta Existente

O mesmo endpoint gerencia tanto a criação quanto a atualização de respostas:

async function atualizarRespostaRevisão(
  tokenAcesso: string,
  nomeRevisão: string,
  novoTextoResposta: string
): Promise<{ sucesso: boolean }> {
  // A requisição PUT atualiza a resposta existente
  return responderRevisão(tokenAcesso, nomeRevisão, novoTextoResposta);
}

Excluir uma Resposta

async function deleteReviewReply(
  accessToken: string,
  reviewName: string
): Promise<{ success: boolean }> {
  const response = await fetch(
    `https://mybusiness.googleapis.com/v4/${reviewName}/reply`,
    {
      method: 'DELETE',
      headers: {
        Authorization: `Bearer ${accessToken}`,
      },
    }
  );

  // 204 No Content indica que a exclusão foi bem-sucedida
  if (!response.ok && response.status !== 204) {
    const errorBody = await response.text();
    throw new Error(`Falha ao excluir a resposta: ${response.status} ${errorBody}`);
  }

  return { success: true };
}

Melhores Práticas de Resposta

Ao construir sistemas de resposta automática, considere estas diretrizes:

Gerenciando Atualizações e Exclusões de Avaliações

O Google permite que os clientes editem ou excluam suas avaliações. Sua aplicação deve lidar com esses cenários de forma eficiente.

Detetando Alterações nas Avaliações

The updateTime o campo indica quando uma avaliação foi modificada pela última vez:

interface ReviewChange {
  reviewId: string;
  changeType: 'novo' | 'atualizado' | 'deletado';
  review?: Review;
}

async function detectReviewChanges(
  accessToken: string,
  accountId: string,
  locationId: string,
  previousReviews: Map
): Promise {
  const currentReviews = await getAllReviews(accessToken, accountId, locationId);
  const changes: ReviewChange[] = [];

  const currentReviewMap = new Map(
    currentReviews.map((r) => [r.id, r])
  );

  // Verifica por avaliações novas e atualizadas
  for (const review of currentReviews) {
    const previous = previousReviews.get(review.id);

    if (!previous) {
      changes.push({ reviewId: review.id, changeType: 'novo', review });
    } else if (previous.updateTime !== review.updateTime) {
      changes.push({ reviewId: review.id, changeType: 'atualizado', review });
    }
  }

  // Verifica por avaliações deletadas
  for (const [reviewId] of previousReviews) {
    if (!currentReviewMap.has(reviewId)) {
      changes.push({ reviewId, changeType: 'deletado' });
    }
  }

  return changes;
}

Estratégia de Polling como Alternativa ao Webhook

O Google não fornece webhooks para alterações de avaliações. Implemente uma estratégia de polling em vez disso:

async function pollForReviewChanges(
  accessToken: string,
  accountId: string,
  locationId: string,
  onNewReview: (review: Review) => Promise,
  onUpdatedReview: (review: Review) => Promise,
  onDeletedReview: (reviewId: string) => Promise
): Promise {
  let previousReviews = new Map();

  // Busca inicial
  const initialReviews = await getAllReviews(accessToken, accountId, locationId);
  previousReviews = new Map(initialReviews.map((r) => [r.id, r]));

  // Verificação a cada 5 minutos
  setInterval(async () => {
    try {
      const changes = await detectReviewChanges(
        accessToken,
        accountId,
        locationId,
        previousReviews
      );

      for (const change of changes) {
        switch (change.changeType) {
          case 'new':
            await onNewReview(change.review!);
            previousReviews.set(change.reviewId, change.review!);
            break;
          case 'updated':
            await onUpdatedReview(change.review!);
            previousReviews.set(change.reviewId, change.review!);
            break;
          case 'deleted':
            await onDeletedReview(change.reviewId);
            previousReviews.delete(change.reviewId);
            break;
        }
      }
    } catch (error) {
      console.error('Erro ao verificar mudanças nas avaliações:', error);
    }
  }, 5 * 60 * 1000); // 5 minutos
}

Análise e Insights

The API GBP fornece métricas agregadas juntamente com avaliações individuais. Utilize-as para painéis e relatórios.

Extraindo Métricas de Avaliação

interface ReviewAnalytics {
  totalReviews: number;
  averageRating: number;
  ratingDistribution: Record;
  repliedCount: number;
  unrepliedCount: number;
  replyRate: number;
  averageResponseTime?: number;
}

function analyzeReviews(reviews: Review[]): ReviewAnalytics {
  const ratingDistribution: Record = {
    1: 0,
    2: 0,
    3: 0,
    4: 0,
    5: 0,
  };

  let totalRating = 0;
  let repliedCount = 0;

  for (const review of reviews) {
    ratingDistribution[review.rating]++;
    totalRating += review.rating;
    if (review.reviewReply) {
      repliedCount++;
    }
  }

  const totalReviews = reviews.length;
  const unrepliedCount = totalReviews - repliedCount;

  return {
    totalReviews,
    averageRating: totalReviews > 0 ? totalRating / totalReviews : 0,
    ratingDistribution,
    repliedCount,
    unrepliedCount,
    replyRate: totalReviews > 0 ? (repliedCount / totalReviews) * 100 : 0,
  };
}

Limites de Taxa e Quotas

A API GBP impõe limites de taxa para garantir um uso justo. Planeje sua integração de acordo.

Limites de Taxa Atuais

Implementando Limitação de Taxa

class LimitadorDeTaxa {
  private pedidos: number[] = [];
  private readonly maxPedidos: number;
  private readonly janelaMs: number;

  constructor(maxPedidos: number = 300, janelaMs: number = 60000) {
    this.maxPedidos = maxPedidos;
    this.janelaMs = janelaMs;
  }

  async aguardarVaga(): Promise {
    const agora = Date.now();
    this.pedidos = this.pedidos.filter((tempo) => agora - tempo < this.janelaMs);

    if (this.pedidos.length >= this.maxPedidos) {
      const pedidoMaisAntigo = this.pedidos[0];
      const tempoEspera = this.janelaMs - (agora - pedidoMaisAntigo) + 100;
      await new Promise((resolver) => setTimeout(resolver, tempoEspera));
    }

    this.pedidos.push(Date.now());
  }
}

// Uso
const limitadorDeTaxa = new LimitadorDeTaxa(300, 60000);

async function pedidoComLimite(
  funcaoPedido: () => Promise
): Promise {
  await limitadorDeTaxa.aguardarVaga();
  return funcaoPedido();
}

Gestão e Atualização de Tokens

Os tokens de acesso expiram após uma hora. Implemente a atualização automática do token para garantir acesso ininterrupto.

Implementação de Atualização de Token

interface TokenStore {
  accessToken: string;
  refreshToken: string;
  expiresAt: number;
}

class GoogleBusinessTokenManager {
  private tokenStore: TokenStore;
  private clientId: string;
  private clientSecret: string;

  constructor(
    initialTokens: TokenStore,
    clientId: string,
    clientSecret: string
  ) {
    this.tokenStore = initialTokens;
    this.clientId = clientId;
    this.clientSecret = clientSecret;
  }

  async getValidAccessToken(): Promise {
    // Atualiza se o token expirar em menos de 5 minutos
    const bufferMs = 5 * 60 * 1000;
    if (Date.now() >= this.tokenStore.expiresAt - bufferMs) {
      await this.refreshAccessToken();
    }
    return this.tokenStore.accessToken;
  }

  private async refreshAccessToken(): Promise {
    const response = await fetch('https://oauth2.googleapis.com/token', {
      method: 'POST',
      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
      body: new URLSearchParams({
        refresh_token: this.tokenStore.refreshToken,
        client_id: this.clientId,
        client_secret: this.clientSecret,
        grant_type: 'refresh_token',
      }),
    });

    if (!response.ok) {
      const errorText = await response.text();
      throw new Error(`Falha ao atualizar o token: ${response.status} ${errorText}`);
    }

    const data = await response.json();

    this.tokenStore.accessToken = data.access_token;
    this.tokenStore.expiresAt = Date.now() + data.expires_in * 1000;

    // Nota: O Google pode retornar um novo token de atualização; atualize se fornecido
    if (data.refresh_token) {
      this.tokenStore.refreshToken = data.refresh_token;
    }
  }
}

Melhores Práticas para Tratamento de Erros

Um tratamento de erros robusto é essencial para aplicações em produção. A API GBP retorna códigos de erro específicos que você pode gerenciar programaticamente.

Manipulador de Erros Abrangente

type ErrorType = 'refresh-token' | 'retry' | 'user-error' | 'unknown';

interface HandledError {
  type: ErrorType;
  message: string;
  shouldRetry: boolean;
  retryAfterMs?: number;
}

function handleGBPError(statusCode: number, errorBody: string): HandledError {
  const lowerBody = errorBody.toLowerCase();

  // Erros de autenticação
  if (
    lowerBody.includes('invalid_grant') ||
    lowerBody.includes('token has been expired or revoked')
  ) {
    return {
      type: 'refresh-token',
      message: 'Token de acesso expirado. Por favor, reconecte sua conta.',
      shouldRetry: false,
    };
  }

  if (lowerBody.includes('invalid_token') || lowerBody.includes('unauthorized')) {
    return {
      type: 'refresh-token',
      message: 'Token de acesso inválido. Por favor, reconecte sua conta.',
      shouldRetry: false,
    };
  }

  // Erros de permissão
  if (lowerBody.includes('permission_denied') || lowerBody.includes('forbidden')) {
    return {
      type: 'user-error',
      message: 'Você não tem permissão para gerenciar este local.',
      shouldRetry: false,
    };
  }

  // Recurso não encontrado
  if (lowerBody.includes('not_found')) {
    return {
      type: 'user-error',
      message: 'O recurso solicitado não foi encontrado.',
      shouldRetry: false,
    };
  }

  // Limite de taxa
  if (
    statusCode === 429 ||
    lowerBody.includes('rate_limit') ||
    lowerBody.includes('quota')
  ) {
    return {
      type: 'retry',
      message: 'Limite de taxa excedido. Tentando novamente após um atraso.',
      shouldRetry: true,
      retryAfterMs: 60000, // Aguardar 1 minuto
    };
  }

  // Serviço indisponível
  if (statusCode === 503 || lowerBody.includes('service_unavailable')) {
    return {
      type: 'retry',
      message: 'Serviço temporariamente indisponível.',
      shouldRetry: true,
      retryAfterMs: 30000,
    };
  }

  return {
    type: 'unknown',
    message: `Erro inesperado: ${statusCode}

Lógica de Repetição com Retardo Exponencial

async function withRetry(
  operation: () => Promise,
  maxRetries: number = 3
): Promise {
  let lastError: Error | undefined;

  for (let attempt = 0; attempt <= maxRetries; attempt++) {
    try {
      return await operation();
    } catch (error: any) {
      lastError = error;

      const handled = handleGBPError(
        error.statusCode || 500,
        error.message || ''
      );

      if (!handled.shouldRetry || attempt === maxRetries) {
        throw error;
      }

      const backoffMs = handled.retryAfterMs || Math.pow(2, attempt) * 1000;
      console.log(`Tentativa de nova execução ${attempt + 1} após ${backoffMs}ms`);
      await new Promise((resolve) => setTimeout(resolve, backoffMs));
    }
  }

  throw lastError;
}

Usando o Late para Gestão de Avaliações

Construir e manter uma integração com as Avaliações do Google Meu Negócio exige um esforço de desenvolvimento significativo: fluxos de OAuth, gerenciamento de tokens, limitação de taxa, tratamento de erros e mudanças contínuas na API. [INTERNAL_LINK:api-integration-best-practices]

Late (https://getlate.dev) simplifica todo esse processo com uma API unificada que gerencia a complexidade para você.

Por que escolher a Late para gestão de avaliações

Em vez de gerenciar tokens OAuth, lidar com limites de taxa e enfrentar a versão da API por conta própria, o Late oferece:

• API UnificadaUma interface consistente para o Google Business Profile e outras plataformas.
• Gestão Automática de TokensO Late gerencia automaticamente a atualização e o armazenamento de tokens.
• Limitação de Taxa IntegradaNunca se preocupe em atingir os limites da API.
• Tratamento de ErrosRespostas de erro padronizadas em todas as plataformas
• Suporte a WebhooksReceba notificações de novas avaliações sem precisar fazer polling.

Começando com o Late

import { Late } from '@getlate/sdk';

const late = new Late({
  apiKey: process.env.LATE_API_KEY,
});

// Buscar avaliações com uma única chamada
const reviews = await late.reviews.list({
  accountId: 'seu-id-de-conta-conectada',
  platform: 'googlebusiness',
});

// Responder a uma avaliação
await late.reviews.reply({
  reviewId: 'id-da-avaliação',
  message: 'Obrigado pelo seu feedback!',
});

A abordagem unificada do Late permite que você se expanda para outras plataformas de avaliação (Yelp, Facebook, TripAdvisor) sem precisar reescrever seu código de integração.

Próximos Passos

1. Inscreva-se no Late at getlate.dev
2. Conecte suas contas do Google Business Profile.
3. Comece a gerenciar avaliações de forma programática com nossa API unificada.

Confira nosso documentation para a referência completa da API e exemplos adicionais.

Gerenciar avaliações do Google Business Profile de forma programática abre possibilidades poderosas de automação para a gestão de reputação. Seja construindo diretamente na API do GBP ou utilizando uma plataforma unificada como o Late, o essencial é implementar um tratamento de erros robusto, respeitar os limites de taxa e manter tokens de acesso atualizados. Os exemplos de código neste guia oferecem uma base sólida para qualquer uma das abordagens.