Überwindung von CAPTCHA in Puppeteer-Skripten: Von reCAPTCHA zu Erkennungsdiensten

CAPTCHAs sind dazu gedacht, Bots zu blockieren, wodurch die Automatisierung mit Tools wie Puppenspieler herausfordernd. Dieser Artikel erklärt, wie man CAPTCHA-Probleme umgeht, von Stealth-Techniken bis hin zu Lösungsmethoden. Folgendes lernen Sie:

• Arten von CAPTCHAs: Textbasiert, bildbasiert, reCAPTCHA, hCAPTCHA, und Audio-CAPTCHAs.
• Erkennung vermeiden: Verwenden Sie Puppeteer-Extra-Stealth-Plugins, verwalten Sie Browser-Fingerabdrücke und simulieren Sie menschliches Verhalten (Tippen, Mausbewegungen, Scrollen).
• CAPTCHAs lösen: Integrieren Sie Dienste wie 2Captcha oder verwenden Sie OCR-Tools wie Tesseract für Bild-CAPTCHAs.
• Verbesserung der Erfolgsraten: Rotieren Sie IPs, behandeln Sie Fehler mit Wiederholungsversuchen und optimieren Sie die Ressourcennutzung.

Schneller Vergleich der CAPTCHA-Typen

Erfahren Sie, wie Sie mit diesen Methoden die Automatisierung optimieren, gleichzeitig eine Erkennung vermeiden und CAPTCHAs effizient lösen können.

Wie man umgehen kann reCAPTCHA mit Puppenspieler und Headless ...

Methoden zur Verhinderung der Bot-Erkennung

Um CAPTCHA-Herausforderungen effektiv zu umgehen, müssen Puppeteer-Skripte das Verhalten echter menschlicher Benutzer nachahmen. Dazu gehören Stealth-Techniken und natürliche Verhaltensmuster.

Einrichten von Puppeteer-extra Stealth

Die richtigen puppeteer-extra Mit seinem Stealth-Plugin kann Bot-Erkennung verhindert werden. So richten Sie es ein:

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

Sie können auch bestimmte Ausweichtechniken aktivieren:

puppeteer.use(StealthPlugin({
  enabledEvasions: new Set([
    "chrome.app",
    "chrome.csi",
    "defaultArgs",
    "navigator.plugins"
  ])
}))

Das Stealth-Plugin bekämpft gängige Erkennungsmethoden durch:

• Entferne den navigator.webdriver Resorts
• Anzeigen für Headless Chrome ausblenden
• Hinzufügen von Chrome-App- und CSI-Objekten
• Browser-Fingerabdrücke anpassen

Browser-Fingerabdruckverwaltung

Browser-Fingerprinting ist ein Schlüsselfaktor bei der Bot-Erkennung. Um ein überzeugendes Browserprofil zu erstellen, konzentrieren Sie sich auf diese Bereiche:

Zusätzlich zu statischen Konfigurationen ist die Einbeziehung dynamischer, menschenähnlicher Verhaltensweisen von entscheidender Bedeutung.

Simulation menschlichen Verhaltens

Die Simulation menschlichen Verhaltens trägt dazu bei, das Erkennungsrisiko zu verringern. Hier sind einige effektive Techniken:

• Tippmuster
  Führen Sie zufällige Verzögerungen zwischen den Tastenanschlägen ein (z. B. 50 ms bis 200 ms), um die natürliche Tippgeschwindigkeit nachzuahmen und automatisierte Eingabemuster zu vermeiden.
• Mausbewegung
  Verwenden Sie nichtlineare Mauspfade mit unterschiedlichen Geschwindigkeiten. Kleine, zufällige Abweichungen können menschliche Unvollkommenheiten bei der Cursorsteuerung nachbilden.
• Seiteninteraktion
  Simulieren Sie realistisches Scrollen mit variablen Geschwindigkeiten und Pausen. Durch zufällige Anpassungen des Ansichtsfensters können Sie Lese- oder Scanverhalten emulieren.

Starten Sie abschließend den Browser mit Argumenten, die die Bot-Erkennung reduzieren:

const browser = await puppeteer.launch({
  args: [
    '--disable-blink-features=AutomationControlled',
    '--window-size=1920,1080'
  ],
  headless: false
})

reCAPTCHA mit Puppeteer lösen

Sobald Stealth-Maßnahmen implementiert sind, ist die effiziente Handhabung von reCAPTCHA für eine zuverlässige Automatisierung unerlässlich. Dies baut auf den zuvor besprochenen Stealth- und Verhaltenssimulationstechniken auf.

Verwenden von CAPTCHA-Lösungsdiensten

Eine Möglichkeit, reCAPTCHA programmgesteuert zu verarbeiten, ist die Integration von CAPTCHA-Lösungsdiensten. Wenn Ihr Skript auf ein reCAPTCHA stößt, sendet es die erforderlichen Parameter an einen Solver-Dienst. Der Dienst verarbeitet das CAPTCHA und gibt die Lösung in der Regel innerhalb von 10–30 Sekunden zurück.

Einrichten 2Captcha API mit Puppeteer

2Captcha ist ein häufig verwendeter Dienst zum Lösen von reCAPTCHAs. So können Sie ihn in Ihr Puppeteer-Setup integrieren:

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

// Configure solver extension
const extensionPath = path.join(__dirname, './2captcha-solver')
const apiKey = 'YOUR_2CAPTCHA_API_KEY'

// Launch browser with the solver extension
const browser = await puppeteer.launch({
    args: [
        `--disable-extensions-except=${extensionPath}`,
        `--load-extension=${extensionPath}`
    ],
    headless: false
})

Sobald der Browser eingerichtet ist, können Sie den Status des CAPTCHA-Solvers überprüfen:

// Wait for solver button and check status
await page.waitForSelector('.captcha-solver')
const solverButton = await page.$('.captcha-solver')
const state = await solverButton.getAttribute('data-state')

// Proceed when solved
if (state === 'solved') {
    await page.click('#submit-form')
}

Tipps zur Verbesserung der ReCAPTCHA-Erfolgsraten

Um die Chancen zu verbessern, reCAPTCHAs effektiv zu lösen, befolgen Sie diese Vorgehensweisen:

• Verwenden Sie einen Pool von Residential-Proxys, um IP-Adressen zu rotieren.
• Fügen Sie zwischen den Lösungsversuchen kurze Verzögerungen ein, um das natürliche Benutzerverhalten zu simulieren.
• Schließen Sie die Fehlerbehandlung mit Wiederholungsversuchen mit exponentiellem Backoff ein.
• Behalten Sie den Browserkontext über alle Versuche hinweg bei, um unnötige Neuinitialisierungen zu vermeiden.

So können Sie die Fehlerbehandlung in Ihren CAPTCHA-Lösungsprozess integrieren:

const solveCaptcha = async (page, maxRetries = 3) => {
    let attempts = 0
    while (attempts < maxRetries) {
        try {
            // Attempt CAPTCHA solution
            await page.click('.captcha-solver')
            await page.waitForSelector('[data-state="solved"]')
            return true
        } catch (error) {
            attempts++
            await page.waitForTimeout(2000 * attempts)
        }
    }
    return false
}

Eine Fallstudie aus DataScrape-Lösungen unterstreicht die Wirksamkeit dieser Methoden. Im März 2024 erreichte der Einsatz von 2Captcha mit Puppeteer eine 95%ige Reduzierung der manuellen CAPTCHA-Lösungszeit und steigerte die Datenextraktionsraten um 60% bei der Verarbeitung von über 1 Million CAPTCHAs monatlich. ^[2].

sbb-itb-23997f1

Bild-CAPTCHA-Erkennungsmethoden

Bild-CAPTCHAs sind darauf ausgelegt, automatisierte Systeme herauszufordern. Mit den richtigen Tools können OCR- und Bildverarbeitungstechniken diese Rätsel jedoch effektiv lösen.

Arten von Bild-CAPTCHAs

• Textbasierte Bilder: Dazu gehören verzerrte Zeichen mit unterschiedlichen Schriftarten und komplexen Hintergründen.
• Objekterkennung: Dabei geht es darum, bestimmte Objekte aus einer Reihe von Optionen zu identifizieren.
• Musterabgleich: Erfordert, dass Benutzer visuelle Muster zuordnen oder identifizieren.

Lassen Sie uns nun in OCR-Methoden eintauchen, die speziell für textbasierte CAPTCHAs entwickelt wurden.

Verwenden von OCR für CAPTCHA-Text

Tesseract OCR ist ein leistungsstarkes Tool zur Texterkennung in Bildern. Nachfolgend finden Sie ein Beispiel für die Integration von Tesseract OCR mit Puppeteer zur Lösung textbasierter CAPTCHAs:

const tesseract = require('node-tesseract-ocr')
const sharp = require('sharp')

async function solveCaptcha(imageBuffer) {
    // Preprocess the image to improve OCR performance
    const processedImage = await sharp(imageBuffer)
        .grayscale()
        .threshold(150)
        .toBuffer()

    const config = {
        lang: "eng",
        oem: 1,
        psm: 7,
    }

    return await tesseract.recognize(processedImage, config)
}

Die Feinabstimmung der Bildeigenschaften während der Vorverarbeitung spielt eine entscheidende Rolle bei der Steigerung der Erkennungsgenauigkeit.

Verbesserung der Bilderkennungsgenauigkeit

Durch die Verbesserung von Kontrast und Helligkeit können die OCR-Ergebnisse deutlich verbessert werden. Hier ist ein Beispiel für die dynamische Anpassung dieser Einstellungen:

async function enhanceCaptchaRecognition(page) {
    return await page.evaluate(() => {
        const img = document.querySelector('.captcha-image')
        const canvas = document.createElement('canvas')
        const ctx = canvas.getContext('2d')

        ctx.filter = 'contrast(150%) brightness(120%)'
        ctx.drawImage(img, 0, 0)

        return canvas.toDataURL()
    })
}

Beispielsweise erreichte ein Projekt, das auf die taiwanesische Bahnbuchungswebsite abzielte, eine Genauigkeit von 98.84 % für einzelne Ziffern und eine Gesamtgenauigkeit von 91.13 %. ^[1]Ebenso haben sich Deep-Learning-Methoden für bildbasierte CAPTCHAs als effektiv erwiesen. Ein TensorFlow-basiertes Modell, das ein Convolutional Neural Network nutzt, erreichte eine Erfolgsquote von 90 %. ^[1]. Durch Experimentieren mit Vorverarbeitungstechniken – wie dem Optimieren von Kontrast, Helligkeit und Schwellenwerten – können die Ergebnisse basierend auf den spezifischen Merkmalen jedes CAPTCHA-Typs weiter verbessert werden.

CAPTCHA-Skriptleistung

Die Erstellung zuverlässiger CAPTCHA-Lösungsskripte erfordert eine effektive Fehlerbehandlung, IP-Rotation und Leistungsoptimierungen. Sobald Sie CAPTCHA-Lösungstechniken eingerichtet haben, liegt der nächste Schritt in der Skripteffizienz.

Fehlerbehebungssysteme

Eine gute Fehlerbehandlung ist der Schlüssel zur Stabilität Ihres Skripts. Hier ist ein Beispiel, das den Vorgang bei einem Fehler wiederholt:

async function handleCaptchaSolution(page) {
    const MAX_RETRIES = 3;
    let attempts = 0;

    while (attempts < MAX_RETRIES) {
        try {
            await page.setDefaultNavigationTimeout(30000);
            const result = await solveCaptcha(page);
            return result;
        } catch (error) {
            if (error instanceof TimeoutError) {
                console.error(`Attempt ${attempts + 1}: CAPTCHA timeout`);
            } else if (error instanceof NetworkError) {
                console.error(`Attempt ${attempts + 1}: Network failure`);
            }
            attempts++;
            await page.waitForTimeout(2000 * attempts);
        }
    }
    throw new Error('Maximum retry attempts exceeded');
}

Dieser Ansatz behandelt Timeouts und Netzwerkprobleme mit inkrementellen Wiederholungsversuchen und stellt sicher, dass Ihr Skript nicht unerwartet abstürzt.

IP- und Browserrotation

Rotierende IP-Adressen und Browser-Fingerabdrücke helfen, eine Erkennung zu vermeiden. So können Sie Puppeteer-Extra-Plugins zu diesem Zweck verwenden:

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

puppeteer.use(StealthPlugin());
puppeteer.use(AnonymizeUAPlugin());

async function rotateIdentity() {
    const proxy = await getNextProxy(); // Your proxy rotation logic
    const browser = await puppeteer.launch({
        args: [`--proxy-server=${proxy.host}:${proxy.port}`]
    });
    return browser;
}

Durch die Rotation von IPs und HTTP-Headern ahmt Ihr Skript das natürliche Browserverhalten nach und verringert so die Wahrscheinlichkeit, markiert zu werden.

Leistungsoptimierung

Steigern Sie die Effizienz und Erfolgsquote Ihres Skripts mit den folgenden Techniken:

• Ressourcenmanagement
  Stoppen Sie unnötige Ressourcendownloads wie Bilder, Stylesheets oder Schriftarten:

await page.setRequestInterception(true);
page.on('request', (request) => {
    if (['image', 'stylesheet', 'font'].includes(request.resourceType())) {
        request.abort();
    } else {
        request.continue();
    }
});

• Parallelverarbeitung
  Verwenden Sie Puppeteer-Cluster, um mehrere CAPTCHAs gleichzeitig zu lösen:

const { Cluster } = require('puppeteer-cluster');

const cluster = await Cluster.launch({
    concurrency: Cluster.CONCURRENCY_CONTEXT,
    maxConcurrency: 4,
    monitor: true
});

await cluster.task(async ({ page, data: url }) => {
    await handleCaptchaSolution(page);
});

• Caching-Strategie
  Cachen Sie Antworten, um redundante Anfragen zu vermeiden und Verarbeitungszeit zu sparen:

const cache = new Map();

async function getCachedResponse(url) {
    if (cache.has(url)) {
        const { timestamp, data } = cache.get(url);
        if (Date.now() - timestamp < 3600000) { // 1-hour cache
            return data;
        }
    }
    const response = await fetchResponse(url);
    cache.set(url, { timestamp: Date.now(), data: response });
    return response;
}

Diese Methoden arbeiten zusammen, um die Ressourcennutzung zu reduzieren, die Geschwindigkeit zu verbessern und mehrere Aufgaben effizient zu bewältigen.

Fazit und Implementierungsleitfaden

CAPTCHA-Lösungsübersicht

Der effektive Umgang mit CAPTCHAs erfordert eine mehrschichtige Strategie, die auf Prävention ausgerichtet ist. Durch den Einsatz von Stealth-Techniken, optimierten Headern und rotierenden IPs können Sie die Wahrscheinlichkeit verringern, dass CAPTCHAs überhaupt ausgelöst werden. Prävention ist immer besser als reaktives Lösen.

Latenknoten Browser-Automatisierung

Latenode vereinfacht die CAPTCHA-Verwaltung mit integrierten Funktionen wie Stealth-Modus, Proxy-Rotation und Cookie-Verarbeitung.

Hier ist ein Beispiel, wie Sie es einrichten können:

const workflow = new LatenodeWorkflow({ browserOptions: { stealth: true, proxyRotation: true, cookieManagement: true } });

await workflow.initBrowser({ captchaHandling: { prevention: true, autoRetry: true, maxAttempts: 3 } });

Nächste Schritte zur Umsetzung

Um Ihren Automatisierungs-Workflow zu verbessern, sollten Sie die folgenden Schritte in Betracht ziehen:

• Aktivieren Sie den Stealth-Modus
  Verwenden Sie Puppeteer-Extra-Stealth-Plugins, um die Wahrscheinlichkeit des Auslösens von CAPTCHAs zu verringern.
• Einrichten der Fehlerbehebung
  Fügen Sie Fehlerbehebungsmechanismen hinzu, um verschiedene CAPTCHA-Typen zu verarbeiten. Nutzen Sie automatische Wiederholungsversuche mit Strategien wie exponentiellem Backoff für einen reibungsloseren Betrieb.
• Verbessern Sie die Ressourceneffizienz
  Reduzieren Sie die Ausführungszeit von Skripts, indem Sie Ressourcen selektiv laden und Caching verwenden. So erzielen Sie eine bessere Leistung, ohne die Erfolgsraten zu beeinträchtigen.

Ähnliche Artikel

• Funktionsweise der Headless-Browser-Erkennung und Umgehung dieser
• Formularautomatisierung mit Puppeteer: Texteingabe, Formularausfüllen und Benutzersimulation
• Verwalten des Browser-Fingerabdrucks in Puppeteer, um eine Erkennung zu vermeiden
• Unsichtbare Automatisierung: Verwenden von Puppeteer-Extra-Plugin-Stealth zum Umgehen des Bot-Schutzes