CAPTCHAs in Puppeteer-Skripten überwinden: Von reCAPTCHA bis zu Erkennungsdiensten

CAPTCHAs sollen Bots blockieren und machen die Automatisierung mit Tools wie Puppeteer zu einer Herausforderung. Dieser Artikel erklärt, wie Sie CAPTCHA-Hürden umgehen können – von Stealth-Techniken bis hin zu Lösungsansätzen. Das erwartet Sie:

• Arten von CAPTCHAs: Textbasierte, bildbasierte, reCAPTCHA, hCAPTCHA und Audio-CAPTCHAs.
• Erkennung vermeiden: Nutzen Sie Puppeteer-extra-Stealth-Plugins, verwalten Sie Browser-Fingerprints 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 bildbasierte CAPTCHAs.
• Erfolgsquoten verbessern: Rotieren Sie IPs, behandeln Sie Fehler mit Wiederholungsversuchen und optimieren Sie die Ressourcennutzung.

Schneller Vergleich von CAPTCHA-Arten

Erfahren Sie, wie diese Methoden Ihnen helfen können, Ihre Automatisierung zu optimieren, während Sie Erkennung vermeiden und CAPTCHAs effizient lösen.

So umgehen Sie reCAPTCHA mit Puppeteer und Headless ...

Methoden zur Vermeidung der Bot-Erkennung

Um CAPTCHA-Hürden effektiv zu umgehen, müssen sich Puppeteer-Skripte wie echte menschliche Nutzer verhalten. Dazu gehören Stealth-Techniken und natürliche Verhaltensmuster.

Puppeteer-extra Stealth einrichten

Die Verwendung von puppeteer-extra mit dem Stealth-Plugin kann helfen, die Bot-Erkennung zu vermeiden. So richten Sie es ein:

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

Sie können auch gezielte Umgehungstechniken aktivieren:

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

Das Stealth-Plugin adressiert gängige Erkennungsmethoden durch:

• Entfernen der Eigenschaft navigator.webdriver
• Verbergen von Indikatoren für Headless Chrome
• Hinzufügen von Chrome-App- und CSI-Objekten
• Anpassen von Browser-Fingerprints

Verwaltung von Browser-Fingerprints

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

Neben statischen Konfigurationen ist es entscheidend, dynamische, menschenähnliche Verhaltensweisen einzubinden.

Simulation menschlichen Verhaltens

Die Simulation menschlichen Verhaltens trägt dazu bei, Erkennungsrisiken zu senken. Hier sind einige effektive Techniken:

• Tippmuster
  Fügen Sie zufällige Verzögerungen zwischen Tasteneingaben ein (z. B. 50 ms bis 200 ms), um natürliche Tippgeschwindigkeiten nachzuahmen und automatisierte Eingabemuster zu vermeiden.
• Mausbewegungen
  Verwenden Sie nicht lineare Mauspfade mit unterschiedlichen Geschwindigkeiten. Kleine, zufällige Abweichungen können menschliche Ungenauigkeiten bei der Cursorsteuerung nachbilden.
• Seiteninteraktion
  Simulieren Sie realistisches Scrollen mit variablen Geschwindigkeiten und Pausen. Zufällige Viewport-Anpassungen können Lese- oder Scanverhalten nachahmen.

Starten Sie den Browser abschließend 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 eingerichtet sind, wird der effiziente Umgang mit reCAPTCHA entscheidend für eine zuverlässige Automatisierung. Dies baut auf den zuvor beschriebenen Techniken zur Stealth- und Verhaltenssimulation auf.

CAPTCHA-Lösungsdienste verwenden

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

2Captcha-API mit Puppeteer einrichten

2Captcha ist ein häufig genutzter Dienst zum Lösen von reCAPTCHAs. So können Sie ihn in Ihre Puppeteer-Konfiguration 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-Lösers prü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-Erfolgsquoten

Um die Chancen auf ein effektives Lösen von reCAPTCHAs zu erhöhen, befolgen Sie diese Praktiken:

• Verwenden Sie einen Pool von Residential Proxies, um IP-Adressen zu rotieren.
• Fügen Sie kurze Verzögerungen zwischen Lösungsversuchen ein, um natürliches Nutzerverhalten zu simulieren.
• Integrieren Sie eine Fehlerbehandlung mit Wiederholungsversuchen und exponentiellem Backoff.
• Behalten Sie den Browserkontext über mehrere 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 von DataScrape Solutions hebt die Wirksamkeit dieser Methoden hervor. Im März 2024 führte der Einsatz von 2Captcha mit Puppeteer dort zu einer Reduzierung der manuellen CAPTCHA-Lösungszeit um 95 % und steigerte die Datenextraktionsrate bei der Verarbeitung von mehr als 1 Million CAPTCHAs pro Monat um 60 % [2].

sbb-itb-23997f1

Methoden zur Erkennung bildbasierter CAPTCHAs

Bildbasierte CAPTCHAs sollen automatisierte Systeme herausfordern. Mit den richtigen Tools können OCR- und Bildverarbeitungstechniken diese Aufgaben jedoch effektiv lösen.

Arten bildbasierter CAPTCHAs

• Textbasierte Bilder: Sie enthalten verzerrte Zeichen mit unterschiedlichen Schriftarten und komplexen Hintergründen.
• Objekterkennung: Dabei müssen bestimmte Objekte aus einer Auswahl identifiziert werden.
• Musterabgleich: Nutzer müssen visuelle Muster abgleichen oder identifizieren.

Sehen wir uns nun OCR-Methoden an, die speziell für textbasierte CAPTCHAs entwickelt wurden.

OCR für CAPTCHA-Text verwenden

Tesseract OCR ist ein leistungsstarkes Tool zur Texterkennung in Bildern. Nachfolgend sehen Sie ein Beispiel für die Integration von Tesseract OCR mit Puppeteer, um textbasierte CAPTCHAs zu lösen:

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 von Bildeigenschaften während der Vorverarbeitung spielt eine entscheidende Rolle bei der Verbesserung der Erkennungsgenauigkeit.

Genauigkeit der Bilderkennung verbessern

Eine Optimierung von Kontrast und Helligkeit kann die OCR-Ergebnisse erheblich verbessern. 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()
    })
}

So erreichte beispielsweise ein Projekt für die Buchungswebsite der taiwanischen Eisenbahn eine Genauigkeit von 98,84 % bei einzelnen Ziffern und eine Gesamtgenauigkeit von 91,13 % [1]. Ebenso haben sich Deep-Learning-Methoden für bildbasierte CAPTCHAs als wirksam erwiesen. Ein auf TensorFlow basierendes Modell, das ein Convolutional Neural Network nutzt, erzielte eine Erfolgsquote von 90 % [1]. Durch Experimente mit Vorverarbeitungstechniken – etwa durch Anpassung von Kontrast, Helligkeit und Schwellenwerten – lassen sich die Ergebnisse je nach spezifischen Merkmalen des jeweiligen CAPTCHA-Typs weiter verbessern.

Performance von CAPTCHA-Skripten

Zuverlässige CAPTCHA-Lösungsskripte erfordern eine robuste Fehlerbehandlung, IP-Rotation und Performance-Optimierungen. Nachdem Sie Techniken zum Lösen von CAPTCHAs eingerichtet haben, ist die Optimierung der Skripteffizienz der nächste Schritt.

Systeme zur Fehlerbehebung

Eine gute Fehlerbehandlung ist entscheidend, damit Ihr Skript stabil bleibt. Hier ist ein Beispiel, das bei Fehlern Wiederholungsversuche durchführt:

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 schrittweisen Wiederholungsversuchen und stellt sicher, dass Ihr Skript nicht unerwartet abstürzt.

IP- und Browser-Rotation

Die Rotation von IPs und Browser-Fingerprints hilft, Erkennung zu vermeiden. So können Sie puppeteer-extra-Plugins dafür 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 natürliches Surfverhalten nach und senkt die Wahrscheinlichkeit, markiert zu werden.

Performance-Optimierung

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

• Ressourcenverwaltung
  Unterbinden 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();
    }
});

• Parallele Verarbeitung
  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 senken, die Geschwindigkeit zu erhöhen und mehrere Aufgaben effizient zu verarbeiten.

Fazit und Implementierungsleitfaden

Überblick über CAPTCHA-Lösungen

Der effektive Umgang mit CAPTCHAs erfordert eine mehrschichtige, präventive Strategie. Mit Tools wie Stealth-Techniken, optimierten Headern und rotierenden IPs können Sie die Wahrscheinlichkeit senken, dass CAPTCHAs überhaupt ausgelöst werden. Prävention ist immer besser, als CAPTCHAs nachträglich lösen zu müssen.

Latenode Browser-Automatisierung

Latenode vereinfacht das CAPTCHA-Management durch integrierte Funktionen wie Stealth-Modus, Proxy-Rotation und Cookie-Verwaltung.

So können Sie es einrichten:

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

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

Nächste Schritte für die Implementierung

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

• Stealth-Modus aktivieren
  Verwenden Sie Puppeteer-extra-Stealth-Plugins, um die Wahrscheinlichkeit zu senken, CAPTCHAs auszulösen.
• Fehlerbehebung einrichten
  Ergänzen Sie Mechanismen zur Fehlerbehebung für verschiedene CAPTCHA-Arten. Verwenden Sie automatische Wiederholungsversuche mit Strategien wie exponentiellem Backoff für reibungslosere Abläufe.
• Ressourceneffizienz verbessern
  Reduzieren Sie die Skriptausführungszeit durch selektives Laden von Ressourcen und Caching. So verbessern Sie die Performance, ohne die Erfolgsquoten zu beeinträchtigen.