Surmonter le CAPTCHA dans les scripts Puppeteer : de reCAPTCHA aux services de reconnaissance

Les CAPTCHA sont conçus pour bloquer les robots, ce qui permet l'automatisation avec des outils comme Marionnettiste Défi. Cet article explique comment contourner les problèmes de CAPTCHA, des techniques de furtivité aux méthodes de résolution. Voici ce que vous apprendrez :

• Types de CAPTCHA: Basé sur du texte, basé sur des images, reCAPTCHA, hCAPTCHA, et les CAPTCHA audio.
• Éviter la détection:Utilisez les plugins furtifs Puppeteer-extra, gérez les empreintes digitales du navigateur et simulez le comportement humain (saisie, mouvement de la souris, défilement).
• Résoudre les CAPTCHA: Intégrer des services comme 2Captcha ou utilisez des outils OCR comme Tesseract pour les CAPTCHA d'image.
• Améliorer les taux de réussite: Faites pivoter les adresses IP, gérez les erreurs avec de nouvelles tentatives et optimisez l'utilisation des ressources.

Comparaison rapide des types de CAPTCHA

Découvrez comment ces méthodes peuvent vous aider à rationaliser l’automatisation tout en évitant la détection et en résolvant efficacement les CAPTCHA.

Comment contourner reCAPTCHA avec Marionnettiste et sans tête...

Méthodes de prévention de la détection des robots

Pour contourner efficacement les défis CAPTCHA, les scripts Puppeteer doivent se comporter de manière à imiter les utilisateurs réels. Cela implique l'utilisation de techniques furtives et de comportements naturels.

Configuration de Puppeteer-extra Stealth

En utilisant puppeteer-extra Grâce à son plugin furtif, il peut éviter la détection des robots. Voici comment le configurer :

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

Vous pouvez également activer des techniques d’évasion spécifiques :

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

Le plugin furtif s'attaque aux méthodes de détection courantes en :

• Enlever le navigator.webdriver propriété
• Masquer les indicateurs de Chrome sans tête
• Ajout d'objets Chrome App et CSI
• Ajuster les empreintes digitales du navigateur

Gestion des empreintes digitales du navigateur

L'empreinte digitale du navigateur est un facteur clé dans la détection des robots. Pour créer un profil de navigateur convaincant, concentrez-vous sur les points suivants :

En plus des configurations statiques, l’intégration de comportements dynamiques, de type humain, est essentielle.

Simulation du comportement humain

Simuler le comportement humain permet de réduire les risques de détection. Voici quelques techniques efficaces :

• Modèles de frappe
  Introduisez des délais aléatoires entre les frappes (par exemple, 50 ms à 200 ms) pour imiter les vitesses de frappe naturelles et éviter les modèles de saisie automatisés.
• Mouvement de la souris
  Utilisez des trajectoires de souris non linéaires à des vitesses variables. De légers écarts aléatoires peuvent reproduire les imperfections humaines dans le contrôle du curseur.
• Interaction des pages
  Simulez un défilement réaliste avec des vitesses et des pauses variables. Des ajustements aléatoires de la fenêtre d'affichage peuvent simuler un comportement de lecture ou de balayage.

Enfin, lancez le navigateur avec des arguments qui réduisent la détection des robots :

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

Résoudre le reCAPTCHA avec Puppeteer

Une fois les mesures de furtivité mises en place, la gestion efficace de reCAPTCHA devient essentielle pour une automatisation fiable. Cela s'appuie sur les techniques de furtivité et de simulation comportementale évoquées précédemment.

Utilisation des services de résolution de CAPTCHA

Une façon de gérer les reCAPTCHA par programmation consiste à intégrer des services de résolution de CAPTCHA. Lorsque votre script rencontre un reCAPTCHA, il envoie les paramètres requis à un service de résolution. Ce service traite le CAPTCHA et renvoie la solution, généralement en 10 à 30 secondes.

Configuration 2Captcha API avec Puppeteer

2Captcha est un service couramment utilisé pour résoudre les reCAPTCHA. Voici comment l'intégrer à votre configuration Puppeteer :

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
})

Une fois le navigateur configuré, vous pouvez vérifier l'état du solveur CAPTCHA :

// 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')
}

Conseils pour améliorer les taux de réussite de ReCAPTCHA

Pour améliorer vos chances de résoudre efficacement les reCAPTCHA, suivez ces pratiques :

• Utilisez un pool de proxys résidentiels pour faire tourner les adresses IP.
• Ajoutez de courts délais entre les tentatives de résolution pour simuler le comportement naturel de l'utilisateur.
• Inclure la gestion des erreurs avec des tentatives de recul exponentiel.
• Maintenir le contexte du navigateur entre les tentatives pour éviter les réinitialisations inutiles.

Voici comment vous pouvez intégrer la gestion des erreurs dans votre processus de résolution de CAPTCHA :

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
}

Une étude de cas de Solutions de récupération de données souligne l'efficacité de ces méthodes. En mars 2024, l'utilisation de 2Captcha avec Puppeteer a permis de réduire de 95 % le temps de résolution manuelle des CAPTCHA et d'augmenter de 60 % le taux d'extraction des données lors du traitement de plus d'un million de CAPTCHA par mois. .

sbb-itb-23997f1

Méthodes de reconnaissance d'image CAPTCHA

Les CAPTCHA d'images sont conçus pour défier les systèmes automatisés. Cependant, avec les bons outils, l'OCR et les techniques de traitement d'images peuvent résoudre efficacement ces énigmes.

Types de CAPTCHA d'image

• Images textuelles:Il s'agit notamment de caractères déformés avec des polices variables et des arrière-plans complexes.
• Reconnaissance d'objets:Implique l’identification d’objets spécifiques à partir d’un ensemble d’options.
• Correspondance de motif:Nécessite que les utilisateurs fassent correspondre ou identifient des modèles visuels.

Maintenant, plongeons dans les méthodes OCR spécialement conçues pour les CAPTCHA basés sur du texte.

Utilisation de l'OCR pour le texte CAPTCHA

Tesseract OCR est un outil puissant pour la reconnaissance de texte dans les images. Voici un exemple d'intégration de Tesseract OCR avec Puppeteer pour résoudre des CAPTCHA textuels :

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)
}

Le réglage précis des propriétés de l’image pendant le prétraitement joue un rôle crucial dans l’amélioration de la précision de la reconnaissance.

Améliorer la précision de la reconnaissance d'images

Améliorer le contraste et la luminosité peut considérablement améliorer les résultats de l'OCR. Voici un exemple d'ajustement dynamique de ces paramètres :

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()
    })
}

Par exemple, un projet ciblant le site Web de réservation des chemins de fer de Taïwan a atteint un taux de précision de 98.84 % pour les chiffres uniques et une précision globale de 91.13 %. De même, les méthodes d'apprentissage profond se sont avérées efficaces pour les CAPTCHA basés sur des images. Un modèle basé sur TensorFlow, exploitant un réseau neuronal convolutif, a atteint un taux de réussite de 90 %. L'expérimentation de techniques de prétraitement, comme le réglage du contraste, de la luminosité et des seuils, peut encore améliorer les résultats en fonction des caractéristiques spécifiques de chaque type de CAPTCHA.

Performances du script CAPTCHA

Créer des scripts de résolution de CAPTCHA fiables nécessite une gestion rigoureuse des erreurs, une rotation des adresses IP et des ajustements de performances. Une fois les techniques de résolution de CAPTCHA mises en place, l'étape suivante consiste à se concentrer sur l'efficacité des scripts.

Systèmes de récupération d'erreurs

Une bonne gestion des erreurs est essentielle à la stabilité de votre script. Voici un exemple de nouvelle tentative en cas d'échec :

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');
}

Cette approche gère les délais d'attente et les problèmes de réseau avec des tentatives incrémentielles, garantissant que votre script ne plante pas de manière inattendue.

Rotation IP et navigateur

La rotation des adresses IP et des empreintes digitales du navigateur permet d'éviter la détection. Voici comment utiliser les plugins puppeteer-extra à cette fin :

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;
}

En faisant tourner les adresses IP et les en-têtes HTTP, votre script imite le comportement de navigation naturel, réduisant ainsi les risques d'être signalé.

Optimisation des performances

Améliorez l'efficacité et le taux de réussite de votre script grâce aux techniques suivantes :

• Gestion des ressources
  Arrêtez les téléchargements de ressources inutiles comme les images, les feuilles de style ou les polices :

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

• Traitement parallèle
  Utilisez puppeteer-cluster pour résoudre plusieurs CAPTCHA en même temps :

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);
});

• Stratégie de mise en cache
  Mettez en cache les réponses pour éviter les requêtes redondantes et gagner du temps de traitement :

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;
}

Ces méthodes fonctionnent ensemble pour réduire l’utilisation des ressources, améliorer la vitesse et gérer efficacement plusieurs tâches.

Conclusion et guide de mise en œuvre

Présentation de la solution CAPTCHA

La gestion efficace des CAPTCHA nécessite une stratégie multicouche axée sur la prévention. En utilisant des outils tels que les techniques furtives, les en-têtes optimisés et la rotation des adresses IP, vous pouvez réduire les risques de déclenchement des CAPTCHA. Mieux vaut prévenir que guérir.

Laténode Automatisation du navigateur

Latenode facilite la gestion des CAPTCHA grâce à des fonctionnalités intégrées telles que le mode furtif, la rotation du proxy et la gestion des cookies.

Voici un exemple de la façon dont vous pouvez le configurer :

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

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

Prochaines étapes de mise en œuvre

Pour améliorer votre flux de travail d’automatisation, tenez compte des étapes suivantes :

• Activer le mode furtif
  Utilisez les plugins furtifs Puppeteer-extra pour réduire les risques de déclenchement de CAPTCHA.
• Configurer la récupération d'erreur
  Ajoutez des mécanismes de récupération d'erreur pour gérer différents types de CAPTCHA. Utilisez des tentatives automatiques avec des stratégies comme le backoff exponentiel pour un fonctionnement plus fluide.
• Améliorer l'efficacité des ressources
  Réduisez le temps d'exécution des scripts en chargeant sélectivement les ressources et en utilisant la mise en cache, garantissant ainsi de meilleures performances sans sacrifier les taux de réussite.

articles similaires

• Comment fonctionne la détection de navigateur sans tête et comment la contourner
• Automatisation des formulaires avec Puppeteer : saisie de texte, remplissage de formulaires et simulation utilisateur
• Gestion de l'empreinte digitale du navigateur dans Puppeteer pour éviter la détection
• Automatisation invisible : utiliser puppeteer-extra-plugin-stealth pour contourner la protection contre les robots