Vollständiger Leitfaden zur Maskierung von Selenium und Puppeteer vor Erkennung

Moderne Anti-Bot-Schutzsysteme erkennen automatisierte Browser leicht anhand von Dutzenden von Merkmalen: von JavaScript-Variablen bis hin zu Verhaltensmerkmalen von WebDriver. Websites verwenden Cloudflare, DataDome, PerimeterX und eigene Lösungen, die bis zu 90 % der Anfragen von Selenium und Puppeteer in der Standardkonfiguration blockieren.

In diesem Leitfaden werden wir alle Methoden zur Maskierung von Automatisierung besprechen: von grundlegenden Einstellungen bis hin zu fortgeschrittenen Techniken zum Umgehen der Erkennung. Sie erhalten fertige Lösungen mit Codebeispielen für Python und Node.js, die gegen die meisten Schutzsysteme funktionieren.

Wie Websites Automatisierung erkennen

Anti-Bot-Schutzsysteme analysieren den Browser anhand vieler Parameter gleichzeitig. Selbst wenn Sie ein Merkmal verbergen, werden die anderen die Automatisierung verraten. Das Verständnis aller Erkennungsmethoden ist der Schlüssel zur effektiven Maskierung.

WebDriver-Indikatoren

Die einfachste Methode zur Erkennung besteht darin, JavaScript-Variablen zu überprüfen, die nur in automatisierten Browsern vorhanden sind:

// Diese Variablen verraten Selenium/Puppeteer
navigator.webdriver === true
window.navigator.webdriver === true
document.$cdc_ // ChromeDriver spezifische Variable
window.document.documentElement.getAttribute("webdriver")
navigator.plugins.length === 0 // Automatisierte Browser haben keine Plugins
navigator.languages === "" // Leere Sprachliste

Cloudflare und ähnliche Systeme überprüfen diese Eigenschaften zuerst. Wenn auch nur eine positiv zurückgegeben wird, wird die Anfrage blockiert.

Fingerprinting des Browsers

Fortgeschrittene Systeme erstellen einen einzigartigen Fingerabdruck des Browsers basierend auf Dutzenden von Parametern:

• Canvas Fingerprinting — Rendering versteckter Bilder und Analyse von Pixel-Daten
• WebGL Fingerprinting — Parameter des Grafikrenderers und der Grafikkarte
• Audio Context — einzigartige Eigenschaften der Audioverarbeitung
• Fonts Fingerprinting — Liste der installierten Schriftarten im System
• Screen Resolution — Bildschirmauflösung, Farbtiefe, verfügbarer Bereich
• Timezone & Language — Zeitzone, Browser-Sprachen, Systemlokalisierung

Automatisierte Browser haben oft untypische Kombinationen dieser Parameter. Zum Beispiel hat Headless Chrome keine Plugins, unterstützt jedoch WebGL — eine solche Kombination kommt bei echten Nutzern äußerst selten vor.

Verhaltensanalyse

Moderne Systeme verfolgen Verhaltensmuster:

• Bewegungen der Maus — Bots bewegen den Cursor in geraden Linien oder bewegen ihn gar nicht
• Geschwindigkeit der Aktionen — sofortiges Ausfüllen von Formularen, unnatürliche Klickgeschwindigkeit
• Scrollmuster — plötzliche Sprünge anstelle von sanftem Scrollen
• Tastaturereignisse — keine natürlichen Verzögerungen zwischen den Tastenanschlägen
• Frequenz der Anfragen — zu regelmäßige Intervalle zwischen den Aktionen

Grundlegende Maskierung von Selenium

Selenium WebDriver hinterlässt in der Standardkonfiguration viele Spuren. Lassen Sie uns eine schrittweise Konfiguration zur Minimierung der Erkennung am Beispiel von Python und ChromeDriver betrachten.

Deaktivierung des Webdriver-Flags

Der erste Schritt besteht darin, die Variable navigator.webdriver zu verbergen. Dies geschieht über das Chrome DevTools-Protokoll:

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

# Konfiguration der Chrome-Optionen
chrome_options = Options()

# Deaktivieren des Automatisierungsflags
chrome_options.add_experimental_option("excludeSwitches", ["enable-automation"])
chrome_options.add_experimental_option('useAutomationExtension', False)

# Erstellen des Treibers
driver = webdriver.Chrome(options=chrome_options)

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

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

Konfiguration von User-Agent und anderen Headern

Headless-Browser verwenden häufig veraltete oder spezifische User-Agent-Strings. Es ist notwendig, einen aktuellen User-Agent eines echten Browsers festzulegen:

# Aktueller User-Agent von Chrome unter Windows
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'
chrome_options.add_argument(f'user-agent={user_agent}')

# Zusätzliche Argumente zur Maskierung
chrome_options.add_argument('--disable-blink-features=AutomationControlled')
chrome_options.add_argument('--disable-dev-shm-usage')
chrome_options.add_argument('--no-sandbox')
chrome_options.add_argument('--disable-gpu')

# Fenstergröße wie bei einem echten Benutzer
chrome_options.add_argument('--window-size=1920,1080')
chrome_options.add_argument('--start-maximized')

Hinzufügen von Plugins und Sprachen

Automatisierte Browser haben keine Plugins und zeigen häufig eine leere Sprachliste an. Wir beheben dies über CDP:

driver.execute_cdp_cmd('Page.addScriptToEvaluateOnNewDocument', {
    'source': '''
        Object.defineProperty(navigator, 'languages', {
            get: () => ['de-DE', 'de', 'en']
        });
        
        Object.defineProperty(navigator, 'plugins', {
            get: () => [
                {
                    0: {type: "application/x-google-chrome-pdf", suffixes: "pdf", description: "Portable Document Format"},
                    description: "Portable Document Format",
                    filename: "internal-pdf-viewer",
                    length: 1,
                    name: "Chrome PDF Plugin"
                },
                {
                    0: {type: "application/pdf", suffixes: "pdf", description: ""},
                    description: "",
                    filename: "mhjfbmdgcfjbbpaeojofohoefgiehjai",
                    length: 1,
                    name: "Chrome PDF Viewer"
                }
            ]
        });
        
        Object.defineProperty(navigator, 'platform', {
            get: () => 'Win32'
        });
    '''
})

Vollständiges Beispiel zur Konfiguration von Selenium

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

def create_stealth_driver():
    chrome_options = Options()
    
    # Grundlegende Maskierungseinstellungen
    chrome_options.add_experimental_option("excludeSwitches", ["enable-automation"])
    chrome_options.add_experimental_option('useAutomationExtension', False)
    chrome_options.add_argument('--disable-blink-features=AutomationControlled')
    
    # User-Agent
    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'
    chrome_options.add_argument(f'user-agent={user_agent}')
    
    # Fenstergröße
    chrome_options.add_argument('--window-size=1920,1080')
    chrome_options.add_argument('--start-maximized')
    
    driver = webdriver.Chrome(options=chrome_options)
    
    # Maskierungsskript über CDP
    stealth_script = '''
        Object.defineProperty(navigator, 'webdriver', {get: () => undefined});
        Object.defineProperty(navigator, 'languages', {get: () => ['de-DE', 'de']});
        Object.defineProperty(navigator, 'platform', {get: () => 'Win32'});
        
        window.chrome = {
            runtime: {}
        };
        
        Object.defineProperty(navigator, 'plugins', {
            get: () => [1, 2, 3, 4, 5]
        });
    '''
    
    driver.execute_cdp_cmd('Page.addScriptToEvaluateOnNewDocument', {
        'source': stealth_script
    })
    
    return driver

# Verwendung
driver = create_stealth_driver()
driver.get('https://bot.sannysoft.com/')  # Website zur Erkennungstest

Konfiguration von Puppeteer zum Umgehen der Erkennung

Puppeteer hat die gleichen Erkennungsprobleme wie Selenium. Für Node.js gibt es jedoch eine fertige Bibliothek puppeteer-extra-plugin-stealth, die die meisten Maskierungseinstellungen automatisiert.

Installation von puppeteer-extra

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

Grundkonfiguration mit dem Stealth-Plugin

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

// Stealth-Plugin aktivieren
puppeteer.use(StealthPlugin());

(async () => {
    const browser = await puppeteer.launch({
        headless: 'new', // Neuer Headless-Modus von Chrome
        args: [
            '--no-sandbox',
            '--disable-setuid-sandbox',
            '--disable-dev-shm-usage',
            '--disable-accelerated-2d-canvas',
            '--disable-gpu',
            '--window-size=1920,1080',
            '--disable-web-security',
            '--disable-features=IsolateOrigins,site-per-process'
        ]
    });
    
    const page = await browser.newPage();
    
    // Viewport festlegen
    await page.setViewport({
        width: 1920,
        height: 1080,
        deviceScaleFactor: 1
    });
    
    // User-Agent festlegen
    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');
    
    // Zusätzliche Header
    await page.setExtraHTTPHeaders({
        'Accept-Language': 'de-DE,de;q=0.9',
        'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8'
    });
    
    await page.goto('https://bot.sannysoft.com/');
    
    // Screenshot zur Überprüfung
    await page.screenshot({ path: 'test.png' });
    
    await browser.close();
})();

Manuelle Konfiguration ohne Plugins

Wenn Sie die vollständige Kontrolle wünschen oder keine Drittanbieterbibliotheken verwenden können, konfigurieren Sie die Maskierung manuell:

const puppeteer = require('puppeteer');

(async () => {
    const browser = await puppeteer.launch({
        headless: 'new',
        args: ['--no-sandbox', '--disable-setuid-sandbox']
    });
    
    const page = await browser.newPage();
    
    // Webdriver und andere Eigenschaften überschreiben
    await page.evaluateOnNewDocument(() => {
        Object.defineProperty(navigator, 'webdriver', {
            get: () => undefined
        });
        
        Object.defineProperty(navigator, 'languages', {
            get: () => ['de-DE', 'de']
        });
        
        Object.defineProperty(navigator, 'plugins', {
            get: () => [1, 2, 3, 4, 5]
        });
        
        // Chrome headless maskieren
        Object.defineProperty(navigator, 'platform', {
            get: () => 'Win32'
        });
        
        window.chrome = {
            runtime: {}
        };
        
        // Berechtigungen überschreiben
        const originalQuery = window.navigator.permissions.query;
        window.navigator.permissions.query = (parameters) => (
            parameters.name === 'notifications' ?
                Promise.resolve({ state: Notification.permission }) :
                originalQuery(parameters)
        );
    });
    
    await page.goto('https://example.com');
    await browser.close();
})();

Konfiguration zum Umgehen von Cloudflare

Cloudflare verwendet fortschrittliche Erkennungsmethoden. Um dies zu umgehen, müssen zufällige Verzögerungen und die Simulation von Aktionen hinzugefügt werden:

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

puppeteer.use(StealthPlugin());

async function bypassCloudflare(url) {
    const browser = await puppeteer.launch({
        headless: 'new',
        args: [
            '--no-sandbox',
            '--disable-setuid-sandbox',
            '--disable-web-security'
        ]
    });
    
    const page = await browser.newPage();
    
    // Zufälliger User-Agent
    const userAgents = [
        'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
        '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',
        'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
    ];
    await page.setUserAgent(userAgents[Math.floor(Math.random() * userAgents.length)]);
    
    // Auf die Seite gehen
    await page.goto(url, { waitUntil: 'networkidle2' });
    
    // Warten auf die Cloudflare-Prüfung (normalerweise 5-10 Sekunden)
    await page.waitForTimeout(8000);
    
    // Zufällige Mausbewegung
    await page.mouse.move(100, 100);
    await page.mouse.move(200, 200);
    
    const content = await page.content();
    await browser.close();
    
    return content;
}

Bekämpfung von JavaScript-Fingerprinting

JavaScript-Fingerprinting ist die Erstellung eines einzigartigen Fingerabdrucks des Browsers basierend auf vielen Parametern. Selbst wenn Sie den Webdriver verborgen haben, analysieren Systeme Hunderte anderer Eigenschaften, um Automatisierung zu erkennen.

Hauptvektoren des Fingerprintings

Anti-Bot-Schutzsysteme überprüfen die folgenden Parameter:

Komplexes Maskierungsskript

Das folgende Skript überschreibt die meisten problematischen Eigenschaften. Integrieren Sie es über CDP (Selenium) oder evaluateOnNewDocument (Puppeteer):

const stealthScript = `
    // Entfernen von webdriver
    Object.defineProperty(navigator, 'webdriver', {
        get: () => undefined
    });
    
    // Hinzufügen des chrome Objekts
    window.chrome = {
        runtime: {},
        loadTimes: function() {},
        csi: function() {},
        app: {}
    };
    
    // Überschreiben von Berechtigungen
    const originalQuery = window.navigator.permissions.query;
    window.navigator.permissions.query = (parameters) => (
        parameters.name === 'notifications' ?
            Promise.resolve({ state: Notification.permission }) :
            originalQuery(parameters)
    );
    
    // Maskierung von Plugins
    Object.defineProperty(navigator, 'plugins', {
        get: () => {
            return [
                {
                    0: {type: "application/x-google-chrome-pdf", suffixes: "pdf"},
                    description: "Portable Document Format",
                    filename: "internal-pdf-viewer",
                    length: 1,
                    name: "Chrome PDF Plugin"
                },
                {
                    0: {type: "application/pdf", suffixes: "pdf"},
                    description: "Portable Document Format",
                    filename: "internal-pdf-viewer",
                    length: 1,
                    name: "Chrome PDF Viewer"
                },
                {
                    0: {type: "application/x-nacl"},
                    description: "Native Client Executable",
                    filename: "internal-nacl-plugin",
                    length: 2,
                    name: "Native Client"
                }
            ];
        }
    });
    
    // Sprachen
    Object.defineProperty(navigator, 'languages', {
        get: () => ['de-DE', 'de']
    });
    
    // Plattform
    Object.defineProperty(navigator, 'platform', {
        get: () => 'Win32'
    });
    
    // Anbieter
    Object.defineProperty(navigator, 'vendor', {
        get: () => 'Google Inc.'
    });
    
    // Entfernen von Spuren von Selenium
    delete window.cdc_adoQpoasnfa76pfcZLmcfl_Array;
    delete window.cdc_adoQpoasnfa76pfcZLmcfl_Promise;
    delete window.cdc_adoQpoasnfa76pfcZLmcfl_Symbol;
    
    // Battery API (nicht in headless)
    if (!navigator.getBattery) {
        navigator.getBattery = () => Promise.resolve({
            charging: true,
            chargingTime: 0,
            dischargingTime: Infinity,
            level: 1
        });
    }
`;

Entfernen von WebDriver-Eigenschaften

ChromeDriver und andere WebDriver-Implementierungen fügen spezifische Variablen in den globalen Geltungsbereich ein. Diese Variablen beginnen mit dem Präfix cdc_ und werden von Schutzsystemen leicht erkannt.

Erkennung von cdc-Variablen

Die Überprüfung des Vorhandenseins dieser Variablen kann mit einem einfachen Skript erfolgen:

// Suche nach allen cdc-Variablen
for (let key in window) {
    if (key.includes('cdc_')) {
        console.log('WebDriver-Variable erkannt:', key);
    }
}

// Typische Variablen von ChromeDriver:
// cdc_adoQpoasnfa76pfcZLmcfl_Array
// cdc_adoQpoasnfa76pfcZLmcfl_Promise
// cdc_adoQpoasnfa76pfcZLmcfl_Symbol
// $cdc_asdjflasutopfhvcZLmcfl_

Methode 1: Entfernen über CDP

Der zuverlässigste Weg besteht darin, die Variablen vor dem Laden der Seite über das Chrome DevTools-Protokoll zu entfernen:

from selenium import webdriver

driver = webdriver.Chrome()

# Entfernen aller cdc-Variablen
driver.execute_cdp_cmd('Page.addScriptToEvaluateOnNewDocument', {
    'source': '''
        // Entfernen bekannter cdc-Variablen
        const cdcProps = [
            'cdc_adoQpoasnfa76pfcZLmcfl_Array',
            'cdc_adoQpoasnfa76pfcZLmcfl_Promise',
            'cdc_adoQpoasnfa76pfcZLmcfl_Symbol',
            '$cdc_asdjflasutopfhvcZLmcfl_'
        ];
        
        cdcProps.forEach(prop => {
            delete window[prop];
        });
        
        // Entfernen aller Variablen, die 'cdc_' enthalten
        Object.keys(window).forEach(key => {
            if (key.includes('cdc_') || key.includes('$cdc_')) {
                delete window[key];
            }
        });
    '''
})

Methode 2: Modifikation von ChromeDriver

Ein radikalerer Ansatz besteht darin, die Binärdatei von ChromeDriver zu ändern, indem die Zeichenfolge cdc_ durch eine andere Zeichenfolge ersetzt wird. Dies verhindert die Erstellung dieser Variablen:

import re

def patch_chromedriver(driver_path):
    """
    Patcht ChromeDriver, indem 'cdc_' durch eine zufällige Zeichenfolge ersetzt wird
    """
    with open(driver_path, 'rb') as f:
        content = f.read()
    
    # Ersetzen aller Vorkommen von 'cdc_' durch 'dog_' (oder eine andere Zeichenfolge der gleichen Länge)
    patched = content.replace(b'cdc_', b'dog_')
    
    with open(driver_path, 'wb') as f:
        f.write(patched)
    
    print(f'ChromeDriver gepatcht: {driver_path}')

# Verwendung
patch_chromedriver('/path/to/chromedriver')

Methode 3: Verwendung von undetected-chromedriver

Die Bibliothek undetected-chromedriver patcht ChromeDriver automatisch beim Start:

pip install undetected-chromedriver

import undetected_chromedriver as uc

# Erstellen des Treibers mit automatischem Patchen
driver = uc.Chrome()

driver.get('https://nowsecure.nl/')  # Website zur Erkennungstest
input('Drücken Sie die Eingabetaste zum Schließen...')
driver.quit()

Maskierung von Canvas, WebGL und Audio API

Canvas, WebGL und Audio Fingerprinting sind Methoden zur Erstellung eines einzigartigen Fingerabdrucks basierend auf den Merkmalen der Grafikdarstellung und der Audioverarbeitung. Jede Kombination von Browser, OS und Hardware ergibt ein einzigartiges Ergebnis.

Canvas Fingerprinting

Systeme zeichnen ein verstecktes Bild auf Canvas und analysieren die resultierenden Pixel. Headless-Browser liefern häufig untypische Ergebnisse aufgrund des Fehlens von GPU-Beschleunigung.

// Typischer Code für Canvas Fingerprinting
const canvas = document.createElement('canvas');
const ctx = canvas.getContext('2d');
ctx.textBaseline = 'top';
ctx.font = '14px Arial';
ctx.fillText('Browser-Fingerabdruck', 2, 2);
const fingerprint = canvas.toDataURL();

Zum Schutz können Sie zufälligen Rauschen zur Canvas API hinzufügen:

const canvasNoiseScript = `
    // Fügen Sie zufälligen Rauschen zur Canvas hinzu
    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) {
            // Fügen Sie minimales Rauschen zu RGB hinzu (nicht für das Auge sichtbar)
            imageData.data[i] += Math.floor(Math.random() * 3) - 1;
            imageData.data[i + 1] += Math.floor(Math.random() * 3) - 1;
            imageData.data[i + 2] += Math.floor(Math.random() * 3) - 1;
        }
        context.putImageData(imageData, 0, 0);
    };
    
    // Überschreiben von toDataURL
    HTMLCanvasElement.prototype.toDataURL = function() {
        if (this.width > 0 && this.height > 0) {
            const context = this.getContext('2d');
            addNoise(this, context);
        }
        return originalToDataURL.apply(this, arguments);
    };
`;

WebGL Fingerprinting

WebGL liefert Informationen über die Grafikkarte und die Treiber. Headless-Browser zeigen häufig SwiftShader (Software-Renderer) anstelle einer echten GPU an:

const webglMaskScript = `
    // Maskierung von WebGL-Parametern
    const getParameter = WebGLRenderingContext.prototype.getParameter;
    WebGLRenderingContext.prototype.getParameter = function(parameter) {
        // UNMASKED_VENDOR_WEBGL
        if (parameter === 37445) {
            return 'Intel Inc.';
        }
        // UNMASKED_RENDERER_WEBGL
        if (parameter === 37446) {
            return 'Intel Iris OpenGL Engine';
        }
        return getParameter.call(this, parameter);
    };
    
    // Auch für WebGL2
    if (typeof WebGL2RenderingContext !== 'undefined') {
        const getParameter2 = WebGL2RenderingContext.prototype.getParameter;
        WebGL2RenderingContext.prototype.getParameter = function(parameter) {
            if (parameter === 37445) {
                return 'Intel Inc.';
            }
            if (parameter === 37446) {
                return 'Intel Iris OpenGL Engine';
            }
            return getParameter2.call(this, parameter);
        };
    }
`;

Audio Context Fingerprinting

Die Audio-API liefert ebenfalls einen einzigartigen Fingerabdruck. Fügen Sie Rauschen zur Audioverarbeitung hinzu:

const audioMaskScript = `
    // Fügen Sie Rauschen zum Audio Context hinzu
    const AudioContext = window.AudioContext || window.webkitAudioContext;
    if (AudioContext) {
        const originalCreateAnalyser = AudioContext.prototype.createAnalyser;
        AudioContext.prototype.createAnalyser = function() {
            const analyser = originalCreateAnalyser.call(this);
            const originalGetFloatFrequencyData = analyser.getFloatFrequencyData;
            analyser.getFloatFrequencyData = function(array) {
                originalGetFloatFrequencyData.call(this, array);
                // Fügen Sie minimales Rauschen hinzu
                for (let i = 0; i < array.length; i++) {
                    array[i] += Math.random() * 0.0001;
                }
            };
            return analyser;
        };
    }
`;

Nachahmung menschlichen Verhaltens

Selbst mit perfekter technischer Maskierung verraten Bots sich durch ihr Verhalten. Maschinenlern-Systeme analysieren Bewegungsmuster der Maus, Geschwindigkeit der Aktionen und die Reihenfolge der Ereignisse.

Zufällige Verzögerungen zwischen Aktionen

Verwenden Sie niemals feste Verzögerungen. Echte Benutzer machen Pausen unterschiedlicher Dauer:

import random
import time

def human_delay(min_seconds=1, max_seconds=3):
    """Zufällige Verzögerung, die einen Menschen imitiert"""
    delay = random.uniform(min_seconds, max_seconds)
    time.sleep(delay)

# Verwendung
driver.get('https://example.com')
human_delay(2, 4)  # Pause von 2-4 Sekunden

element = driver.find_element(By.ID, 'search')
human_delay(0.5, 1.5)  # Kurze Pause vor der Eingabe

element.send_keys('Suchanfrage')
human_delay(1, 2)

Sanfte Mausbewegung

Bots bewegen die Maus in geraden Linien oder teleportieren den Cursor. Echte Benutzer erzeugen kurvenreiche Trajektorien mit Beschleunigung und Verzögerung:

// Puppeteer: sanfte Mausbewegung
async function humanMouseMove(page, targetX, targetY) {
    const steps = 25; // Anzahl der Zwischenpunkte
    const currentPos = await page.evaluate(() => ({
        x: window.mouseX || 0,
        y: window.mouseY || 0
    }));
    
    for (let i = 0; i <= steps; i++) {
        const t = i / steps;
        // Verwenden Sie Easing für Sanftheit
        const ease = t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t;
        
        const x = currentPos.x + (targetX - currentPos.x) * ease;
        const y = currentPos.y + (targetY - currentPos.y) * ease;
        
        await page.mouse.move(x, y);
        await page.waitForTimeout(Math.random() * 10 + 5);
    }
    
    // Position speichern
    await page.evaluate((x, y) => {
        window.mouseX = x;
        window.mouseY = y;
    }, targetX, targetY);
}

// Verwendung
await humanMouseMove(page, 500, 300);
await page.mouse.click(500, 300);

Natürliche Scrollbewegung

Echte Benutzer scrollen sanft, mit Pausen zum Lesen des Inhalts:

async function humanScroll(page) {
    const scrollHeight = await page.evaluate(() => document.body.scrollHeight);
    const viewportHeight = await page.evaluate(() => window.innerHeight);
    
    let currentPosition = 0;
    
    while (currentPosition < scrollHeight - viewportHeight) {
        // Zufälliger Scrollschritt (200-500px)
        const scrollStep = Math.floor(Math.random() * 300) + 200;
        currentPosition += scrollStep;
        
        // Sanftes Scrollen
        await page.evaluate((pos) => {
            window.scrollTo({
                top: pos,
                behavior: 'smooth'
            });
        }, currentPosition);
        
        // Pause zum "Lesen" des Inhalts (1-3 Sekunden)
        await page.waitForTimeout(Math.random() * 2000 + 1000);
    }
}

// Verwendung
await page.goto('https://example.com');
await humanScroll(page);

Natürliche Texteingabe

Menschen tippen mit unterschiedlicher Geschwindigkeit, machen Tippfehler und korrigieren diese:

async function humanTypeText(page, selector, text) {
    await page.click(selector);
    
    for (let char of text) {
        // Zufällige Verzögerung zwischen den Tastenanschlägen (50-200ms)
        const delay = Math.random() * 150 + 50;
        await page.waitForTimeout(delay);
        
        // 5% Chance auf einen Tippfehler
        if (Math.random() < 0.05) {
            // Einen zufälligen Buchstaben tippen
            const wrongChar = String.fromCharCode(97 + Math.floor(Math.random() * 26));
            await page.keyboard.type(wrongChar);
            await page.waitForTimeout(100 + Math.random() * 100);
            // Löschen (Backspace)
            await page.keyboard.press('Backspace');
            await page.waitForTimeout(50 + Math.random() * 50);
        }
        
        await page.keyboard.type(char);
    }
}

// Verwendung
await humanTypeText(page, '#search-input', 'Beispiel-Suchanfrage');

Integration von Proxys für vollständige Anonymität

Die Maskierung des Browsers ist nutzlos, wenn alle Anfragen von einer IP-Adresse kommen. Anti-Bot-Schutzsysteme verfolgen die Anzahl der Anfragen von jeder IP und blockieren verdächtige Aktivitäten. Proxys sind ein unverzichtbarer Bestandteil jeder ernsthaften Automatisierung.

Auswahl des Proxytyps

Verschiedene Aufgaben erfordern unterschiedliche Proxytypen: