.png)
.svg){kind=icon}
Agents IA prêts à l'emploi sont disponibles sur Latenode 🚀
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 :
| 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.
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.
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 :
navigator.webdriver propriété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 | Objectif |
|---|---|---|
| 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.
Simuler le comportement humain permet de réduire les risques de détection. Voici quelques techniques efficaces :
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
})
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.
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.
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')
}
Pour améliorer vos chances de résoudre efficacement les reCAPTCHA, suivez ces pratiques :
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. .
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.
Maintenant, plongeons dans les méthodes OCR spécialement conçues pour les CAPTCHA basés sur du texte.
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 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.
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.
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.
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é.
Améliorez l'efficacité et le taux de réussite de votre script grâce aux techniques suivantes :
await page.setRequestInterception(true);
page.on('request', (request) => {
if (['image', 'stylesheet', 'font'].includes(request.resourceType())) {
request.abort();
} else {
request.continue();
}
});
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);
});
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.
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.
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 } });
Pour améliorer votre flux de travail d’automatisation, tenez compte des étapes suivantes :
Échanger des applications
Application 1
Application 2
Étape 1 : Choisir un déclencheur
Étape 2 : Choisissez une action
Aucune carte de crédit n'est nécessaire
Sans restriction
