Wie Proxys beim Scrapen von Bewertungsdaten helfen: Trustpilot, G2 & Google Business

Wer systematisch Bewertungsdaten von Trustpilot, G2 oder Google Business sammeln will, trifft schnell auf Rate-Limits, CAPTCHAs und lokalisierte Review-Sets. Eine einzelne IP reicht schon nach wenigen Seiten nicht mehr aus. Genau hier setzen wir an: Wie Proxys beim Scrapen von Bewertungsdaten helfen ist im Kern eine Frage von IP-Rotation, Geo-Targeting und realistischen Anfrage-Profilen. In diesem Guide zeigen wir, wie du mit rotierenden Residential-Proxys von ProxyHat öffentliche Bewertungen skalierbar und zuverlässig extrahierst.

Wichtiger Hinweis vorab: Dieser Beitrag behandelt ausschließlich öffentlich zugängliche Bewertungsdaten. Bitte respektiere die Nutzungsbedingungen (Terms of Service) der jeweiligen Plattformen sowie geltendes Recht – in den USA etwa der Computer Fraud and Abuse Act (CFAA), in der EU die DSGVO. Keine personenbezogenen Daten (PII) ernten, robots.txt beachten, und wo eine offizielle API existiert, diese bevorzugen.

Warum Bewertungsseiten so aggressiv rate-limiten und lokalisieren

Bewertungsportale leben von Vertrauen – und sind deshalb besonders empfindlich gegenüber automatisierten Zugriffen. Trustpilot, G2 und Google Business setzen mehrere Schichten von Schutzmechanismen ein:

• IP-basierte Rate-Limits: Mehrere hundert Requests pro IP/Stunde führen zu HTTP 429 oder temporären Blocks.
• Bot-Fingerprinting: Header-Konsistenz, TLS-Fingerprints (JA3) und Verhaltensanalyse erkennen einfache Scraper.
• Geo- und Locale-Personalisierung: Google Business zeigt je nach hl- und gl-Parameter unterschiedliche Bewertungen. Trustpilot liefert je nach IP-Standort teils unterschiedliche Profil-Snapshots.
• JavaScript-Rendering-Pflicht: G2 und Trustpilot rendern Reviews clientseitig; statisches HTML-Scraping ohne JSON-Extraktion ist fehleranfällig.

Ein Scraper mit einer festen IP erreicht typischerweise nur 20–80 Seiten, bevor er gedrosselt wird. Mit rotierenden Residential-Proxys verteilt sich die Last auf hunderte IPs – jede sieht nur wenige Requests und bleibt unter dem Radar. Laut einer Imperva-Bot-Report-Studie machen Bots mittlerweile über 40 % des globalen Web-Traffics aus, weshalb Plattformen immer aggressivere Gegenmaßnahmen ergreifen.

Proxy-Typen im Vergleich: Welcher für welches Review-Ziel?

Nicht jeder Proxy-Typ eignet sich gleich gut für das Scrapen von Bewertungsportalen. Hier ein Vergleich:

Für die meisten Review-Scraping-Aufgaben sind rotierende Residential-Proxys der beste Kompromiss aus Erfolgrate, Kosten und Geschwindigkeit. Mobile-Proxys sind teurer, aber bei sehr restriktiven Zielen wie G2 oft die einzige zuverlässige Option.

Trustpilot: Eingebettetes __NEXT_DATA__ statt HTML parsen

Trustpilot nutzt Next.js und bettet die Review-Daten als JSON im <script id="__NEXT_DATA__">-Tag ein. Anstatt das HTML nach Review-Blöcken zu durchsuchen (brittle), extrahieren wir dieses JSON direkt. Pagination erfolgt über ?page=N.

Wichtige Felder in __NEXT_DATA__:

• reviews-Array mit title, text, stars, dates, consumer.displayName
• numberOfReviews für Pagination-Logik
• displayName für die Business-Identität

Python: Trustpilot-Seiten mit IP-Rotation scrapen

import requests
import json
import re
import time
from urllib.parse import quote

PROXY = "http://user-country-DE:pass@gate.proxyhat.com:8080"
proxies = {"http": PROXY, "https": PROXY}

HEADERS = {
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0 Safari/537.36",
    "Accept-Language": "de-DE,de;q=0.9,en;q=0.8",
}

def scrape_trustpilot(business_slug, max_pages=10):
    all_reviews = []
    for page in range(1, max_pages + 1):
        url = f"https://www.trustpilot.com/review/{business_slug}?page={page}"
        # Neue IP pro Seite durch Proxy-Rotation
        resp = requests.get(url, headers=HEADERS, proxies=proxies, timeout=30)
        if resp.status_code == 429:
            time.sleep(5)
            continue
        match = re.search(r'<script id="__NEXT_DATA__" type="application/json">(.*?)</script>',
                          resp.text, re.DOTALL)
        if not match:
            break
        data = json.loads(match.group(1))
        reviews = (data.get("props", {})
                      .get("pageProps", {})
                      .get("reviews", []))
        if not reviews:
            break
        for r in reviews:
            all_reviews.append({
                "title": r.get("title"),
                "text": r.get("text"),
                "stars": r.get("stars"),
                "date": r.get("dates", {}).get("publishedDate"),
            })
        time.sleep(1.5)  # Höflich bleiben
    return all_reviews

reviews = scrape_trustpilot("beispiel-firma", max_pages=20)
print(f"{len(reviews)} Bewertungen gesammelt")

Dieser Ansatz nutzt eine rotierende Residential-IP pro Request über gate.proxyhat.com:8080. Die Accept-Language-Header passen zur Ziel-Locale (de-DE), was die Konsistenz mit der Proxy-Geo erhöht.

G2: Stärkere Anti-Bot-Maßnahmen mit Residential-IPs und Headern umgehen

G2 setzt Cloudflare und fortschrittliches Bot-Fingerprinting ein. Datacenter-Proxys werden meist innerhalb von 10–30 Requests blockiert. Residential-Proxys mit realistischen Headern und moderater Rate (1–2 Sekunden zwischen Requests) erreichen deutlich bessere Erfolgsraten.

Strategien für G2:

• Residential-Proxys mit Country-Targeting: user-country-US für US-Reviews, da G2 viele Produktseiten primär für den US-Markt rendert.
• Vollständige Browser-Header: sec-ch-ua, sec-fetch-dest, sec-fetch-mode, sec-fetch-site – nicht weglassen.
• Sticky Sessions für Multi-Page-Profile: Wenn ein Produktprofil 5 Seiten hat, behalte dieselbe IP über -session-abc123, um Cookie-Konsistenz zu wahren.
• Star-Distribution parsen: G2 zeigt oft eine aggregierte Sterneverteilung; diese ist im HTML oder in JSON-LD-Blobs zu finden.

Python: G2 mit Sticky Session

import requests
import time

# Sticky Session für ein ganzes Produktprofil
SESSION_ID = "g2-product-xyz-001"
PROXY = f"http://user-session-{SESSION_ID}-country-US:pass@gate.proxyhat.com:8080"
proxies = {"http": PROXY, "https": PROXY}

HEADERS = {
    "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0 Safari/537.36",
    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
    "Accept-Language": "en-US,en;q=0.9",
    "sec-ch-ua": '"Chromium";v="124", "Google Chrome";v="124"',
    "sec-ch-ua-mobile": "?0",
    "sec-ch-ua-platform": '"macOS"',
    "sec-fetch-dest": "document",
    "sec-fetch-mode": "navigate",
    "sec-fetch-site": "none",
    "sec-fetch-user": "?1",
    "upgrade-insecure-requests": "1",
}

def scrape_g2_reviews(product_slug, max_pages=5):
    results = []
    for page in range(1, max_pages + 1):
        url = f"https://www.g2.com/products/{product_slug}/reviews?page={page}"
        resp = requests.get(url, headers=HEADERS, proxies=proxies, timeout=45)
        if resp.status_code == 403:
            print(f"403 auf Seite {page} – Session pausieren")
            time.sleep(15)
            continue
        # HTML parsen oder JSON-LD extrahieren
        results.append({"page": page, "status": resp.status_code, "html_len": len(resp.text)})
        time.sleep(2)
    return results

data = scrape_g2_reviews("slack", max_pages=3)
print(data)

Die -session-{SESSION_ID}-Flag hält die IP über mehrere Requests stabil – wichtig, wenn G2 Cookies erwartet. Für ein neues Produktprofil änders du einfach die Session-ID und bekommst eine neue IP.

Google Business / Maps: hl, gl und Geo-Targeting

Google Business-Reviews sind besonders stark personalisiert. Die Parameter hl (Sprache) und gl (Land) steuern, welche Reviews priorisiert angezeigt werden. Eine IP aus Deutschland sieht für dasselbe Business teils andere Top-Reviews als eine US-IP.

Für konsistente Datensätze empfiehlt sich:

• Country-Targeted Residential Sessions: user-country-US für US-Datensätze, user-country-DE für deutsche.
• Konsistente hl/gl-Parameter: Immer beide setzen, z. B. hl=en&gl=us.
• Sticky Sessions pro Business: Ein Business-Profil über mehrere Seiten mit derselben IP laden, um Sortierkonsistenz zu gewährleisten.

Beispiel-URL: https://www.google.com/maps/place/.../reviews?hl=en&gl=us

Google liefert Reviews oft über asynchrone Endpoints, die protobuf- oder JSON-Antworten zurückgeben. Diese sind nicht dokumentiert und ändern sich häufig. Für stabilere Pipelines ist die offizielle Places API eine Alternative, wenn auch mit Kosten verbunden (~$17 pro 1.000 Place-Detail-Requests, Stand 2024).

Node.js: Review-Scraping mit ProxyHat und undici

Für JavaScript/TypeScript-Pipelines lässt sich ProxyHat ebenso einfach einsetzen. Hier ein Node.js-Beispiel mit undici, das Trustpilot-Seiten mit rotierenden IPs lädt:

import { request } from "undici";

const PROXY_URL = "http://user-country-DE:pass@gate.proxyhat.com:8080";

const headers = {
  "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0 Safari/537.36",
  "Accept-Language": "de-DE,de;q=0.9,en;q=0.8",
};

async function scrapeTrustpilot(businessSlug, maxPages = 10) {
  const allReviews = [];
  for (let page = 1; page <= maxPages; page++) {
    const url = `https://www.trustpilot.com/review/${businessSlug}?page=${page}`;
    const resp = await request(url, {
      method: "GET",
      headers,
      dispatcher: new (await import("undici")).ProxyAgent(PROXY_URL),
      headersTimeout: 30000,
      bodyTimeout: 30000,
    });
    if (resp.statusCode === 429) {
      console.warn(`429 auf Seite ${page}, pausiere`);
      await new Promise(r => setTimeout(r, 5000));
      continue;
    }
    const body = await resp.body.text();
    const match = body.match(/<script id="__NEXT_DATA__" type="application\/json">(.*?)<\/script>/s);
    if (!match) break;
    const data = JSON.parse(match[1]);
    const reviews = data?.props?.pageProps?.reviews ?? [];
    if (reviews.length === 0) break;
    for (const r of reviews) {
      allReviews.push({
        title: r.title,
        text: r.text,
        stars: r.stars,
        date: r.dates?.publishedDate,
      });
    }
    await new Promise(r => setTimeout(r, 1500));
  }
  return allReviews;
}

const reviews = await scrapeTrustpilot("beispiel-firma", 15);
console.log(`${reviews.length} Bewertungen gesammelt`);

Best Practices: Rate-Limits, Fingerprints und Fehlerbehandlung

Rate-Limit-Strategien

• 1–3 Sekunden zwischen Requests pro IP, nicht pro Scraper-Prozess.
• Exponentielles Backoff bei HTTP 429: Start 5s, dann 10s, 20s, 40s.
• Concurrency begrenzen: Maximal 5–10 gleichzeitige Requests pro Proxy-Session.

Fingerprint-Risiken

• TLS-Fingerprints (JA3) verraten Python-Requests-Clients. Für G2 erwägen Tools wie curl_cffi oder Headless-Browser.
• Header-Konsistenz prüfen: Wenn sec-ch-ua-platform "macOS" sagt, sollte der User-Agent ebenfalls macOS sein.
• Keine leeren Referer-Header bei navigationsähnlichen Requests.

Öffentliche vs. Login-geschützte Daten

Trustpilot- und G2-Reviews sind ohne Login sichtbar – ideal für öffentliches Scraping. Google Business-Reviews sind ebenfalls öffentlich, aber die asynchronen Endpoints erfordern oft ein gültiges Token aus einem initialen Page-Load. Login-geschützte Daten (z. B. LinkedIn-Recommendations, interne Foren) sind nicht Gegenstand dieses Guides und oft rechtlich problematisch.

ProxyHat-spezifisches Setup

ProxyHat bietet rotierende Residential-Proxys über das Gateway gate.proxyhat.com. Die Konfiguration erfolgt über den Username mit Flags:

• HTTP-Standard: http://USERNAME:PASSWORD@gate.proxyhat.com:8080
• SOCKS5: socks5://USERNAME:PASSWORD@gate.proxyhat.com:1080
• Country-Targeting: user-country-US:pass
• City-Targeting: user-country-DE-city-berlin:pass
• Sticky Session: user-session-abc123:pass
• Kombination: user-session-abc123-country-US:pass

Detaillierte Konfiguration findest du in der ProxyHat-Dokumentation. Aktuelle Preise und verfügbare Locations sind auf der Preisseite und der Locations-Seite zu finden.

Weitere Anleitungen zum Thema Web-Scraping findest du in unserem Web-Scraping-Use-Case und für SERP-Daten im SERP-Tracking-Use-Case.

Ethisches Scraping und wann offizielle APIs besser sind

Nicht jedes Scraping ist gleich. Vor jedem Projekt solltest du prüfen:

1. Existiert eine offizielle API? G2 bietet eine Partner-API für Reviews. Trustpilot hat eine Consumer-API für öffentliche Reviews. Google Places API deckt Business-Reviews ab. Wenn eine API existiert und deine Anforderungen erfüllt, nutze sie – sie ist stabiler und rechtlich sicherer.
2. Respektiere robots.txt: Prüfe https://www.trustpilot.com/robots.txt usw., bevor du scrapst.
3. Keine PII-Ernte: Review-Autorennamen sind oft PII. Für DSGVO-konforme Datensätze pseudonymisiere oder aggregiere.
4. Rate-Limits einhalten: Auch wenn du technisch mehr könntest – sei höflich. 1–3 Sekunden pro Request ist ein guter Standard.
5. Nutzungsbedingungen lesen: Viele Plattformen verbieten automatisierten Zugriff in ihren ToS. Das ist keine rechtliche Grauzone, sondern oft ein klarer Vertrag.

Wenn du nur aggregierte Sterneverteilungen und Review-Counts brauchst, ist eine offizielle API fast immer die bessere Wahl. Scraping ist dann sinnvoll, wenn du Review-Texte für Sentiment-Analyse oder NLP brauchst und keine API diese bereitstellt.

Key Takeaways: Rotierende Residential-Proxys sind für Review-Scraping unverzichtbar, weil Plattformen IP-basierte Rate-Limits und Geo-Personalisierung einsetzen. Trustpilot über __NEXT_DATA__ parsen, nicht über HTML. G2 braucht Sticky Sessions plus vollständige Browser-Header. Google Business erfordert konsistente hl/gl-Parameter und Country-Targeting. Immer robots.txt und ToS respektieren – und wo möglich offizielle APIs nutzen.

FAQ: Häufige Fragen