.png)
.svg){kind=icon}
Agentes de IA prontos para uso estão disponíveis no Latenode 🚀
Os CAPTCHAs são projetados para bloquear bots, facilitando a automação com ferramentas como Marionetista desafiador. Este artigo explica como contornar problemas de CAPTCHA, desde técnicas furtivas até métodos de resolução. Aqui está o que você aprenderá:
| Tipo CAPTCHA | Descrição | Desafios |
|---|---|---|
| Baseado em texto | Texto distorcido para reconhecimento | Texto complexo difícil de ler |
| Baseado em imagem | Identificar objetos/padrões | Requer processamento visual |
| reCAPTCHA | Sistema de análise de risco do Google | Detecta comportamento semelhante ao de um bot |
| hCAPTCHA | Tarefas de identificação de objetos | Semelhante ao reCAPTCHA |
| em áudio | Tarefas baseadas em som | Reconhecimento de fala complexo |
Aprenda como esses métodos podem ajudar você a otimizar a automação, evitando a detecção e resolvendo CAPTCHAs com eficiência.
Para contornar desafios de CAPTCHA de forma eficaz, os scripts do Puppeteer precisam se comportar de maneiras que imitem usuários humanos reais. Isso inclui usar técnicas de stealth e padrões de comportamento natural.
utilização puppeteer-extra com seu plugin stealth pode ajudar a evitar a detecção de bot. Veja como configurá-lo:
const puppeteer = require('puppeteer-extra')
const StealthPlugin = require('puppeteer-extra-plugin-stealth')
puppeteer.use(StealthPlugin())
Você também pode habilitar técnicas específicas de evasão:
puppeteer.use(StealthPlugin({
enabledEvasions: new Set([
"chrome.app",
"chrome.csi",
"defaultArgs",
"navigator.plugins"
])
}))
O plugin stealth aborda métodos comuns de detecção por:
navigator.webdriver propriedadeA impressão digital do navegador é um fator-chave na detecção de bots. Para criar um perfil de navegador convincente, concentre-se nessas áreas:
| Área de Configuração | Detalhes de Implementação | Propósito |
|---|---|---|
| User Agent | Girar strings dinamicamente | Oculta marcadores de automação |
| Suporte WebGL | Ativar aceleração de hardware | Imita uma configuração de navegador padrão |
| Configurações da janela de visualização | Use dimensões aleatórias e realistas | Corresponde a configurações comuns de usuários |
| Cabeçalhos de idioma | Alinhar com a localidade do agente do usuário | Garante consistência no perfil do navegador |
Além de configurações estáticas, é fundamental incorporar comportamentos dinâmicos e semelhantes aos humanos.
Simular o comportamento humano ajuda a reduzir os riscos de detecção. Aqui estão algumas técnicas eficazes:
Por fim, inicie o navegador com argumentos que reduzem a detecção de bots:
const browser = await puppeteer.launch({
args: [
'--disable-blink-features=AutomationControlled',
'--window-size=1920,1080'
],
headless: false
})
Uma vez que as medidas de stealth estejam em vigor, lidar com reCAPTCHA de forma eficiente se torna essencial para uma automação confiável. Isso se baseia nas técnicas de stealth e simulação de comportamento discutidas anteriormente.
Uma maneira de lidar com o reCAPTCHA programaticamente é integrando serviços de resolução de CAPTCHA. Quando seu script encontra um reCAPTCHA, ele envia os parâmetros necessários para um serviço de resolução. O serviço processa o CAPTCHA e retorna a solução, geralmente em 10–30 segundos.
2Captcha é um serviço comumente usado para resolver reCAPTCHAs. Veja como você pode integrá-lo à sua configuração do 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
})
Depois que o navegador estiver configurado, você pode verificar o status do solucionador 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')
}
Para aumentar as chances de resolver reCAPTCHAs de forma eficaz, siga estas práticas:
Veja como você pode integrar o tratamento de erros ao seu processo de resolução 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
}
Um estudo de caso de Soluções DataScrape destaca a eficácia desses métodos. Em março de 2024, o uso do 2Captcha com o Puppeteer resultou em uma redução de 95% no tempo de resolução manual de CAPTCHAs e aumentou as taxas de extração de dados em 60% ao processar mais de 1 milhão de CAPTCHAs mensalmente. .
Os CAPTCHAs de imagem são projetados para desafiar sistemas automatizados. No entanto, com as ferramentas certas, técnicas de OCR e processamento de imagem podem efetivamente resolver esses quebra-cabeças.
Agora, vamos nos aprofundar nos métodos de OCR projetados especificamente para CAPTCHAs baseados em texto.
Tesseract OCR é uma ferramenta poderosa para reconhecer texto em imagens. Abaixo está um exemplo de como integrar o Tesseract OCR com o Puppeteer para resolver CAPTCHAs baseados em texto:
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)
}
O ajuste fino das propriedades da imagem durante o pré-processamento desempenha um papel crucial no aumento da precisão do reconhecimento.
Melhorar o contraste e o brilho pode melhorar significativamente os resultados de OCR. Aqui está um exemplo de ajuste dessas configurações dinamicamente:
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()
})
}
Por exemplo, um projeto direcionado ao site de reservas ferroviárias de Taiwan atingiu uma taxa de precisão de 98.84% para dígitos únicos e uma precisão geral de 91.13%. Da mesma forma, métodos de aprendizado profundo têm se mostrado eficazes para CAPTCHAs baseados em imagens. Um modelo baseado no TensorFlow, utilizando uma rede neural convolucional, atingiu uma taxa de sucesso de 90%. . Experimentar técnicas de pré-processamento — como ajustar contraste, brilho e limites — pode melhorar ainda mais os resultados com base nas características específicas de cada tipo de CAPTCHA.
Criar scripts confiáveis de resolução de CAPTCHA requer um forte tratamento de erros, rotação de IP e ajustes de desempenho. Depois de configurar as técnicas de resolução de CAPTCHA, focar na eficiência do script é o próximo passo.
Um bom tratamento de erros é essencial para manter seu script estável. Aqui está um exemplo que tenta novamente em caso de falha:
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');
}
Essa abordagem lida com tempos limite e problemas de rede com tentativas incrementais, garantindo que seu script não falhe inesperadamente.
A rotação de IPs e impressões digitais do navegador ajuda a evitar a detecção. Veja como você pode usar os plugins puppeteer-extra para esse propósito:
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;
}
Ao rotacionar IPs e cabeçalhos HTTP, seu script imita o comportamento natural de navegação, reduzindo as chances de ser sinalizado.
Aumente a eficiência e a taxa de sucesso do seu script com as seguintes técnicas:
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;
}
Esses métodos trabalham juntos para reduzir o uso de recursos, melhorar a velocidade e lidar com múltiplas tarefas com eficiência.
Lidar com CAPTCHAs de forma eficaz envolve uma estratégia em camadas focada na prevenção. Ao usar ferramentas como técnicas furtivas, cabeçalhos otimizados e IPs rotativos, você pode reduzir as chances de CAPTCHAs serem acionados em primeiro lugar. A prevenção é sempre melhor do que resolvê-los de forma reativa.
O Latenode facilita o gerenciamento de CAPTCHA com recursos integrados como modo furtivo, rotação de proxy e tratamento de cookies.
Aqui está um exemplo de como você pode configurá-lo:
const workflow = new LatenodeWorkflow({ browserOptions: { stealth: true, proxyRotation: true, cookieManagement: true } });
await workflow.initBrowser({ captchaHandling: { prevention: true, autoRetry: true, maxAttempts: 3 } });
Para aprimorar seu fluxo de trabalho de automação, considere estas etapas:
Trocar aplicativos
Aplicativo 1
Aplicativo 2
- Escolha um gatilho
- Escolha uma ação
Sem necessidade de cartão de crédito
Sem restrição
