Surmonter les 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

Type de CAPTCHA	Description	Défis
À base de texte	Texte déformé pour la reconnaissance	Texte complexe difficile à lire
Basé sur l'image	Identifier les objets/modèles	Nécessite un traitement visuel
reCAPTCHA	Le système d'analyse des risques de Google	Détecte les comportements de type robot
hCAPTCHA	Tâches d'identification d'objets	Similaire à reCAPTCHA
Audio	Tâches basées sur le son	Reconnaissance vocale complexe

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

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

<span class="hljs-keyword">const</span> puppeteer = <span class="hljs-built_in">require</span>(<span class="hljs-string">'puppeteer-extra'</span>)
<span class="hljs-keyword">const</span> <span class="hljs-title class_">StealthPlugin</span> = <span class="hljs-built_in">require</span>(<span class="hljs-string">'puppeteer-extra-plugin-stealth'</span>)
puppeteer.<span class="hljs-title function_">use</span>(<span class="hljs-title class_">StealthPlugin</span>())

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

puppeteer.<span class="hljs-title function_">use</span>(<span class="hljs-title class_">StealthPlugin</span>({
  <span class="hljs-attr">enabledEvasions</span>: <span class="hljs-keyword">new</span> <span class="hljs-title class_">Set</span>([
    <span class="hljs-string">"chrome.app"</span>,
    <span class="hljs-string">"chrome.csi"</span>,
    <span class="hljs-string">"defaultArgs"</span>,
    <span class="hljs-string">"navigator.plugins"</span>
  ])
}))

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 :

Zone de configuration	Détails d'implémentation	Interet
Agent utilisateur	Faire pivoter les chaînes de manière dynamique	Masque les marqueurs d'automatisation
Prise en charge de WebGL	Activer l'accélération matérielle	Imite une configuration de navigateur standard
Paramètres de la fenêtre d'affichage	Utilisez des dimensions aléatoires et réalistes	Correspond aux configurations utilisateur courantes
En-têtes de langue	Aligner avec les paramètres régionaux de l'agent utilisateur	Assure la cohérence du profil du navigateur

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 :

<span class="hljs-keyword">const</span> browser = <span class="hljs-keyword">await</span> puppeteer.<span class="hljs-title function_">launch</span>({
  <span class="hljs-attr">args</span>: [
    <span class="hljs-string">'--disable-blink-features=AutomationControlled'</span>,
    <span class="hljs-string">'--window-size=1920,1080'</span>
  ],
  <span class="hljs-attr">headless</span>: <span class="hljs-literal">false</span>
})

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.

Pour commencer 2Captcha API avec Puppeteer

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

<span class="hljs-keyword">const</span> puppeteer = <span class="hljs-built_in">require</span>(<span class="hljs-string">'puppeteer-extra'</span>)
<span class="hljs-keyword">const</span> <span class="hljs-title class_">StealthPlugin</span> = <span class="hljs-built_in">require</span>(<span class="hljs-string">'puppeteer-extra-plugin-stealth'</span>)
<span class="hljs-keyword">const</span> path = <span class="hljs-built_in">require</span>(<span class="hljs-string">'path'</span>)

<span class="hljs-comment">// Configure solver extension</span>
<span class="hljs-keyword">const</span> extensionPath = path.<span class="hljs-title function_">join</span>(__dirname, <span class="hljs-string">'./2captcha-solver'</span>)
<span class="hljs-keyword">const</span> apiKey = <span class="hljs-string">'YOUR_2CAPTCHA_API_KEY'</span>

<span class="hljs-comment">// Launch browser with the solver extension</span>
<span class="hljs-keyword">const</span> browser = <span class="hljs-keyword">await</span> puppeteer.<span class="hljs-title function_">launch</span>({
    <span class="hljs-attr">args</span>: [
        <span class="hljs-string">`--disable-extensions-except=<span class="hljs-subst">${extensionPath}</span>`</span>,
        <span class="hljs-string">`--load-extension=<span class="hljs-subst">${extensionPath}</span>`</span>
    ],
    <span class="hljs-attr">headless</span>: <span class="hljs-literal">false</span>
})

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

<span class="hljs-comment">// Wait for solver button and check status</span>
<span class="hljs-keyword">await</span> page.<span class="hljs-title function_">waitForSelector</span>(<span class="hljs-string">'.captcha-solver'</span>)
<span class="hljs-keyword">const</span> solverButton = <span class="hljs-keyword">await</span> page.$(<span class="hljs-string">'.captcha-solver'</span>)
<span class="hljs-keyword">const</span> state = <span class="hljs-keyword">await</span> solverButton.<span class="hljs-title function_">getAttribute</span>(<span class="hljs-string">'data-state'</span>)

<span class="hljs-comment">// Proceed when solved</span>
<span class="hljs-keyword">if</span> (state === <span class="hljs-string">'solved'</span>) {
    <span class="hljs-keyword">await</span> page.<span class="hljs-title function_">click</span>(<span class="hljs-string">'#submit-form'</span>)
}

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 :

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

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. [2].

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 :

<span class="hljs-keyword">const</span> tesseract = <span class="hljs-built_in">require</span>(<span class="hljs-string">'node-tesseract-ocr'</span>)
<span class="hljs-keyword">const</span> sharp = <span class="hljs-built_in">require</span>(<span class="hljs-string">'sharp'</span>)

<span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">solveCaptcha</span>(<span class="hljs-params">imageBuffer</span>) {
    <span class="hljs-comment">// Preprocess the image to improve OCR performance</span>
    <span class="hljs-keyword">const</span> processedImage = <span class="hljs-keyword">await</span> <span class="hljs-title function_">sharp</span>(imageBuffer)
        .<span class="hljs-title function_">grayscale</span>()
        .<span class="hljs-title function_">threshold</span>(<span class="hljs-number">150</span>)
        .<span class="hljs-title function_">toBuffer</span>()

    <span class="hljs-keyword">const</span> config = {
        <span class="hljs-attr">lang</span>: <span class="hljs-string">"eng"</span>,
        <span class="hljs-attr">oem</span>: <span class="hljs-number">1</span>,
        <span class="hljs-attr">psm</span>: <span class="hljs-number">7</span>,
    }

    <span class="hljs-keyword">return</span> <span class="hljs-keyword">await</span> tesseract.<span class="hljs-title function_">recognize</span>(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 :

<span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">enhanceCaptchaRecognition</span>(<span class="hljs-params">page</span>) {
    <span class="hljs-keyword">return</span> <span class="hljs-keyword">await</span> page.<span class="hljs-title function_">evaluate</span>(<span class="hljs-function">() =></span> {
        <span class="hljs-keyword">const</span> img = <span class="hljs-variable language_">document</span>.<span class="hljs-title function_">querySelector</span>(<span class="hljs-string">'.captcha-image'</span>)
        <span class="hljs-keyword">const</span> canvas = <span class="hljs-variable language_">document</span>.<span class="hljs-title function_">createElement</span>(<span class="hljs-string">'canvas'</span>)
        <span class="hljs-keyword">const</span> ctx = canvas.<span class="hljs-title function_">getContext</span>(<span class="hljs-string">'2d'</span>)

        ctx.<span class="hljs-property">filter</span> = <span class="hljs-string">'contrast(150%) brightness(120%)'</span>
        ctx.<span class="hljs-title function_">drawImage</span>(img, <span class="hljs-number">0</span>, <span class="hljs-number">0</span>)

        <span class="hljs-keyword">return</span> canvas.<span class="hljs-title function_">toDataURL</span>()
    })
}

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 %. [1]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 %. [1]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 :

<span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">handleCaptchaSolution</span>(<span class="hljs-params">page</span>) {
    <span class="hljs-keyword">const</span> <span class="hljs-variable constant_">MAX_RETRIES</span> = <span class="hljs-number">3</span>;
    <span class="hljs-keyword">let</span> attempts = <span class="hljs-number">0</span>;

    <span class="hljs-keyword">while</span> (attempts < <span class="hljs-variable constant_">MAX_RETRIES</span>) {
        <span class="hljs-keyword">try</span> {
            <span class="hljs-keyword">await</span> page.<span class="hljs-title function_">setDefaultNavigationTimeout</span>(<span class="hljs-number">30000</span>);
            <span class="hljs-keyword">const</span> result = <span class="hljs-keyword">await</span> <span class="hljs-title function_">solveCaptcha</span>(page);
            <span class="hljs-keyword">return</span> result;
        } <span class="hljs-keyword">catch</span> (error) {
            <span class="hljs-keyword">if</span> (error <span class="hljs-keyword">instanceof</span> <span class="hljs-title class_">TimeoutError</span>) {
                <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">`Attempt <span class="hljs-subst">${attempts + <span class="hljs-number">1</span>}</span>: CAPTCHA timeout`</span>);
            } <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (error <span class="hljs-keyword">instanceof</span> <span class="hljs-title class_">NetworkError</span>) {
                <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">`Attempt <span class="hljs-subst">${attempts + <span class="hljs-number">1</span>}</span>: Network failure`</span>);
            }
            attempts++;
            <span class="hljs-keyword">await</span> page.<span class="hljs-title function_">waitForTimeout</span>(<span class="hljs-number">2000</span> * attempts);
        }
    }
    <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">'Maximum retry attempts exceeded'</span>);
}

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 :

<span class="hljs-keyword">const</span> puppeteer = <span class="hljs-built_in">require</span>(<span class="hljs-string">'puppeteer-extra'</span>);
<span class="hljs-keyword">const</span> <span class="hljs-title class_">StealthPlugin</span> = <span class="hljs-built_in">require</span>(<span class="hljs-string">'puppeteer-extra-plugin-stealth'</span>);
<span class="hljs-keyword">const</span> <span class="hljs-title class_">AnonymizeUAPlugin</span> = <span class="hljs-built_in">require</span>(<span class="hljs-string">'puppeteer-extra-plugin-anonymize-ua'</span>);

puppeteer.<span class="hljs-title function_">use</span>(<span class="hljs-title class_">StealthPlugin</span>());
puppeteer.<span class="hljs-title function_">use</span>(<span class="hljs-title class_">AnonymizeUAPlugin</span>());

<span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">rotateIdentity</span>(<span class="hljs-params"></span>) {
    <span class="hljs-keyword">const</span> proxy = <span class="hljs-keyword">await</span> <span class="hljs-title function_">getNextProxy</span>(); <span class="hljs-comment">// Your proxy rotation logic</span>
    <span class="hljs-keyword">const</span> browser = <span class="hljs-keyword">await</span> puppeteer.<span class="hljs-title function_">launch</span>({
        <span class="hljs-attr">args</span>: [<span class="hljs-string">`--proxy-server=<span class="hljs-subst">${proxy.host}</span>:<span class="hljs-subst">${proxy.port}</span>`</span>]
    });
    <span class="hljs-keyword">return</span> 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 :

<span class="hljs-keyword">await</span> page.<span class="hljs-title function_">setRequestInterception</span>(<span class="hljs-literal">true</span>);
page.<span class="hljs-title function_">on</span>(<span class="hljs-string">'request'</span>, <span class="hljs-function">(<span class="hljs-params">request</span>) =></span> {
    <span class="hljs-keyword">if</span> ([<span class="hljs-string">'image'</span>, <span class="hljs-string">'stylesheet'</span>, <span class="hljs-string">'font'</span>].<span class="hljs-title function_">includes</span>(request.<span class="hljs-title function_">resourceType</span>())) {
        request.<span class="hljs-title function_">abort</span>();
    } <span class="hljs-keyword">else</span> {
        request.<span class="hljs-title function_">continue</span>();
    }
});

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

<span class="hljs-keyword">const</span> { <span class="hljs-title class_">Cluster</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'puppeteer-cluster'</span>);

<span class="hljs-keyword">const</span> cluster = <span class="hljs-keyword">await</span> <span class="hljs-title class_">Cluster</span>.<span class="hljs-title function_">launch</span>({
    <span class="hljs-attr">concurrency</span>: <span class="hljs-title class_">Cluster</span>.<span class="hljs-property">CONCURRENCY_CONTEXT</span>,
    <span class="hljs-attr">maxConcurrency</span>: <span class="hljs-number">4</span>,
    <span class="hljs-attr">monitor</span>: <span class="hljs-literal">true</span>
});

<span class="hljs-keyword">await</span> cluster.<span class="hljs-title function_">task</span>(<span class="hljs-title function_">async</span> ({ page, <span class="hljs-attr">data</span>: url }) => {
    <span class="hljs-keyword">await</span> <span class="hljs-title function_">handleCaptchaSolution</span>(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 :

<span class="hljs-keyword">const</span> cache = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Map</span>();

<span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">getCachedResponse</span>(<span class="hljs-params">url</span>) {
    <span class="hljs-keyword">if</span> (cache.<span class="hljs-title function_">has</span>(url)) {
        <span class="hljs-keyword">const</span> { timestamp, data } = cache.<span class="hljs-title function_">get</span>(url);
        <span class="hljs-keyword">if</span> (<span class="hljs-title class_">Date</span>.<span class="hljs-title function_">now</span>() - timestamp < <span class="hljs-number">3600000</span>) { <span class="hljs-comment">// 1-hour cache</span>
            <span class="hljs-keyword">return</span> data;
        }
    }
    <span class="hljs-keyword">const</span> response = <span class="hljs-keyword">await</span> <span class="hljs-title function_">fetchResponse</span>(url);
    cache.<span class="hljs-title function_">set</span>(url, { <span class="hljs-attr">timestamp</span>: <span class="hljs-title class_">Date</span>.<span class="hljs-title function_">now</span>(), <span class="hljs-attr">data</span>: response });
    <span class="hljs-keyword">return</span> 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 :

<span class="hljs-keyword">const</span> workflow = <span class="hljs-keyword">new</span> <span class="hljs-title class_">LatenodeWorkflow</span>({ <span class="hljs-attr">browserOptions</span>: { <span class="hljs-attr">stealth</span>: <span class="hljs-literal">true</span>, <span class="hljs-attr">proxyRotation</span>: <span class="hljs-literal">true</span>, <span class="hljs-attr">cookieManagement</span>: <span class="hljs-literal">true</span> } });

<span class="hljs-keyword">await</span> workflow.<span class="hljs-title function_">initBrowser</span>({ <span class="hljs-attr">captchaHandling</span>: { <span class="hljs-attr">prevention</span>: <span class="hljs-literal">true</span>, <span class="hljs-attr">autoRetry</span>: <span class="hljs-literal">true</span>, <span class="hljs-attr">maxAttempts</span>: <span class="hljs-number">3</span> } });

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.

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