Contourner les CAPTCHA dans les scripts Puppeteer : de reCAPTCHA aux services de reconnaissance

Les CAPTCHA sont conçus pour bloquer les bots, ce qui rend l’automatisation avec des outils tels que Puppeteer difficile. Cet article explique comment contourner les problèmes liés aux CAPTCHA, des techniques de discrétion aux méthodes de résolution. Voici ce que vous allez découvrir :

• Types de CAPTCHA : CAPTCHA textuels, basés sur des images, reCAPTCHA, hCAPTCHA et CAPTCHA audio.
• Éviter la détection : utilisez les plugins de discrétion Puppeteer-extra, gérez les empreintes du navigateur et simulez le comportement humain (saisie, mouvements de souris, défilement).
• Résoudre les CAPTCHA : intégrez des services tels que 2Captcha ou utilisez des outils OCR comme Tesseract pour les CAPTCHA basés sur des images.
• Améliorer les taux de réussite : effectuez une rotation des IP, gérez les erreurs avec des tentatives répétées et optimisez l’utilisation des ressources.

Comparaison rapide des types de CAPTCHA

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

Comment contourner reCAPTCHA avec Puppeteer et Headless ...

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

Pour contourner efficacement les CAPTCHA, les scripts Puppeteer doivent se comporter comme de véritables utilisateurs humains. Cela implique d’utiliser des techniques de discrétion et des schémas de comportement naturels.

Configurer Puppeteer-extra Stealth

L’utilisation de puppeteer-extra avec son plugin de discrétion peut aider à éviter la détection des bots. 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 de discrétion traite les méthodes de détection courantes en :

• Supprimant la propriété navigator.webdriver
• Masquant les indicateurs de Chrome headless
• Ajoutant les objets Chrome App et CSI
• Ajustant les empreintes du navigateur

Gestion des empreintes du navigateur

L’empreinte du navigateur est un facteur clé de la détection des bots. Pour créer un profil de navigateur convaincant, concentrez-vous sur les éléments suivants :

En complément des configurations statiques, il est essentiel d’intégrer des comportements dynamiques et humains.

Simulation du comportement humain

La simulation du comportement humain contribue à réduire les risques de détection. Voici quelques techniques efficaces :

• Schémas de saisie
  Introduisez des délais aléatoires entre les frappes (par exemple, de 50 ms à 200 ms) afin d’imiter les vitesses de saisie naturelles et d’éviter les schémas de saisie automatisés.
• Mouvement de la souris
  Utilisez des trajectoires de souris non linéaires à des vitesses variées. De petits écarts aléatoires peuvent reproduire les imperfections humaines dans le contrôle du curseur.
• Interaction avec la page
  Simulez un défilement réaliste avec des vitesses et des pauses variables. Des ajustements aléatoires du viewport peuvent reproduire un comportement de lecture ou de balayage visuel.

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

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

Résoudre reCAPTCHA avec Puppeteer

Une fois les mesures de discrétion en place, gérer efficacement reCAPTCHA devient essentiel pour garantir une automatisation fiable. Cela s’appuie sur les techniques de discrétion et de simulation comportementale abordées précédemment.

Utiliser des services de résolution de CAPTCHA

L’une des façons de gérer 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 dernier traite le CAPTCHA et renvoie la solution, généralement sous 10 à 30 secondes.

Configurer l’API 2Captcha 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 résolveur de 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, appliquez les pratiques suivantes :

• Utilisez un pool de proxys résidentiels pour effectuer une rotation des adresses IP.
• Ajoutez de courts délais entre les tentatives de résolution afin de simuler un comportement utilisateur naturel.
• Intégrez une gestion des erreurs avec des tentatives répétées selon un backoff exponentiel.
• Conservez le contexte du navigateur entre les tentatives afin d’éviter les réinitialisations inutiles.

Voici comment intégrer la gestion des erreurs à 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 DataScrape Solutions met en évidence l’efficacité de ces méthodes. En mars 2024, leur utilisation de 2Captcha avec Puppeteer a permis de réduire de 95 % le temps consacré à la résolution manuelle des CAPTCHA et d’augmenter de 60 % les taux d’extraction de données lors du traitement de plus d’un million de CAPTCHA mensuels [2].

sbb-itb-23997f1

Méthodes de reconnaissance des CAPTCHA basés sur des images

Les CAPTCHA basés sur des images sont conçus pour mettre les systèmes automatisés à l’épreuve. Toutefois, avec les bons outils, les techniques d’OCR et de traitement d’image peuvent résoudre efficacement ces énigmes.

Types de CAPTCHA basés sur des images

• Images textuelles : elles contiennent des caractères déformés avec différentes polices et des arrière-plans complexes.
• Reconnaissance d’objets : consiste à identifier des objets spécifiques parmi un ensemble d’options.
• Correspondance de motifs : demande aux utilisateurs d’associer ou d’identifier des motifs visuels.

Voyons maintenant les méthodes OCR spécifiquement conçues pour les CAPTCHA textuels.

Utiliser l’OCR pour le texte des CAPTCHA

Tesseract OCR est un outil puissant pour reconnaître du texte dans des images. Voici un exemple d’intégration de Tesseract OCR avec Puppeteer pour résoudre les 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)
}

L’ajustement 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 reconnaissance.

Améliorer la précision de reconnaissance d’image

L’amélioration du contraste et de la luminosité peut considérablement optimiser les résultats 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 de réservation ferroviaire de Taïwan a atteint un taux de précision de 98,84 % pour les chiffres isolés et une précision globale de 91,13 % [1]. De même, les méthodes de deep learning se sont révélé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 % [1]. L’expérimentation de techniques de prétraitement, telles que l’ajustement du contraste, de la luminosité et des seuils, peut encore améliorer les résultats selon les caractéristiques propres à chaque type de CAPTCHA.

Performances des scripts CAPTCHA

La création de scripts fiables de résolution de CAPTCHA exige une gestion robuste des erreurs, une rotation des IP et des optimisations de performances. Une fois vos techniques de résolution de CAPTCHA configurées, l’étape suivante consiste à vous concentrer sur l’efficacité des scripts.

Systèmes de récupération après erreur

Une bonne gestion des erreurs est essentielle pour préserver la stabilité de votre script. Voici un exemple qui réessaie 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’expiration et les problèmes réseau avec des tentatives répétées progressives, afin d’éviter que votre script ne plante de manière inattendue.

Rotation des IP et du navigateur

La rotation des IP et des empreintes du navigateur aide à é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 effectuant une rotation des IP et des en-têtes HTTP, votre script reproduit un comportement de navigation naturel, ce qui réduit le risque 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 le téléchargement des 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 simultanément :

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 les réponses en cache afin d’éviter les requêtes redondantes et de 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 d’implémentation

Vue d’ensemble des solutions CAPTCHA

La gestion efficace des CAPTCHA repose sur une stratégie à plusieurs niveaux axée sur la prévention. En utilisant des outils tels que les techniques de discrétion, des en-têtes optimisés et la rotation des IP, vous pouvez réduire les probabilités de déclenchement des CAPTCHA dès le départ. La prévention est toujours préférable à une résolution réactive.

Automatisation de navigateur Latenode

Latenode simplifie la gestion des CAPTCHA grâce à des fonctionnalités intégrées comme le mode discret, la rotation des proxys et la gestion des cookies.

Voici un exemple de configuration :

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

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

Prochaines étapes de l’implémentation

Pour améliorer votre workflow d’automatisation, envisagez les étapes suivantes :

• Activer le mode discret
  Utilisez les plugins de discrétion Puppeteer-extra afin de réduire les risques de déclencher des CAPTCHA.
• Configurer la récupération après erreur
  Ajoutez des mécanismes de récupération après erreur pour gérer différents types de CAPTCHA. Utilisez des tentatives automatiques avec des stratégies telles que 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, afin d’améliorer les performances sans compromettre les taux de réussite.