Google Business Reviews API: Vollständiger Integrationsleitfaden

The Google Business Bewertungen API ermöglicht Entwicklern, Kundenbewertungen programmgesteuert über Google Business Profile-Standorte zu verwalten. Egal, ob Sie ein Dashboard für das Reputationsmanagement erstellen, automatisierte Antworten auf Bewertungen einrichten oder Feedback an mehreren Standorten aggregieren möchten, diese API bietet die Grundlage für ein skalierbares Bewertungsmanagement.

Dieser Leitfaden behandelt alles, was Sie benötigen, um die GBP API in Ihre Anwendung zu integrieren: von der ersten Einrichtung über die OAuth-Authentifizierung, das Abrufen von Bewertungen, das programmatische Antworten bis hin zur Handhabung der unvermeidlichen Sonderfälle, die bei Produktionsbereitstellungen auftreten.

Einführung in die Google Business Profile API

Die Geschäftsanwendungen von Google haben sich im Laufe der Jahre erheblich weiterentwickelt. Die aktuelle Implementierung nutzt eine Kombination aus API-Endpunkten:

• Meine API zur Verwaltung von Geschäftskonten (mybusinessaccountmanagement.googleapis.com/v1): Verwalten von Konten und Berechtigungen
• Meine Unternehmensinformationen API (mybusinessbusinessinformation.googleapis.com/v1): Verarbeitet Standortdaten
• Meine Business-API v4 (mybusiness.googleapis.com/v4): Verwalten Sie Bewertungen und lokale Beiträge (diese Funktionen sind weiterhin aktiv)

The Google My Business API Bewertungen Die Funktionalität befindet sich speziell in der v4 API. Während Google viele Funktionen auf neuere v1-Endpunkte migriert hat, bleibt das Bewertungsmanagement auf v4 ohne angekündigtes Datum für die Einstellung.

Hinweis: Google aktualisiert häufig die Struktur ihrer API. Die v4-Endpunkte für Bewertungen sind stabil, aber überprüfe immer die offizielle Dokumentation auf die neuesten Änderungen.

Was Sie mit der Reviews API tun können

Die GBP API unterstützt folgende grundlegende Bewertungsoperationen:

Über die API können Sie Kundenbewertungen nicht löschen. Nur der Rezensent oder Google (bei Verstößen gegen die Richtlinien) kann Bewertungen entfernen.

Einrichten eines Google Cloud-Projekts

Bevor Sie mit dem Schreiben von Code beginnen, benötigen Sie ein richtig konfiguriertes Google Cloud-Projekt mit den aktivierten APIs.

Schritt 1: Erstellen Sie ein Google Cloud-Projekt

1. Navigieren zu Google Cloud Console
2. Erstellen Sie ein neues Projekt oder wählen Sie ein bestehendes aus.
3. Notieren Sie sich Ihre Projekt-ID für späteren Gebrauch.

Schritt 2: Notwendige APIs aktivieren

Aktivieren Sie diese APIs in Ihrem Projekt:

# Verwendung der gcloud CLI
gcloud services enable mybusinessaccountmanagement.googleapis.com  
gcloud services enable mybusinessbusinessinformation.googleapis.com  
gcloud services enable mybusiness.googleapis.com

Oder aktivieren Sie sie über die Cloud-Konsole:

• Meine API zur Verwaltung von Geschäftskonten
• Meine Unternehmensinformationen API
• Google My Business API

Schritt 3: OAuth-Zustimmungsbildschirm konfigurieren

1. Gehe zu APIs & Dienste > OAuth-Zustimmungsbildschirm
2. Select External Benutzertyp (es sei denn, Sie haben eine Google Workspace-Organisation)
3. Füllen Sie die erforderlichen Felder aus:
   • App-Name
   • Benutzer-Support-E-Mail
   • Entwickler-Kontakt-E-Mail
4. Fügen Sie den erforderlichen Umfang hinzu: https://www.googleapis.com/auth/business.manage
5. Testbenutzer hinzufügen (erforderlich im Testmodus)

Schritt 4: OAuth-Anmeldeinformationen erstellen

1. Gehe zu APIs & Dienste > Anmeldeinformationen
2. Click Erstelle Anmeldeinformationen > OAuth-Client-ID
3. Select Webanwendung
4. Fügen Sie Ihre autorisierten Umleitungs-URIs hinzu.
5. Speichern Sie Ihre Client-ID und Ihr Client-Geheimnis.

// Diese in Umgebungsvariablen speichern
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 für Google Business

Das Google Business-Profil benötigt OAuth 2.0 mit Offline-Zugriff, um Aktualisierungstoken zu erhalten. Dadurch kann Ihre Anwendung auf die API zugreifen, ohne dass die Benutzer sich erneut authentifizieren müssen.

Generierung der Autorisierungs-URL

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', // Erzwingt den Zustimmungsbildschirm, um ein Refresh-Token sicherzustellen
  });

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

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

The Zustimmung Der Parameter ist entscheidend. Ohne ihn könnte Google bei nachfolgenden Autorisierungen kein Refresh-Token zurückgeben.

Austausch des Autorisierungscodes

Nachdem der Benutzer Ihre Anwendung autorisiert hat, leitet Google ihn mit einem Autorisierungscode zurück:

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(`Token-Austausch fehlgeschlagen: ${response.status} ${errorText}`);
  }

  return response.json();
}

Hinweis: Speichern Sie das Refresh-Token sicher. Es wird nur bei der ersten Autorisierung (oder bei der Verwendung von Zustimmung).

Konten- und Standortstruktur

Die GBP API verwendet eine hierarchische Struktur: Benutzer haben Konten, und Konten enthalten Standorte. Sie benötigen beide IDs, um auf Bewertungen zuzugreifen.

Benutzerdaten abrufen

interface GBPAccount {
  name: string; // Format: "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(`Fehler beim Abrufen der Konten: ${response.status}`);
    }

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

  return allAccounts;
}

Standorte für ein Konto abrufen

interface GBPLocation {
  name: string; // Format: "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(`Fehler beim Abrufen der Standorte: ${response.status}`);
    }

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

  return allLocations;
}

Bewertungen mit der Google Business Reviews API abrufen

Mit den Konten- und Standort-IDs können Sie Bewertungen abrufen. Die Google Business Bewertungen API gibt standardmäßig Bewertungen in umgekehrter chronologischer Reihenfolge zurück.

Basic Review Fetching

interface ReviewReply {
  kommentar: string;
  aktualisierungszeit: string;
}

interface Review {
  id: string;
  name: string;
  bewertung: {
    anzeigename: string;
    profilfotoUrl?: string;
    istAnonym: boolean;
  };
  bewertungspunktzahl: number;
  sternbewertung: 'EINS' | 'ZWEI' | 'DREI' | 'VIER' | 'FÜNF';
  kommentar?: string;
  erstellungszeit: string;
  aktualisierungszeit: string;
  bewertungsantwort?: ReviewReply;
}

interface ReviewsResponse {
  bewertungen: Review[];
  durchschnittsbewertung?: number;
  gesamtbewertungAnzahl?: number;
  naechsteSeitenToken?: string;
}

async function getReviews(
  zugriffsToken: string,
  kontoId: string,
  standortId: string,
  optionen?: { seitenGroesse?: number; seitenToken?: string }
): Promise {
  const accId = kontoId.includes('/') ? kontoId.split('/').pop() : kontoId;
  const locId = standortId.includes('/') ? standortId.split('/').pop() : standortId;

  const seitenGroesse = Math.min(optionen?.seitenGroesse || 50, 50); // Maximal 50 pro Anfrage
  const url = new URL(
    `https://mybusiness.googleapis.com/v4/accounts/${accId}/locations/${locId}/reviews`
  );
  url.searchParams.set('pageSize', String(seitenGroesse));

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

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

  if (!response.ok) {
    const errorBody = await response.text();
    throw new Error(`Fehler beim Abrufen der Bewertungen: ${response.status} ${errorBody}`);
  }

  const data = await response.json();

  const sternbewertungMap: Record = {
    EINS: 1,
    ZWEI: 2,
    DREI: 3,
    VIER: 4,
    FÜNF: 5,
  };

  const bewertungen

Alle Bewertungen mit Seitenumbruch abrufen

Für Standorte mit vielen Bewertungen müssen Sie die Paginierung berücksichtigen:

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;

    // Fügen Sie eine kurze Verzögerung hinzu, um eine Überlastung zu vermeiden
    if (pageToken) {
      await new Promise((resolve) => setTimeout(resolve, 100));
    }
  } while (pageToken);

  return allReviews;
}

Bewertungen programmgesteuert beantworten

Die Fähigkeit, Antworten auf Google-Bewertungen API Programmgesteuertes Management ist entscheidend für Unternehmen mit mehreren Standorten. Schnelle Reaktionen auf Bewertungen verbessern die Kundenwahrnehmung und können sich positiv auf die lokale SEO auswirken.

Eine Antwort auf eine Bewertung erstellen

async function antwortAufBewertung(
  zugangstoken: string,
  bewertungsname: string,
  antwortText: string
): Promise<{ erfolg: boolean }> {
  // bewertungsname Format: accounts/{accountId}/locations/{locationId}/reviews/{reviewId}
  const antwort = await fetch(
    `https://mybusiness.googleapis.com/v4/${bewertungsname}/reply`,
    {
      method: 'PUT',
      headers: {
        Authorization: `Bearer ${zugangstoken}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({
        comment: antwortText,
      }),
    }
  );

  if (!antwort.ok) {
    const fehlerText = await antwort.text();
    throw new Error(`Antwort auf Bewertung fehlgeschlagen: ${antwort.status} ${fehlerText}`);
  }

  return { erfolg: true };
}

Aktualisierung einer bestehenden Antwort

Der gleiche Endpunkt verarbeitet sowohl das Erstellen als auch das Aktualisieren von Antworten:

async function updateReviewReply(
  accessToken: string,
  reviewName: string,
  newReplyText: string
): Promise<{ success: boolean }> {
  // PUT-Anfrage aktualisiert die bestehende Antwort
  return replyToReview(accessToken, reviewName, newReplyText);
}

Antwort löschen

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 zeigt an, dass die Löschung erfolgreich war
  if (!response.ok && response.status !== 204) {
    const errorBody = await response.text();
    throw new Error(`Löschung der Antwort fehlgeschlagen: ${response.status} ${errorBody}`);
  }

  return { success: true };
}

Best Practices für Antworten

Bei der Erstellung automatisierter Antwortsysteme sollten Sie folgende Richtlinien beachten:

Verwaltung von Überprüfungsaktualisierungen und -löschungen

Google ermöglicht es Kunden, ihre Bewertungen zu bearbeiten oder zu löschen. Ihre Anwendung sollte diese Szenarien elegant handhaben.

Änderungen bei Bewertungen erkennen

The updateTime Feld zeigt an, wann eine Bewertung zuletzt geändert wurde:

interface ReviewChange {
  reviewId: string;
  changeType: 'neu' | 'aktualisiert' | 'gelöscht';
  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])
  );

  // Überprüfen auf neue und aktualisierte Bewertungen
  for (const review of currentReviews) {
    const previous = previousReviews.get(review.id);

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

  // Überprüfen auf gelöschte Bewertungen
  for (const [reviewId] of previousReviews) {
    if (!currentReviewMap.has(reviewId)) {
      changes.push({ reviewId, changeType: 'gelöscht' });
    }
  }

  return changes;
}

Webhook-Alternative: Abfrage-Strategie

Google bietet keine Webhooks für Änderungen an Bewertungen an. Implementiere stattdessen eine Polling-Strategie:

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

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

  // Alle 5 Minuten abfragen
  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('Fehler beim Abfragen von Bewertungsänderungen:', error);
    }
  }, 5 * 60 * 1000); // 5 Minuten
}

Analysen und Einblicke überprüfen

The GBP API bietet aggregierte Kennzahlen zusammen mit individuellen Bewertungen. Nutzen Sie diese für Dashboards und Berichterstattung.

Bewertung Kennzahlen extrahieren

interface ReviewAnalytics {
  gesamtbewertungen: number;
  durchschnittlicheBewertung: number;
  bewertungsverteilung: Record;
  beantworteteAnzahl: number;
  unbeantworteteAnzahl: number;
  antwortquote: number;
  durchschnittlicheAntwortzeit?: number;
}

function analysiereBewertungen(bewertungen: Review[]): ReviewAnalytics {
  const bewertungsverteilung: Record = {
    1: 0,
    2: 0,
    3: 0,
    4: 0,
    5: 0,
  };

  let gesamtbewertung = 0;
  let beantworteteAnzahl = 0;

  for (const bewertung of bewertungen) {
    bewertungsverteilung[bewertung.bewertung]++;
    gesamtbewertung += bewertung.bewertung;
    if (bewertung.bewertungsantwort) {
      beantworteteAnzahl++;
    }
  }

  const gesamtbewertungen = bewertungen.length;
  const unbeantworteteAnzahl = gesamtbewertungen - beantworteteAnzahl;

  return {
    gesamtbewertungen,
    durchschnittlicheBewertung: gesamtbewertungen > 0 ? gesamtbewertung / gesamtbewertungen : 0,
    bewertungsverteilung,
    beantworteteAnzahl,
    unbeantworteteAnzahl,
    antwortquote: gesamtbewertungen > 0 ? (beantworteteAnzahl / gesamtbewertungen) * 100 : 0,
  };
}

Ratenlimits und Kontingente

Die GBP API setzt Nutzungsbeschränkungen durch, um eine faire Nutzung zu gewährleisten. Planen Sie Ihre Integration entsprechend.

Aktuelle Ratenlimits

Implementierung von Ratenbegrenzung

class RateLimiter {
  private requests: number[] = [];
  private readonly maxRequests: number;
  private readonly windowMs: number;

  constructor(maxRequests: number = 300, windowMs: number = 60000) {
    this.maxRequests = maxRequests;
    this.windowMs = windowMs;
  }

  async waitForSlot(): Promise {
    const now = Date.now();
    this.requests = this.requests.filter((time) => now - time < this.windowMs);

    if (this.requests.length >= this.maxRequests) {
      const oldestRequest = this.requests[0];
      const waitTime = this.windowMs - (now - oldestRequest) + 100;
      await new Promise((resolve) => setTimeout(resolve, waitTime));
    }

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

// Verwendung
const rateLimiter = new RateLimiter(300, 60000);

async function rateLimitedRequest(
  requestFn: () => Promise
): Promise {
  await rateLimiter.waitForSlot();
  return requestFn();
}

Tokenverwaltung und Aktualisierung

Zugriffstoken laufen nach einer Stunde ab. Implementiere eine automatische Token-Aktualisierung, um einen unterbrechungsfreien Zugriff zu gewährleisten.

Implementierung der Token-Aktualisierung

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 {
    // Token erneuern, wenn er in weniger als 5 Minuten abläuft
    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(`Token-Aktualisierung fehlgeschlagen: ${response.status} ${errorText}`);
    }

    const data = await response.json();

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

    // Hinweis: Google kann einen neuen Refresh-Token zurückgeben; aktualisieren, wenn bereitgestellt
    if (data.refresh_token) {
      this.tokenStore.refreshToken = data.refresh_token;
    }
  }
}

Best Practices für die Fehlerbehandlung

Eine robuste Fehlerbehandlung ist entscheidend für Produktionsanwendungen. Die GBP API gibt spezifische Fehlercodes zurück, die Sie programmgesteuert verarbeiten können.

Umfassender Fehlerbehandler

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

  // Authentifizierungsfehler
  if (
    lowerBody.includes('invalid_grant') ||
    lowerBody.includes('token ist abgelaufen oder widerrufen')
  ) {
    return {
      type: 'refresh-token',
      message: 'Zugriffstoken ist abgelaufen. Bitte verbinden Sie Ihr Konto erneut.',
      shouldRetry: false,
    };
  }

  if (lowerBody.includes('invalid_token') || lowerBody.includes('unauthorized')) {
    return {
      type: 'refresh-token',
      message: 'Ungültiges Zugriffstoken. Bitte verbinden Sie Ihr Konto erneut.',
      shouldRetry: false,
    };
  }

  // Berechtigungsfehler
  if (lowerBody.includes('permission_denied') || lowerBody.includes('forbidden')) {
    return {
      type: 'user-error',
      message: 'Sie haben keine Berechtigung, diesen Standort zu verwalten.',
      shouldRetry: false,
    };
  }

  // Ressource nicht gefunden
  if (lowerBody.includes('not_found')) {
    return {
      type: 'user-error',
      message: 'Die angeforderte Ressource wurde nicht gefunden.',
      shouldRetry: false,
    };
  }

  // Rate-Limiting
  if (
    statusCode === 429 ||
    lowerBody.includes('rate_limit') ||
    lowerBody.includes('quota')
  ) {
    return {
      type: 'retry',
      message: 'Rate-Limit überschritten. Wiederholung nach Verzögerung.',
      shouldRetry: true,
      retryAfterMs: 60000, // 1 Minute warten
    };
  }

  // Dienst nicht verfügbar
  if (statusCode === 503 || lowerBody.includes('service_unavailable')) {
    return {
      type: 'retry',
      message: 'Dienst vorübergehend nicht verfügbar.',
      shouldRetry: true,
      retryAfterMs: 30000,
    };
  }

  return {
    type: 'unknown',
    message: `Uner

Wiederholungslogik mit exponentiellem Backoff

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(`Wiederholungsversuch ${attempt + 1} nach ${backoffMs}ms`);
      await new Promise((resolve) => setTimeout(resolve, backoffMs));
    }
  }

  throw lastError;
}

Late für das Management von Bewertungen nutzen

Der Aufbau und die Pflege einer Integration für Google Business Reviews erfordern einen erheblichen Entwicklungsaufwand: OAuth-Workflows, Token-Management, Ratenbegrenzung, Fehlerbehandlung und fortlaufende API-Änderungen. [INTERNAL_LINK:api-integration-best-practices]

Late (https://getlate.dev) vereinfacht diesen gesamten Prozess mit einer einheitlichen API, die die Komplexität für Sie übernimmt.

Warum Late für das Management von Bewertungen wählen?

Anstatt OAuth-Token selbst zu verwalten, mit Ratenlimits umzugehen und API-Versionierungen zu bewältigen, bietet Late:

• Einheitliche APIEine einheitliche Benutzeroberfläche für Google Business-Profil und andere Plattformen.
• Automatisches Token-ManagementLate kümmert sich automatisch um die Token-Aktualisierung und -Speicherung.
• Integrierte RatenbegrenzungMach dir keine Sorgen mehr über API-Kontingente.
• FehlerbehandlungStandardisierte Fehlermeldungen über alle Plattformen hinweg
• Webhook-UnterstützungErhalte Benachrichtigungen über neue Bewertungen, ohne ständig nachzufragen.

Erste Schritte mit Late

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

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

// Bewertungen mit einem einzigen Aufruf abrufen
const reviews = await late.reviews.list({
  accountId: 'deine-verbundene-konto-id',
  platform: 'googlebusiness',
});

// Auf eine Bewertung antworten
await late.reviews.reply({
  reviewId: 'bewertungs-id',
  message: 'Danke für dein Feedback!',
});

Der einheitliche Ansatz von Late ermöglicht es Ihnen, auf andere Bewertungsplattformen (Yelp, Facebook, TripAdvisor) zu expandieren, ohne Ihren Integrationscode neu schreiben zu müssen.

Nächste Schritte

1. Registriere dich bei Late at getlate.dev
2. Verbinden Sie Ihre Google Business-Profilkonten.
3. Beginnen Sie, Bewertungen programmgesteuert mit unserer einheitlichen API zu verwalten.

Schau dir unser documentation für die vollständige API-Dokumentation und weitere Beispiele.

Die programmgesteuerte Verwaltung von Google Business-Profilbewertungen eröffnet leistungsstarke Automatisierungsmöglichkeiten für das Reputationsmanagement. Egal, ob Sie direkt auf der GBP-API aufbauen oder eine einheitliche Plattform wie Late nutzen, entscheidend ist die Implementierung einer robusten Fehlerbehandlung, die Einhaltung der Ratenlimits und die Pflege aktueller Zugriffstoken. Die Codebeispiele in diesem Leitfaden bieten eine solide Grundlage für beide Ansätze.