Headless Browser Detection umgehen: Selenium und Puppeteer Maskierung beim Scraping

Moderne Websites haben gelernt, automatisierte Browser (Selenium, Puppeteer, Playwright) zu erkennen und blockieren deren Anfragen. Headless-Browser hinterlassen Dutzende digitaler Spuren, anhand derer Anti-Bot-Systeme die Automatisierung innerhalb von Millisekunden erkennen. In diesem Leitfaden werden wir alle Methoden zur Tarnung von Headless-Browsern mit Codebeispielen in Python und JavaScript durchgehen, damit Ihre Scraper stabil ohne Blockierungen arbeiten.

Der Artikel richtet sich an Entwickler, die sich mit Web-Scraping, Testautomatisierung oder der Datensammlung von geschützten Websites beschäftigen. Wir werden die technischen Details der Erkennung und praktische Lösungen zur Umgehung des Schutzes betrachten.

Wie Websites Headless-Browser erkennen: Hauptmethoden

Anti-Bot-Systeme verwenden eine mehrstufige Überprüfung des Browsers, indem sie Hunderte von Parametern analysieren. Headless-Browser unterscheiden sich von normalen in vielen Merkmalen, die sich nicht einfach durch das Ersetzen des User-Agent verbergen lassen. Das Verständnis der Erkennungsmethoden ist der erste Schritt zur effektiven Tarnung.

JavaScript-Markern der Automatisierung

Die häufigste Methode ist die Überprüfung von JavaScript-Eigenschaften, die nur in automatisierten Browsern erscheinen:

• navigator.webdriver — gibt true in Selenium und Puppeteer zurück
• window.chrome — fehlt in Headless Chrome
• navigator.plugins.length — ist 0 im Headless-Modus
• navigator.languages — oft ein leeres Array oder enthält nur "en-US"
• navigator.permissions — API funktioniert im Headless-Modus unterschiedlich

Analyse des Chrome DevTools Protokolls

Puppeteer und Playwright steuern den Browser über das Chrome DevTools Protokoll (CDP). Das Vorhandensein einer CDP-Verbindung kann durch spezielle JavaScript-Überprüfungen entdeckt werden, die Objekte window.cdc_ analysieren oder Anomalien im Verhalten von Maus- und Tastaturereignissen überprüfen.

Canvas und WebGL Fingerprinting

Headless-Browser generieren identische Canvas- und WebGL-Fingerabdrücke, da sie Software-Rendering anstelle von Hardware-Rendering verwenden. Anti-Bot-Systeme erstellen ein unsichtbares Canvas-Element, zeichnen Text oder Formen darauf und berechnen den Hash des Bildes. Wenn Tausende von Benutzern denselben Hash haben, ist das ein Zeichen für Bots.

Verhaltensanalyse

Moderne Systeme (DataDome, PerimeterX, Cloudflare Bot Management) analysieren Mausbewegungen, Scrollgeschwindigkeit, Klickmuster. Headless-Browser führen Aktionen sofort und ohne natürliche Verzögerungen aus, was die Automatisierung verrät. Auch Ereignisse werden analysiert: In einem normalen Browser tritt immer ein mousemove-Ereignis vor einem Klick auf, während Bots oft ohne vorherige Mausbewegung klicken.

Entfernen von navigator.webdriver und anderen JavaScript-Markern

Die Eigenschaft navigator.webdriver ist der einfachste Weg zur Erkennung von Selenium und anderen WebDriver-Tools. In einem normalen Browser gibt diese Eigenschaft undefined zurück, während sie in einem automatisierten true zurückgibt. Sie kann durch die Ausführung von JavaScript-Code vor dem Laden der Seite entfernt werden.

Selenium (Python): Entfernen von Webdriver über CDP

Für Selenium muss das Chrome DevTools Protokoll verwendet werden, um JavaScript vor dem Laden von Seiten auszuführen:

from selenium import webdriver
from selenium.webdriver.chrome.options import Options

options = Options()
options.add_argument('--disable-blink-features=AutomationControlled')

driver = webdriver.Chrome(options=options)

# Entfernen von navigator.webdriver über CDP
driver.execute_cdp_cmd('Page.addScriptToEvaluateOnNewDocument', {
    'source': '''
        Object.defineProperty(navigator, 'webdriver', {
            get: () => undefined
        });
    '''
})

driver.get('https://example.com')

Die Option --disable-blink-features=AutomationControlled deaktiviert das Flag, das Chrome im Automatisierungsmodus hinzufügt. Dies ist ein grundlegender Schutz, der mit anderen Methoden kombiniert werden muss.

Puppeteer (Node.js): Tarnung über Page.evaluateOnNewDocument

In Puppeteer wird die Methode page.evaluateOnNewDocument() verwendet, um Code vor dem Laden der Seite auszuführen:

const puppeteer = require('puppeteer');

(async () => {
    const browser = await puppeteer.launch({
        headless: true,
        args: ['--disable-blink-features=AutomationControlled']
    });
    
    const page = await browser.newPage();
    
    // Entfernen von Webdriver und anderen Markern
    await page.evaluateOnNewDocument(() => {
        Object.defineProperty(navigator, 'webdriver', {
            get: () => undefined
        });
        
        // Hinzufügen des chrome-Objekts
        window.chrome = {
            runtime: {}
        };
        
        // Emulation von Plugins
        Object.defineProperty(navigator, 'plugins', {
            get: () => [1, 2, 3, 4, 5]
        });
    });
    
    await page.goto('https://example.com');
})();

Playwright: Eingebaute Tarnungsoptionen

Playwright bietet eine fortschrittlichere Tarnung von Haus aus, aber zusätzliche Anpassungen sind dennoch erforderlich:

const { chromium } = require('playwright');

(async () => {
    const browser = await chromium.launch({
        headless: true,
        args: ['--disable-blink-features=AutomationControlled']
    });
    
    const context = await browser.newContext({
        userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
    });
    
    const page = await context.newPage();
    
    await page.addInitScript(() => {
        Object.defineProperty(navigator, 'webdriver', {
            get: () => undefined
        });
    });
    
    await page.goto('https://example.com');
})();

Tarnung des Chrome DevTools Protokolls

Puppeteer und Playwright hinterlassen Spuren der CDP-Verbindung, die durch die Analyse von window-Objekten entdeckt werden können. Anti-Bot-Systeme suchen nach Variablen mit dem Präfix cdc_, $cdc_ oder __webdriver_, die Chrome bei der Verbindung über das DevTools Protokoll erstellt.

Entfernen von CDP-Variablen

Das folgende Skript entfernt alle Variablen, die mit der Automatisierung in Verbindung stehen, aus dem window-Objekt:

await page.evaluateOnNewDocument(() => {
    // Entfernen aller Variablen mit dem Präfix cdc_
    const cdcProps = Object.keys(window).filter(prop => 
        prop.includes('cdc_') || 
        prop.includes('$cdc_') || 
        prop.includes('__webdriver_')
    );
    
    cdcProps.forEach(prop => {
        delete window[prop];
    });
    
    // Überschreiben von document.__proto__, um CDP zu verbergen
    const originalQuery = document.querySelector;
    document.querySelector = function(selector) {
        if (selector.includes('cdc_')) return null;
        return originalQuery.call(this, selector);
    };
});

Verwendung von gepatchten Chromium-Versionen

Es gibt modifizierte Builds von Chromium, die keine CDP-Spuren hinterlassen. Zum Beispiel wendet die Bibliothek puppeteer-extra mit dem Plugin puppeteer-extra-plugin-stealth automatisch Dutzende von Patches zur Tarnung von CDP an.

Anpassung von User-Agent und HTTP-Headern

Headless-Browser verwenden veraltete oder unrealistische User-Agent-Strings. Zum Beispiel fügt Puppeteer standardmäßig das Wort "HeadlessChrome" in den User-Agent ein. Darüber hinaus müssen zusätzliche Header konfiguriert werden, die in den Anfragen normaler Browser vorhanden sind.

Aktuelle User-Agent zur Tarnung

Verwenden Sie aktuelle User-Agent von echten Browsern. Hier sind Beispiele für 2024:

# Chrome 120 auf Windows 10
Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36

# Chrome 120 auf macOS
Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36

# Firefox 121 auf Windows
Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:121.0) Gecko/20100101 Firefox/121.0

Anpassung der Header in Selenium

from selenium.webdriver.chrome.options import Options

options = Options()
options.add_argument('user-agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36')

# Zusätzliche Header über CDP
driver.execute_cdp_cmd('Network.setUserAgentOverride', {
    "userAgent": 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
    "platform": 'Win32',
    "acceptLanguage": 'en-US,en;q=0.9'
})

Anpassung der Header in Puppeteer

await page.setUserAgent('Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36');

await page.setExtraHTTPHeaders({
    'Accept-Language': 'en-US,en;q=0.9',
    'Accept-Encoding': 'gzip, deflate, br',
    'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
    'Sec-Fetch-Site': 'none',
    'Sec-Fetch-Mode': 'navigate',
    'Sec-Fetch-User': '?1',
    'Sec-Fetch-Dest': 'document'
});

Die Header Sec-Fetch-* sind von entscheidender Bedeutung — sie wurden in Chrome 76+ eingeführt und ihr Fehlen verrät alte Browser-Versionen oder Bots.

Emulation von Canvas und WebGL Fingerprint

Canvas- und WebGL-Fingerprinting ist eine leistungsstarke Erkennungsmethode, da Headless-Browser identische Fingerabdrücke erzeugen. Anti-Bot-Systeme erstellen ein unsichtbares Canvas, zeichnen Text darauf und berechnen den Hash der Pixel. Wenn Tausende von Anfragen denselben Hash haben, sind das Bots.

Hinzufügen von Rauschen zum Canvas

Das folgende Skript fügt dem Canvas-Fingerabdruck zufälliges Rauschen hinzu, wodurch jede Anfrage einzigartig wird:

await page.evaluateOnNewDocument(() => {
    const originalToDataURL = HTMLCanvasElement.prototype.toDataURL;
    const originalToBlob = HTMLCanvasElement.prototype.toBlob;
    const originalGetImageData = CanvasRenderingContext2D.prototype.getImageData;
    
    // Funktion zum Hinzufügen von Rauschen
    const addNoise = (canvas, context) => {
        const imageData = originalGetImageData.call(context, 0, 0, canvas.width, canvas.height);
        for (let i = 0; i < imageData.data.length; i += 4) {
            imageData.data[i] += Math.floor(Math.random() * 10) - 5;
            imageData.data[i + 1] += Math.floor(Math.random() * 10) - 5;
            imageData.data[i + 2] += Math.floor(Math.random() * 10) - 5;
        }
        context.putImageData(imageData, 0, 0);
    };
    
    HTMLCanvasElement.prototype.toDataURL = function() {
        addNoise(this, this.getContext('2d'));
        return originalToDataURL.apply(this, arguments);
    };
});

Emulation von WebGL-Parametern

WebGL gibt Informationen über die Grafikkarte und Treiber preis. Im Headless-Modus geben diese Parameter Software-Rendering zurück:

await page.evaluateOnNewDocument(() => {
    const getParameter = WebGLRenderingContext.prototype.getParameter;
    WebGLRenderingContext.prototype.getParameter = function(parameter) {
        // Emulation einer echten Grafikkarte
        if (parameter === 37445) {
            return 'Intel Inc.';
        }
        if (parameter === 37446) {
            return 'Intel Iris OpenGL Engine';
        }
        return getParameter.call(this, parameter);
    };
});

Der Parameter 37445 ist UNMASKED_VENDOR_WEBGL, und 37446 ist UNMASKED_RENDERER_WEBGL. Im Headless-Modus geben sie "Google SwiftShader" zurück, was die Automatisierung verrät.

Selenium Stealth: Fertige Lösungen für Python

Die Bibliothek selenium-stealth wendet automatisch Dutzende von Patches zur Tarnung von Selenium an. Dies ist die einfachste Lösung für Python-Entwickler, die keine manuelle Anpassung jedes Parameters erfordert.

Installation und grundlegende Konfiguration

pip install selenium-stealth

from selenium import webdriver
from selenium_stealth import stealth
from selenium.webdriver.chrome.options import Options

options = Options()
options.add_argument("--headless")
options.add_argument("--no-sandbox")
options.add_argument("--disable-dev-shm-usage")

driver = webdriver.Chrome(options=options)

# Anwenden von Stealth-Patches
stealth(driver,
    languages=["en-US", "en"],
    vendor="Google Inc.",
    platform="Win32",
    webgl_vendor="Intel Inc.",
    renderer="Intel Iris OpenGL Engine",
    fix_hairline=True,
)

driver.get("https://bot.sannysoft.com")
driver.save_screenshot("test.png")

Die Bibliothek entfernt automatisch navigator.webdriver, fügt window.chrome hinzu, emuliert Plugins, tarnt WebGL und wendet über 20 weitere Patches an. Dies deckt 80% der Erkennungsmöglichkeiten ab.

Erweiterte Konfiguration mit Proxys

Für eine vollständige Tarnung kombinieren Sie selenium-stealth mit residential Proxys — sie bieten echte IP-Adressen von Haushaltsbenutzern, was entscheidend für die Umgehung fortschrittlicher Anti-Bot-Systeme ist:

from selenium.webdriver.common.proxy import Proxy, ProxyType

proxy = Proxy()
proxy.proxy_type = ProxyType.MANUAL
proxy.http_proxy = "ip:port"
proxy.ssl_proxy = "ip:port"

capabilities = webdriver.DesiredCapabilities.CHROME
proxy.add_to_capabilities(capabilities)

driver = webdriver.Chrome(desired_capabilities=capabilities, options=options)
stealth(driver, languages=["en-US", "en"], vendor="Google Inc.", platform="Win32")

Puppeteer Extra Stealth Plugin für Node.js

Für Puppeteer gibt es das Plugin puppeteer-extra-plugin-stealth, das die fortschrittlichste Lösung zur Tarnung von Headless-Browsern im JavaScript-Ökosystem darstellt. Es enthält 23 unabhängige Module, von denen jedes einen bestimmten Aspekt der Automatisierung tarnt.

Installation und grundlegende Verwendung

npm install puppeteer-extra puppeteer-extra-plugin-stealth

const puppeteer = require('puppeteer-extra');
const StealthPlugin = require('puppeteer-extra-plugin-stealth');

puppeteer.use(StealthPlugin());

(async () => {
    const browser = await puppeteer.launch({ 
        headless: true,
        args: ['--no-sandbox', '--disable-setuid-sandbox']
    });
    
    const page = await browser.newPage();
    await page.goto('https://bot.sannysoft.com');
    await page.screenshot({ path: 'test.png' });
    await browser.close();
})();

Was der Stealth Plugin tarnt

Das Plugin wendet automatisch die folgenden Patches an:

• Entfernen von navigator.webdriver
• Hinzufügen des window.chrome-Objekts
• Emulation der navigator.permissions-API
• Tarnung von navigator.plugins und navigator.mimeTypes
• Emulation von Canvas und WebGL Fingerprint
• Tarnung von User-Agent und Sprachen
• Behebung von Anomalien im iframe contentWindow
• Emulation der Battery API, Media Devices, WebRTC

Konfiguration mit Proxys und zusätzlichen Parametern

const puppeteer = require('puppeteer-extra');
const StealthPlugin = require('puppeteer-extra-plugin-stealth');
const AdblockerPlugin = require('puppeteer-extra-plugin-adblocker');

puppeteer.use(StealthPlugin());
puppeteer.use(AdblockerPlugin({ blockTrackers: true }));

(async () => {
    const browser = await puppeteer.launch({
        headless: true,
        args: [
            '--proxy-server=http://your-proxy:port',
            '--disable-web-security',
            '--disable-features=IsolateOrigins,site-per-process'
        ]
    });
    
    const page = await browser.newPage();
    
    // Proxy-Authentifizierung
    await page.authenticate({
        username: 'your-username',
        password: 'your-password'
    });
    
    await page.setViewport({ width: 1920, height: 1080 });
    await page.goto('https://example.com', { waitUntil: 'networkidle2' });
})();

Playwright: Anti-Detection-Konfiguration

Playwright hat eine ausgeklügeltere Architektur im Vergleich zu Puppeteer und hinterlässt weniger Spuren der Automatisierung. Für die Umgehung fortschrittlicher Anti-Bot-Systeme sind jedoch zusätzliche Anpassungen erforderlich. Für Playwright gibt es einen Port des Stealth-Plugins — playwright-extra.

Installation von playwright-extra

npm install playwright-extra playwright-extra-plugin-stealth playwright

const { chromium } = require('playwright-extra');
const stealth = require('playwright-extra-plugin-stealth');

chromium.use(stealth());

(async () => {
    const browser = await chromium.launch({ headless: true });
    const context = await browser.newContext({
        userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
        viewport: { width: 1920, height: 1080 },
        locale: 'en-US',
        timezoneId: 'America/New_York'
    });
    
    const page = await context.newPage();
    await page.goto('https://bot.sannysoft.com');
    await page.screenshot({ path: 'test.png' });
    await browser.close();
})();

Konfiguration des Browser-Kontexts für maximale Tarnung

Playwright ermöglicht die Erstellung isolierter Browser-Kontexte mit individuellen Einstellungen. Dies ist nützlich für Multi-Account-Management oder paralleles Scraping:

const context = await browser.newContext({
    userAgent: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36',
    viewport: { width: 1440, height: 900 },
    locale: 'en-US',
    timezoneId: 'America/Los_Angeles',
    permissions: ['geolocation'],
    geolocation: { latitude: 37.7749, longitude: -122.4194 },
    colorScheme: 'light',
    deviceScaleFactor: 2,
    isMobile: false,
    hasTouch: false,
    // Proxy-Konfiguration für den Kontext
    proxy: {
        server: 'http://your-proxy:port',
        username: 'user',
        password: 'pass'
    }
});

Die Parameter geolocation und timezoneId müssen mit der IP-Adresse des Proxys übereinstimmen, da sonst Anti-Bot-Systeme eine Diskrepanz feststellen (z. B. IP aus Kalifornien, aber Zeitzone New York).

Proxy-Rotation zur Risikominderung von Blockierungen

Selbst ein perfekt getarnter Headless-Browser kann blockiert werden, wenn er eine IP-Adresse für Hunderte von Anfragen verwendet. Moderne Anti-Bot-Systeme analysieren die Anfragefrequenz von einer IP und blockieren verdächtige Aktivitäten. Die Rotation von Proxys ist ein unverzichtbares Element des Schutzes beim Scraping.

Proxy-Typen für Scraping: Vergleich

Für das Scraping geschützter Websites (Marktplätze, soziale Netzwerke, Werbeplattformen) werden residential Proxys empfohlen, da sie echte IPs von Haushaltsbenutzern haben und nicht auf den schwarzen Listen von Anti-Bot-Systemen landen.

Implementierung der Proxy-Rotation in Puppeteer

const puppeteer = require('puppeteer-extra');
const StealthPlugin = require('puppeteer-extra-plugin-stealth');

puppeteer.use(StealthPlugin());

const proxyList = [
    'http://user1:pass1@proxy1:port',
    'http://user2:pass2@proxy2:port',
    'http://user3:pass3@proxy3:port'
];

async function scrapeWithRotation(urls) {
    for (let i = 0; i < urls.length; i++) {
        const proxy = proxyList[i % proxyList.length];
        
        const browser = await puppeteer.launch({
            headless: true,
            args: [`--proxy-server=${proxy}`]
        });
        
        const page = await browser.newPage();
        
        try {
            await page.goto(urls[i], { waitUntil: 'networkidle2' });
            const data = await page.evaluate(() => document.body.innerText);
            console.log(data);
        } catch (error) {
            console.error(`Error on ${urls[i]}:`, error);
        } finally {
            await browser.close();
        }
        
        // Verzögerung zwischen Anfragen
        await new Promise(resolve => setTimeout(resolve, 2000));
    }
}

scrapeWithRotation([
    'https://example1.com',
    'https://example2.com',
    'https://example3.com'
]);

Rotation über Session-basierte Proxys

Einige Proxy-Anbieter (einschließlich ProxyCove) bieten eine session-basierte Rotation an — jede Anfrage erhält automatisch eine neue IP, ohne dass der Browser neu gestartet werden muss. Dies wird über ein spezielles Proxy-URL-Format realisiert:

// Format: username-session-RANDOM:password@gateway:port
const generateSessionProxy = () => {
    const sessionId = Math.random().toString(36).substring(7);
    return `http://username-session-${sessionId}:password@gateway.proxycove.com:12321`;
};

const browser = await puppeteer.launch({
    args: [`--proxy-server=${generateSessionProxy()}`]
});

Wie man die Qualität der Tarnung überprüft: Testwerkzeuge

Nach der Konfiguration der Tarnung ist es wichtig zu überprüfen, wie gut Ihr Headless-Browser einen normalen Benutzer imitiert. Es gibt mehrere spezialisierte Websites, die Dutzende von Browserparametern analysieren und anzeigen, welche Spuren der Automatisierung zurückgeblieben sind.

Haupt-Testwerkzeuge

• bot.sannysoft.com — überprüft 15+ Erkennungsparameter, einschließlich Webdriver, Chrome-Objekt, Plugins, Canvas
• arh.antoinevastel.com/bots/areyouheadless — spezialisiert auf die Erkennung von Headless Chrome
• pixelscan.net — fortgeschrittene Analyse des Fingerprints mit Visualisierung aller Parameter
• abrahamjuliot.github.io/creepjs — die detaillierteste Analyse (200+ Parameter), zeigt das Vertrauensniveau des Browsers an
• iphey.com — Überprüfung der IP-Adresse auf Zugehörigkeit zu Proxys und VPNs

Automatisierung der Tests

Erstellen Sie ein Skript zur automatischen Überprüfung der Tarnung nach jeder Änderung der Einstellungen:

const puppeteer = require('puppeteer-extra');
const StealthPlugin = require('puppeteer-extra-plugin-stealth');

puppeteer.use(StealthPlugin());

async function testStealth() {
    const browser = await puppeteer.launch({ headless: true });
    const page = await browser.newPage();
    
    // Test 1: Sannysoft
    await page.goto('https://bot.sannysoft.com');
    await page.screenshot({ path: 'test-sannysoft.png', fullPage: true });
    
    // Test 2: Are you headless
    await page.goto('https://arh.antoinevastel.com/bots/areyouheadless');
    const headlessDetected = await page.evaluate(() => {
        return document.body.innerText.includes('You are not Chrome headless');
    });
    console.log('Headless erkannt:', !headlessDetected);
    
    // Test 3: Webdriver-Eigenschaft
    const webdriverPresent = await page.evaluate(() => navigator.webdriver);
    console.log('navigator.webdriver:', webdriverPresent);
    
    // Test 4: Chrome-Objekt
    const chromePresent = await page.evaluate(() => !!window.chrome);
    console.log('window.chrome vorhanden:', chromePresent);
    
    await browser.close();
}

testStealth();

Checkliste für erfolgreiche Tarnung

Fazit

Die Tarnung von Headless-Browsern ist eine komplexe Aufgabe, die Aufmerksamkeit auf Dutzende von Parametern erfordert. Moderne Anti-Bot-Systeme verwenden maschinelles Lernen und analysieren Hunderte von Browsermerkmalen gleichzeitig, weshalb das einfache Ersetzen des User-Agent nicht mehr funktioniert. Für erfolgreiches Scraping ist es notwendig, mehrere Schutzmethoden zu kombinieren.

Die wichtigsten Elemente einer effektiven Tarnung sind das Entfernen von JavaScript-Markern der Automatisierung (navigator.webdriver, CDP-Variablen), die Emulation von Canvas- und WebGL-Fingerprints, die Anpassung realistischer HTTP-Header und die Verwendung qualitativ hochwertiger Proxys. Fertige Lösungen (selenium-stealth für Python, puppeteer-extra-plugin-stealth für Node.js) decken 80% der Erkennungsmöglichkeiten ab, aber für die Umgehung fortschrittlicher Schutzmaßnahmen sind zusätzliche Anpassungen erforderlich.

Ein kritischer Punkt ist die Wahl des Proxys. Selbst ein perfekt getarnter Browser wird blockiert, wenn er IP-Adressen aus schwarzen Listen verwendet oder zu viele Anfragen von einer IP aus sendet. Für das Scraping geschützter Websites empfehlen wir die Verwendung von residential Proxys mit automatischer Rotation — sie bieten einen hohen Trust Score und ein minimales Risiko von Blockierungen, da sie echte IP-Adressen von Haushaltsbenutzern anstelle von Serveradressen verwenden.

Testen Sie regelmäßig die Qualität der Tarnung über spezialisierte Dienste (bot.sannysoft.com, pixelscan.net) und passen Sie die Einstellungen an Änderungen in den Anti-Bot-Systemen an. Scraping ist ein ständiges Wettrüsten zwischen Bot-Entwicklern und Schutzanbietern, daher kann eine Konfiguration, die heute funktioniert, in einigen Monaten ein Update erfordern.