got-scraping in Node.js: Residential Proxies & Header Generator Praxisleitfaden

Warum got-scraping in Node.js rohe HTTP-Clients überlegen ist

Wenn Sie mit got oder axios Web-Daten abrufen, fällt das meistens nicht sofort auf — bis es plötzlich nicht mehr funktioniert. Ein einzelner Request mit axios.get(url) sendet einen Header-Set, der für einen Browser völlig untypisch ist: Accept: application/json, text/plain, */*, keine sec-ch-ua-Header, keine accept-language-Kohärenz, und häufig eine Header-Reihenfolge, die kein echter Chrome je produzieren würde. Moderne Anti-Bot-Systeme wie Cloudflare, Datadome und Akamai prüfen genau das.

got-scraping in Node.js löst dieses Problem an der Wurzel. Es ist Apify's auf got basierender HTTP-Client, der einen Header Generator integriert, der zusammenhängende, browser-ähnliche Header-Sets erzeugt — mit korrekter Reihenfolge, konsistenten sec-ch-ua-Werten, accept-language-Ketten und HTTP/2-Unterstützung. In Kombination mit einem got-scraping proxy aus dem Residential-Bereich erhalten Sie eine Anfrage, die auf Netzwerk- und Anwendungsebene wie ein echter Browser aussieht.

Bevor wir in die Implementierung einsteigen, ein wichtiger Hinweis: Dieser Artikel behandelt das Scraping öffentlicher Daten. Das unbefugte Scraping geschützter Inhalte kann in den USA unter den FTC Act und den Computer Fraud and Abuse Act (CFAA) fallen, und in der EU greift die DSGVO (GDPR) bei personenbezogenen Daten. Respektieren Sie robots.txt, Rate-Limits und die Nutzungsbedingungen jeder Website. Wenn eine offizielle API existiert, ziehen Sie diese vor.

Technischer Kontext: Warum rohe Requests scheitern

Anti-Bot-Systeme arbeiten auf mehreren Ebenen:

• TLS-Fingerprinting (JA3/JA4): Die Cipher-Suite-Reihenfolge und Extensions Ihres TLS-Handshakes verrät Node.js. got-scraping nutzt HTTP/2 und einen angepassten TLS-Stack, der näher an Chrome herankommt.
• Header-Kohärenz: Ein echter Chrome 120 auf Windows sendet sec-ch-ua, sec-ch-ua-mobile, sec-ch-ua-platform in einer bestimmten Reihenfolge. Fehlt einer oder stimmt die Reihenfolge nicht, ist die Anfrage verdächtig.
• IP-Reputation: Datacenter-IP-Adressen (AWS, GCP, Hetzner) erscheinen in bekannten Blocklisten. Residential-IPs aus echten ISP-Bereichen haben eine wesentlich höhere Erfolgsquote.
• Verhaltensanalyse: Zu viele Requests pro Sekunde von derselben IP, kein Referrer, keine Cookies — alles Signale für Bot-Erkennung.

Ein MDN-Artikel zu sec-ch-ua zeigt, wie komplex die Client-Hints-Kette ist. Es reicht nicht, einen Header hinzuzufügen — alle müssen zusammenpassen.

got-scraping Header Generator: Die idiomsche API-Oberfläche

Der Kern von got-scraping ist die Integration des header-generator-Pakets. Statt Header manuell zusammenzubasteln, generiert got-scraping bei jedem Request einen konsistenten Satz basierend auf von Ihnen gewählten Browser-, Geräte- und Betriebssystem-Profilen.

Die zentralen Erweiterungspunkte sind:

• got.extend() — erstellt eine vorkonfigurierte Instanz mit Standard-Headern, Hooks und Proxy-Einstellungen.
• useHeaderGenerator: true — aktiviert den Header Generator für diese Instanz.
• headerGeneratorOptions — steuert, welche Browser-, Geräte- und OS-Profile verwendet werden: browsers: ['chrome'], devices: ['desktop'], operatingSystems: ['windows', 'macos'].
• proxyUrl — übergibt einen HTTP/HTTPS- oder SOCKS5-Proxy pro Request oder global.

Grundlegende Konfiguration

import { gotScraping } from 'got-scraping';

// Vorkonfigurierte Instanz mit Header Generator
const client = gotScraping.extend({
  useHeaderGenerator: true,
  headerGeneratorOptions: {
    browsers: ['chrome'],
    devices: ['desktop'],
    operatingSystems: ['windows', 'macos'],
    locales: ['de-DE', 'en-US'],
  },
  timeout: { request: 30000 },
  retry: { limit: 3 },
});

const response = await client.get('https://example.com/data');
console.log(response.body.slice(0, 200));

Diese Konfiguration erzeugt bei jedem Aufruf einen frischen, kohärenten Header-Satz, der wie ein echter Chrome-Browser auf Windows oder macOS aussieht — inklusive korrekter sec-ch-ua-Kette und accept-language.

Residential Proxies mit got-scraping: ProxyHat-Integration

Selbst mit perfekten Headern und HTTP/2-TLS-Handshake reicht ein Datacenter-IP-Bereich nicht aus. Anti-Bot-Dienste verknüpfen IP-ASN-Daten mit Header-Profilen. Wenn ein Chrome-Header-Set von einer AWS-IP kommt, ist das verdächtig. Hier kommt der got-scraping proxy ins Spiel.

Residential-Proxies leiten Ihren Traffic durch echte ISP-IP-Adressen. ProxyHat bietet Residential-, Mobile- und Datacenter-Proxys über gate.proxyhat.com. Für HTTP verwenden Sie Port 8080, für SOCKS5 Port 1080.

HTTP-Proxy mit got-scraping

import { gotScraping } from 'got-scraping';

const client = gotScraping.extend({
  useHeaderGenerator: true,
  headerGeneratorOptions: {
    browsers: ['chrome'],
    devices: ['desktop'],
    operatingSystems: ['windows'],
  },
  proxyUrl: 'http://USERNAME:PASSWORD@gate.proxyhat.com:8080',
});

const res = await client.get('https://httpbin.org/headers');
console.log(JSON.parse(res.body).headers);

Geo-Targeting und Sticky Sessions

ProxyHat unterstützt Geo-Targeting und Sticky Sessions über Flags im Username:

• user-country-US:pass — US-Exit-IP
• user-country-DE-city-berlin:pass — Berlin-Exit-IP
• user-session-abc123:pass — Sticky Session mit ID abc123

// US-Exit mit Sticky Session
const proxyUrl = 'http://user-country-US-session-abc123:pass@gate.proxyhat.com:8080';

const res = await gotScraping({
  url: 'https://httpbin.org/ip',
  proxyUrl,
  useHeaderGenerator: true,
});
console.log(JSON.parse(res.body).origin); // US-IP

SOCKS5 über Port 1080

Für Anwendungen, die SOCKS5 benötigen (z. B. für bestimmte Tunneling-Szenarien), verwenden Sie Port 1080:

const proxyUrl = 'socks5://user-country-DE:pass@gate.proxyhat.com:1080';

const res = await gotScraping({
  url: 'https://httpbin.org/ip',
  proxyUrl,
  useHeaderGenerator: true,
});

Nodejs Scraping Proxy: Per-Request-Rotation mit ProxyHat

In der Produktion reicht ein einziger Proxy nicht aus. Sie müssen pro Request rotieren — verschiedene IPs, verschiedene Sessions, verschiedene Geo-Targets. Hier ist ein vollständiges Beispiel mit nodejs scraping proxy-Rotation, Retry-Hooks und einer kleinen ProxyHat-SDK-Funktion, die pro Request einen neuen Username generiert.

import { gotScraping } from 'got-scraping';
import pLimit from 'p-limit';
import { randomUUID } from 'crypto';

// ProxyHat SDK: generiert per-Request Username mit Rotation
function buildProxyUrl(opts = {}) {
  const {
    country = 'US',
    session = randomUUID().slice(0, 8),
    username = 'user',
    password = 'pass',
  } = opts;
  return `http://${username}-country-${country}-session-${session}:${password}@gate.proxyhat.com:8080`;
}

// got-scraping Instanz mit Retry-Hook
const client = gotScraping.extend({
  useHeaderGenerator: true,
  headerGeneratorOptions: {
    browsers: ['chrome'],
    devices: ['desktop'],
    operatingSystems: ['windows', 'macos'],
    locales: ['en-US', 'de-DE'],
  },
  timeout: { request: 30000 },
  retry: {
    limit: 4,
    statusCodes: [403, 429, 500, 502, 503],
    backoffLimit: 5000,
  },
  hooks: {
    beforeRequest: [
      (options) => {
        // Pro Request neuer Proxy mit frischer Session
        options.proxyUrl = buildProxyUrl({
          country: 'US',
          username: 'user',
          password: 'pass',
        });
      },
    ],
    afterResponse: [
      (response, retryWithMergedOptions) => {
        if (response.statusCode === 403 || response.statusCode === 429) {
          // Bei Block: neue Session erzwingen
          return retryWithMergedOptions({
            proxyUrl: buildProxyUrl({ country: 'US' }),
          });
        }
        return response;
      },
    ],
  },
});

// Bounded Concurrency mit p-limit
const limit = pLimit(10); // max 10 parallele Requests

async function scrapeUrl(url) {
  try {
    const res = await client.get(url);
    return { url, status: res.statusCode, length: res.body.length };
  } catch (err) {
    return { url, error: err.message };
  }
}

const urls = Array.from({ length: 50 }, (_, i) =>
  `https://httpbin.org/anything?page=${i}`
);

const results = await Promise.all(
  urls.map((url) => limit(() => scrapeUrl(url)))
);

const successCount = results.filter((r) => r.status === 200).length;
console.log(`Erfolgreich: ${successCount}/${urls.length}`);

Dieses Beispiel zeigt mehrere Produktionsmuster gleichzeitig:

• Per-Request-Proxy-Rotation über den beforeRequest-Hook mit frischer Session-ID pro Request.
• Retry mit Proxy-Wechsel über den afterResponse-Hook — bei 403/429 wird ein neuer Proxy zugewiesen.
• Bounded Concurrency mit p-limit — verhindert, dass 50 Requests gleichzeitig rausgehen und Rate-Limits auslösen.
• Header Generator aktiviert, sodass jeder Request einen konsistenten Browser-Header-Set erhält.

Produktionsmuster: Cookies, Concurrency und Crawlee

Cookie-Jars für Session-Persistenz

Viele Websites setzen Cookies beim ersten Request und erwarten diese bei nachfolgenden Anfragen. got-scraping unterstützt tough-cookie-Jars nativ:

import { gotScraping } from 'got-scraping';
import { CookieJar } from 'tough-cookie';

const cookieJar = new CookieJar();

const session = gotScraping.extend({
  useHeaderGenerator: true,
  cookieJar,
  proxyUrl: 'http://user-country-DE-session-persist1:pass@gate.proxyhat.com:8080',
});

// Erster Request setzt Cookies
await session.get('https://example.com/login');
// Zweiter Request sendet Cookies automatisch
const res = await session.get('https://example.com/dashboard');

Kombinieren Sie Sticky Sessions (session-persist1) mit Cookie-Jars, um Login-Flows zu durchlaufen, ohne den Proxy zu wechseln.

Skalierung mit Crawlee's CheerioCrawler

Wenn Ihr Scraper wächst, lohnt sich der Wechsel zu Crawlee, Apify's Scraping-Framework. CheerioCrawler nutzt intern got-scraping und fügt Request-Queues, Deduplizierung und automatische Retries hinzu:

import { CheerioCrawler } from 'crawlee';

const crawler = new CheerioCrawler({
  requestHandler: async ({ $, request }) => {
    const title = $('title').text();
    console.log(`${request.url}: ${title}`);
  },
  useHeaderGenerator: true,
  headerGeneratorOptions: {
    browsers: ['chrome'],
    devices: ['desktop'],
    operatingSystems: ['windows'],
  },
  proxyConfiguration: {
    proxyUrls: [
      'http://user-country-US-session-s1:pass@gate.proxyhat.com:8080',
      'http://user-country-US-session-s2:pass@gate.proxyhat.com:8080',
      'http://user-country-US-session-s3:pass@gate.proxyhat.com:8080',
    ],
  },
  maxConcurrency: 20,
  maxRequestRetries: 3,
});

await crawler.run(['https://example.com/page-1', 'https://example.com/page-2']);

Crawlee rotiert automatisch durch die proxyUrls und kombiniert sie mit dem Header Generator. Mit maxConcurrency: 20 halten Sie die Last in einem vertretbaren Rahmen — erfahrungsgemäß sind 10–20 parallele Requests pro Proxy-Session ein guter Startpunkt.

Containerisierung

Für verteilte Scraping-Jobs können Sie Ihren Crawler in Docker-Container packen und horizontal skalieren. Jeder Container erhält seine eigenen Session-IDs und kann unabhängig skaliert werden. Mit Kubernetes und einem Proxy-Pool von 100+ gleichzeitigen Sessions erreichen Sie Durchsätze von 500–1000 Requests pro Minute, ohne einzelne IPs zu überlasten.

Wann ein Headless Browser unvermeidbar ist

got-scraping ist extrem effizient — ein einzelner Prozess kann hunderte Requests pro Sekunde abarbeiten, da kein Browser-Prozess gestartet wird. Aber einige Websites erfordern JavaScript-Ausführung, um Inhalte zu rendern. Wenn die Ziel-Website SPA-Frameworks (React, Vue, Angular) nutzt oder Cloudflare Turnstile/CAPTCHA einsetzt, reicht ein HTTP-Client nicht aus.

In diesem Fall ist PlaywrightCrawler aus Crawlee die nächste Stufe. Er nutzt got-scraping für die Navigation und einen echten Chromium für das Rendering. Der Performance-Overhead ist erheblich — ein Headless-Browser verbraacht ~150 MB RAM pro Tab und ist 10–50x langsamer als ein reiner HTTP-Request. Setzen Sie ihn nur ein, wenn JavaScript-Rendering nachweislich erforderlich ist.

Eine Strategie für hybrides Scraping: Verwenden Sie got-scraping für die ersten 90% der Requests und fallen Sie auf Playwright zurück, nur wenn ein 403/429 auftritt oder wenn der HTML-Body Hinweise auf JavaScript-Rendering enthält (z. B. leere <div id="root">-Tags).

Ethik und rechtliche Rahmenbedingungen

Wichtig: Scraping öffentlicher Daten ist in vielen Rechtsräumen legal, aber die Grenzen sind fließend. Der CFAA in den USA wurde durch Van Buren v. United States (2021) eingeschränkt, aber unbefugter Zugriff auf geschützte Systeme bleibt strafbar. Die DSGVO verlangt eine Rechtsgrundlage für die Verarbeitung personenbezogener Daten — auch wenn diese öffentlich zugänglich sind.

• Prüfen Sie robots.txt vor dem Scraping. got-scraping respektiert diese nicht automatisch — das ist Ihre Verantwortung.
• Rate-Limits respektieren: Halten Sie sich an Crawl-delay in robots.txt und setzen Sie eigene Limits wie maxConcurrency.
• Offizielle APIs bevorzugen: Wenn die Ziel-Website eine API anbietet (z. B. Google Custom Search API, Amazon Product Advertising API), verwenden Sie diese statt HTML-Scraping.
• Personenbezogene Daten: Das Scraping von Profildaten, E-Mail-Adressen oder anderen PII ohne Rechtsgrundlage ist eine DSGVO-Verletzung.
• Nutzungsbedingungen: Viele Websites verbieten Scraping in ihren ToS. Ein Verstoß kann zu Klagen führen (siehe hiQ Labs v. LinkedIn).

Weitere Details zu ProxyHat's Standorten und Einsatzmöglichkeiten finden Sie auf unserer Locations-Seite und der Web-Scraping-Use-Case-Seite. Die vollständige API-Dokumentation finden Sie unter docs.proxyhat.com.

Key Takeaways

• Header-Generator ist Pflicht: got-scraping's useHeaderGenerator erzeugt kohärente Browser-Header-Sets, die sec-ch-ua, accept-language und korrekte Reihenfolge abdecken — das allein reicht aber nicht.
• Residential Proxies sind der zweite Hebel: Selbst perfekte Header scheitern an Datacenter-IP-Reputation. Kombinieren Sie Header Generator mit Residential-IPs über gate.proxyhat.com:8080.
• Per-Request-Rotation: Verwenden Sie den beforeRequest-Hook, um pro Request einen neuen Proxy mit frischer Session-ID zu generieren. Der afterResponse-Hook fängt 403/429 ab und rotiert den Proxy.
• Bounded Concurrency: p-limit mit 10–20 parallelen Requests ist ein sicherer Startpunkt. Über 50 parallele Requests pro Session erhöhen die Block-Wahrscheinlichkeit drastisch.
• Crawlee für Skalierung: Wenn Ihr Scraper wächst, migrieren Sie zu CheerioCrawler, das got-scraping intern nutzt und Request-Queues, Retries und Proxy-Rotation hinzufügt.
• Ethik zuerst: Nur öffentliche Daten, robots.txt respektieren, offizielle APIs bevorzugen, DSGVO beim Umgang mit personenbezogenen Daten beachten.

Bereit loszulegen? Werfen Sie einen Blick auf unsere Preise für Residential Proxies oder lesen Sie unseren Leitfaden zu SERP-Tracking für spezifische Anwendungsfälle.