Wichtiger Hinweis vorab: Dieser Artikel behandelt das Scraping öffentlich verfügbarer Daten. Die Erhebung nicht-öffentlicher oder personenbezogener Daten kann gegen das CFAA (US), die DSGVO (EU) oder die Nutzungsbedingungen einer Website verstoßen. Prüfen Sie immer robots.txt, Rate-Limits und ToS, bevor Sie scrapen. Bevorzugen Sie offizielle APIs, wenn diese verfügbar sind.
Wenn Sie mit got oder axios in Node.js scrapen und ständig 403-Fehler oder Cloudflare-Challenges erhalten, liegt das selten an einem einzelnen Header. Das Problem ist die Kombination aus inkonsistenten Headern, fehlendem TLS-Fingerabdruck und einer Datacenter-IP-Adresse, die von Anti-Bot-Systemen wie PerimeterX, DataDome oder Cloudflare Bot Management sofort erkannt wird. Genau hier setzt got-scraping in Node.js an: ein von Apify entwickelter HTTP-Client, der auf got aufbaut und automatisch kohärente Browser-Header-Sets generiert, HTTP/2 unterstützt und sich nahtlos mit Residential-Proxies kombinieren lässt.
Warum rohe got/axios-Anfragen blockiert werden
Anti-Bot-Systeme prüfen nicht nur, welche Header Sie senden, sondern auch in welcher Reihenfolge und ob sie zusammenpassen. Ein realer Chrome-Browser auf macOS sendet Header in einer bestimmten Reihenfolge: Host, Connection, sec-ch-ua, sec-ch-ua-mobile, sec-ch-ua-platform, Upgrade-Insecure-Requests, User-Agent, Accept, Sec-Fetch-Site, Sec-Fetch-Mode, Sec-Fetch-User, Sec-Fetch-Dest, Accept-Encoding, Accept-Language. Wenn Sie mit got einen User-Agent setzen, der Chrome 120 auf Windows behauptet, aber sec-ch-ua fehlt oder Accept-Language an der falschen Position steht, ist das ein sofortiger Signalwert für Bot-Detection.
Hinzu kommt der TLS-Fingerabdruck. Node.js verwendet standardmäßig OpenSSL, dessen JA3-Hash sich deutlich von dem eines Chrome- oder Firefox-Browsers unterscheidet. Selbst wenn Ihre Header perfekt sind, verrät der TLS-Handshake, dass Sie kein echter Browser sind. got-scraping löst das Header-Problem systematisch; für das TLS-Problem ist in der Regel ein Headless-Browser oder eine TLS-Bibliothek wie got mit angepassten Cipher-Suiten erforderlich.
Die dritte Dimension ist die IP-Adresse. Datacenter-IP-Bereiche (z. B. AWS, DigitalOcean, Hetzner) sind in öffentlichen Listen wie MaxMind GeoIP2 als hosting oder datacenter klassifiziert. Anti-Bot-Dienste gleiten diese Listen in Echtzeit ab. Wenn also Ihre Header und Ihr TLS-Fingerabdruck perfekt aussehen, die IP aber aus 52.0.0.0/8 stammt, wird die Anfrage trotzdem blockiert. Das ist der Grund, warum got-scraping proxy-Integration mit Residential-IPs der entscheidende Schritt für Produktionsscraping ist.
Wie got-scraping's Header-Generator funktioniert
Der Kern von got-scraping ist der got scraping header generator — eine Bibliothek, die nicht nur zufällige Header setzt, sondern ein kohärentes Set generiert, das zu einem bestimmten Browser, Betriebssystem und Gerät passt. Das bedeutet: Wenn Sie Chrome auf Windows simulieren, erhalten Sie die korrekten sec-ch-ua-Werte für diese Version, die passende Accept-Encoding, die richtige Header-Reihenfolge und einen konsistenten User-Agent.
Die Konfiguration erfolgt über headerGeneratorOptions:
import { gotScraping } from 'got-scraping';
const response = await gotScraping({
url: 'https://example.com',
headerGeneratorOptions: {
browsers: ['chrome'],
devices: ['desktop'],
operatingSystems: ['windows', 'macos'],
locales: ['de-DE', 'en-US'],
},
});
Jeder Parameter ist ein Array, aus dem der Generator zufällig wählt. Wenn Sie browsers: ['chrome', 'firefox'] angeben, variiert der Generator zwischen beiden Browsern und erzeugt jeweils das passende Header-Set. Das ist wichtig für Rotations-Szenarien: Wenn Sie 1000 Anfragen senden, sollte nicht jede Anfrage denselben User-Agent haben, aber jede Anfrage muss intern konsistent sein.
HTTP/2-Unterstützung
Modernes got-scraping unterstützt HTTP/2 über die http2-Option. Echte Browser verwenden HTTP/2 oder HTTP/3 für die meisten Anfragen an HTTPS-Endpunkte. Wenn Ihr Scraper HTTP/1.1 verwendet, während der User-Agent Chrome 120 behauptet, ist das ein weiterer Widerspruch, den Bot-Detection-Systeme ausnutzen. Mit http2: true verhandelt got-scraping automatisch das ALPN-Protokoll und verwendet HTTP/2, wenn der Server es unterstützt.
Die idiomatische API-Oberfläche: got.extend und Middleware
Der idiomatische Weg, got-scraping zu verwenden, ist nicht, jede Anfrage einzeln zu konfigurieren, sondern eine vorkonfigurierte Instanz über got.extend zu erstellen. Das entspricht dem Middleware-Muster, das auch got-scraping in der offiziellen Dokumentation empfiehlt. So definieren Sie Header-Generator und Proxy einmal und verwenden die Instanz für alle nachfolgenden Anfragen:
import { gotScraping } from 'got-scraping';
const client = gotScraping.extend({
headerGeneratorOptions: {
browsers: ['chrome'],
devices: ['desktop'],
operatingSystems: ['windows', 'macos'],
locales: ['en-US', 'de-DE'],
},
http2: true,
timeout: { request: 30000 },
retry: { limit: 3, statusCodes: [429, 503] },
});
// Alle nachfolgenden Anfragen erben die Konfiguration
const res = await client.get('https://example.com/api/data');
Die proxyUrl-Option funktioniert sowohl für HTTP/1.1- als auch für HTTP/2-Proxies. Bei HTTP/2 stellt got-scraping die Verbindung zum Proxy über HTTP/1.1 CONNECT her und verhandelt dann HTTP/2 zum Zielserver durch den Tunnel. Das ist transparent — Sie setzen einfach proxyUrl und der Rest wird gehandhabt.
Residential-Proxies über ProxyHat einbinden
Sobald Header und TLS konsistent sind, wird die IP-Adresse zum entscheidenden Faktor. Residential-Proxies verwenden IP-Adressen von echten ISPs (Deutsche Telekom, Comcast, Vodafone), die von Anti-Bot-Systemen nicht als Datacenter-Traffic klassifiziert werden. ProxyHat bietet Residential-, Mobile- und Datacenter-Proxies über dasselbe Gateway unter gate.proxyhat.com an.
Für HTTP-Verbindungen verwenden Sie Port 8080:
http://user-country-US-session-abc123:pass@gate.proxyhat.com:8080
Für SOCKS5-Verbindungen, die in einigen Netzwerkumgebungen zuverlässiger tunneln, verwenden Sie Port 1080:
socks5://user-country-US-session-abc123:pass@gate.proxyhat.com:1080
Die Geo-Targeting- und Session-Flags werden im Benutzernamen codiert. country-US routet die Anfrage durch eine US-Residential-IP, session-abc123 hält dieselbe IP für die Dauer der Session fest. Das ist entscheidend für Cookie-abhängige Seiten: Wenn sich die IP zwischen Login und Datenabruf ändert, wird die Session ungültig.
Warum sind Residential-IPs so wichtig, wenn Header und TLS bereits echt aussehen? Weil Anti-Bot-Systeme mehrere Signale kombinieren. Ein perfekter Chrome-Header mit einer AWS-IP ergibt einen Signalwert von 0,9+ (sehr wahrscheinlich Bot). Dieselben Header mit einer Comcast-Residential-IP ergeben einen Signalwert von 0,1–0,3 (wahrscheinlich Mensch). Die IP-Adresse ist oft der gewichtigste einzelne Faktor in der Bot-Score-Berechnung.
Runnable Node.js-Beispiel mit Proxy-Rotation
Hier ist ein vollständiges Beispiel, das got-scraping mit ProxyHat Residential-Proxies kombiniert, per-request Usernamen generiert und Retry-Hooks für fehlgeschlagene Anfragen implementiert:
import { gotScraping } from 'got-scraping';
import { randomUUID } from 'crypto';
const PROXYHAT_USER = process.env.PROXYHAT_USER;
const PROXYHAT_PASS = process.env.PROXYHAT_PASS;
// Generiert einen eindeutigen Usernamen pro Anfrage für IP-Rotation
function buildProxyUrl(country = 'US', session = null) {
const sid = session || randomUUID().slice(0, 8);
const username = `${PROXYHAT_USER}-country-${country}-session-${sid}`;
return `http://${username}:${PROXYHAT_PASS}@gate.proxyhat.com:8080`;
}
const client = gotScraping.extend({
headerGeneratorOptions: {
browsers: ['chrome'],
devices: ['desktop'],
operatingSystems: ['windows', 'macos'],
locales: ['en-US'],
},
http2: true,
timeout: { request: 30000 },
retry: {
limit: 3,
statusCodes: [429, 503, 502],
backoffLimit: 5000,
},
hooks: {
beforeRequest: [
(options) => {
// Neue IP pro Anfrage, außer bei Sticky-Session
if (!options.context?.stickySession) {
options.proxyUrl = buildProxyUrl('US');
}
},
],
afterResponse: [
(response, retryWithMergedOptions) => {
if (response.statusCode === 403) {
// Neue IP bei Blockierung erzwingen
const newProxy = buildProxyUrl('US');
return retryWithMergedOptions({
proxyUrl: newProxy,
});
}
return response;
},
],
},
});
// Sticky Session für Login + Datenabruf
async function scrapeWithLogin() {
const session = randomUUID().slice(0, 8);
const stickyProxy = buildProxyUrl('US', session);
const loginRes = await client.post('https://example.com/login', {
proxyUrl: stickyProxy,
context: { stickySession: session },
json: { username: 'user', password: 'pass' },
});
const dataRes = await client.get('https://example.com/api/data', {
proxyUrl: stickyProxy,
context: { stickySession: session },
cookieJar: client.cookieJar,
});
return dataRes.body;
}
Das beforeRequest-Hook rotiert die IP-Adresse für jede Anfrage, es sei denn, eine Sticky-Session ist im Kontext markiert. Das afterResponse-Hook erkennt 403-Blockierungen und erzwingt eine neue IP über retryWithMergedOptions. Das ist die idiomatische Art, Proxy-Rotation in got-scraping zu implementieren — nicht als Hack, sondern als Middleware-Schicht.
Produktionsmuster: Concurrency, Cookies und Crawlee
Begrenzte Concurrency mit p-limit
In der Produktion reicht es nicht, Anfragen nacheinander zu senden. Aber unbegrenzte Parallelität führt zu Rate-Limit-Blockierungen und Proxy-Überlastung. Die idiomatische Lösung ist p-limit, um die Anzahl gleichzeitig laufender Anfragen zu begrenzen:
import pLimit from 'p-limit';
const limit = pLimit(10); // Maximal 10 gleichzeitige Anfragen
const urls = ['https://example.com/page/1', 'https://example.com/page/2', /* ... */];
const results = await Promise.all(
urls.map((url) =>
limit(() => client.get(url).then((r) => r.body).catch((e) => {
console.error(`Fehler bei ${url}:`, e.message);
return null;
}))
)
);
Ein Limit von 10 gleichzeitigen Anfragen ist ein guter Startwert für die meisten Ziele. Für streng geschützte Seiten sollten Sie auf 3–5 reduzieren. Bei weniger geschützten APIs können Sie 20–50 ausprobieren. Überwachen Sie die Erfolgsrate: Wenn sie unter 90% fällt, senken Sie das Limit.
Cookie-Management über got's CookieJar
Viele Seiten setzen Cookies bei der ersten Anfrage, die bei nachfolgenden Anfragen erwartet werden. got bietet ein eingebautes cookieJar, das auf tough-cookie basiert. Bei der Verwendung mit Proxies müssen Sie sicherstellen, dass die Cookie-Domain zur Ziel-URL passt, nicht zur Proxy-URL:
import { gotScraping } from 'got-scraping';
import { CookieJar } from 'tough-cookie';
const cookieJar = new CookieJar();
const client = gotScraping.extend({
cookieJar,
headerGeneratorOptions: {
browsers: ['chrome'],
devices: ['desktop'],
operatingSystems: ['macos'],
locales: ['en-US'],
},
});
// Erste Anfrage setzt Cookies
await client.get('https://example.com/');
// Zweite Anfrage sendet Cookies automatisch mit
const res = await client.get('https://example.com/dashboard');
Integration in Crawlee's CheerioCrawler
Wenn Ihr Scraper wächst, brauchen Sie URL-Queue-Management, Deduplizierung und Fehlerbehandlung auf höherer Ebene. Crawlee — ebenfalls von Apify — integriert got-scraping als Standard-HTTP-Client. Der CheerioCrawler ist die idiomatische Wahl für HTML-Scraping ohne Headless-Browser:
import { CheerioCrawler } from 'crawlee';
const crawler = new CheerioCrawler({
requestHandler: async ({ $, request }) => {
const title = $('title').text();
const links = $('a[href]').map((_, el) => $(el).attr('href')).get();
console.log(`${request.url}: ${title}`);
},
maxRequestsPerCrawl: 1000,
maxConcurrency: 10,
requestHandlerTimeout: 30000,
// got-scraping ist bereits integriert —
// Sie können headerGeneratorOptions über requestOptions setzen
requestOptions: {
headerGeneratorOptions: {
browsers: ['chrome'],
operatingSystems: ['windows'],
locales: ['en-US'],
},
},
proxyConfiguration: {
newUrlFunction: () => {
const sid = randomUUID().slice(0, 8);
return `http://${PROXYHAT_USER}-country-US-session-${sid}:${PROXYHAT_PASS}@gate.proxyhat.com:8080`;
},
},
});
await crawler.run(['https://example.com/']);
Crawlee kümmert sich um URL-Queues, Retry-Logik und Concurrency-Begrenzung. Die proxyConfiguration mit newUrlFunction rotiert die IP pro Anfrage — dieselbe Strategie wie im beforeRequest-Hook, aber auf Framework-Ebene.
Proxy-Typ-Vergleich für got-scraping
| Proxy-Typ | Erfolgsrate (geschützte Seiten) | Latenz | Kosten | Use Case |
|---|---|---|---|---|
| Residential | 90–98% | 200–800ms | Mittel | SERP-Scraping, E-Commerce, Login-Seiten |
| Mobile | 95–99% | 500–1500ms | Hoch | Hoch geschützte Ziele, Social Media |
| Datacenter | 30–70% | 50–200ms | Niedrig | Un geschützte APIs, einfache Seiten |
Die Wahl des Proxy-Typs hängt vom Ziel ab. Für SERP-Tracking und E-Commerce-Preisüberwachung sind Residential-Proxies der Sweet Spot zwischen Kosten und Zuverlässigkeit. Für Web-Scraping stark geschützter Ziele wie Social-Media-Plattformen sind Mobile-Proxies oft die einzige zuverlässige Option. Datacenter-Proxies eignen sich für interne APIs oder Seiten ohne Bot-Detection.
Wann ein Headless-Browser unvermeidbar ist
Got-scraping löst das Header- und HTTP/2-Problem. Es löst nicht das TLS-Fingerabdruck-Problem vollständig, und es kann kein JavaScript ausführen. Wenn die Zielseite einen JavaScript-Challenge erfordert (z. B. Cloudflare Turnstile, DataDome JS-Challenge) oder die Inhalte erst nach clientseitigem Rendering sichtbar sind, ist ein Headless-Browser unvermeidbar.
In diesem Fall ist Playwright mit playwright-extra und stealth-Plugin die idiomatische Wahl. Sie können ProxyHat-Proxies direkt über die proxy-Option von Playwright einbinden:
import { chromium } from 'playwright-extra';
import StealthPlugin from 'puppeteer-extra-plugin-stealth';
chromium.use(StealthPlugin());
const browser = await chromium.launch({
headless: true,
proxy: {
server: 'gate.proxyhat.com:8080',
username: `${PROXYHAT_USER}-country-US-session-${randomUUID().slice(0, 8)}`,
password: PROXYHAT_PASS,
},
});
Für die Skalierung eines Headless-Fleets empfiehlt sich Containerisierung mit Docker und einem Orchestrierungstool wie Kubernetes oder AWS ECS. Jede Browser-Instanz verbraucht 200–500 MB RAM, sodass auf einer m5.large-Instanz (8 GB RAM) etwa 10–15 gleichzeitige Browser-Sessions realistisch sind. Im Vergleich dazu verbraucht eine got-scraping-Instanz nur 20–50 MB und erlaubt 100+ gleichzeitige Anfragen auf derselben Maschine.
Ethische und rechtliche Überlegungen
Scraping ist ein mächtiges Werkzeug, aber es muss verantwortungsvoll eingesetzt werden. Hier sind die wichtigsten Punkte:
- Öffentliche Daten nur: Scrapen Sie nur Daten, die ohne Login öffentlich zugänglich sind. Das Scrapen hinter einer Paywall oder Login-Schicht kann gegen das CFAA (USA) oder ähnliche Gesetze verstoßen.
- DSGVO: Wenn Sie personenbezogene Daten von EU-Bürgern sammeln, greift die DSGVO. Das gilt auch für scheinbar öffentliche Daten wie Profile auf öffentlichen Plattformen.
- robots.txt: Respektieren Sie die
robots.txt-Anweisungen einer Website.got-scrapingprüft diese nicht automatisch — das ist Ihre Verantwortung. - Rate-Limits: Senden Sie nicht mehr Anfragen, als ein menschlicher Besucher erzeugen würde. Eine Rate von 1–2 Anfragen pro Sekunde pro Ziel-Domain ist ein guter Richtwert.
- Offizielle APIs bevorzugen: Wenn eine Website eine API anbietet, verwenden Sie diese. Sie ist zuverlässiger, schneller und rechtlich sicherer.
Weitere Informationen zu ProxyHat-Standorten und -Preisen finden Sie auf unserer Standortseite und der Preisseite. Detaillierte Verbindungsinformationen finden Sie in der ProxyHat-Dokumentation.
Key Takeaways
- Header-Konsistenz ist das erste Hindernis: Got-scraping's Header-Generator erzeugt kohärente Browser-Header-Sets mit korrekter Reihenfolge, sec-ch-ua und Accept-Language. Das eliminiert die häufigste Ursache für 403-Fehler.
- HTTP/2 schließt die Lücke: Echte Browser verwenden HTTP/2. Got-scraping verhandelt ALPN automatisch und verwendet HTTP/2, wenn der Server es unterstützt.
- Residential-IPs sind der entscheidende Faktor: Selbst mit perfekten Headern blockieren Anti-Bot-Systeme Datacenter-IPs. ProxyHat Residential-Proxies über
gate.proxyhat.com:8080lösen dieses Problem.- Middleware über Hooks: Verwenden Sie
beforeRequestundafterResponse-Hooks für Proxy-Rotation und Retry-Logik, statt Anfragen manuell zu konfigurieren.- Concurrency begrenzen:
p-limitmit 10 gleichzeitigen Anfragen ist ein solider Startwert. Überwachen Sie die Erfolgsrate und passen Sie an.- Crawlee für Skalierung: Wenn URL-Queues und Deduplizierung nötig werden, ist Crawlee's
CheerioCrawlerdie idiomatische Weiterentwicklung.- Headless-Browser als letztes Mittel: Nur einsetzen, wenn JavaScript-Challenges oder clientseitiges Rendering unvermeidbar sind. Der Ressourcenverbrauch ist 10x höher als bei HTTP-Scraping.
FAQ
Was ist got-scraping in Node.js?
Got-scraping ist ein von Apify entwickeltes npm-Paket, das auf dem HTTP-Client got aufbaut und um einen Header-Generator sowie HTTP/2-Unterstützung erweitert wurde. Es erzeugt kohärente Browser-Header-Sets (Reihenfolge, sec-ch-ua, accept-language), sodass Anfragen aus Node.js wie echte Browser-Anfragen wirken und seltener von Anti-Bot-Systemen blockiert werden.
Warum ist got-scraping in Node.js wichtig für Proxy-Nutzer?
Wenn Header und TLS-Fingerabdruck wie ein echter Browser aussehen, aber die IP-Adresse aus einem Datacenter stammt, erkennen Anti-Bot-Systeme den Widerspruch und blockieren die Anfrage. Got-scraping in Kombination mit Residential-Proxies schließt diese Lücke, da die IP-Adresse wie eine normale Endnutzer-Verbindung aussieht.
Welcher Proxy-Typ funktioniert am besten für got-scraping in Node.js?
Residential-Proxies sind die beste Wahl, da sie IP-Adressen von echten ISPs verwenden und von Anti-Bot-Systemen seltener als Datacenter-Traffic erkannt werden. Für maximale Vertrauenswürdigkeit eignen sich Mobile-Proxies. Datacenter-Proxies reichen für einfache Ziele ohne strenge Anti-Bot-Prüfungen, scheitern aber oft bei geschützten Seiten.
Wie vermeidet man Blockierungen bei got-scraping in Node.js?
Kombinieren Sie got-scraping's Header-Generator mit Residential-Proxies, verwenden Sie Sticky Sessions für Cookie-abhängige Seiten, begrenzen Sie die Concurrency mit p-limit, implementieren Sie Retry-Hooks mit exponentiellem Backoff und respektieren Sie robots.txt sowie Rate-Limits. Nutzen Sie offizielle APIs, wenn verfügbar.
