Como superar CAPTCHAs em scripts Puppeteer: de reCAPTCHA a serviços de reconhecimento

CAPTCHAs são projetados para bloquear bots, o que torna a automação com ferramentas como Puppeteer desafiadora. Este artigo explica como contornar problemas com CAPTCHA, desde técnicas de stealth até métodos de resolução. Veja o que você vai aprender:

• Tipos de CAPTCHA: CAPTCHAs baseados em texto, imagens, reCAPTCHA, hCAPTCHA e áudio.
• Como evitar a detecção: Use plugins de stealth do Puppeteer-extra, gerencie impressões digitais do navegador e simule comportamentos humanos (digitação, movimento do mouse e rolagem).
• Como resolver CAPTCHAs: Integre serviços como 2Captcha ou use ferramentas de OCR como Tesseract para CAPTCHAs de imagem.
• Como aumentar as taxas de sucesso: Faça rotação de IPs, trate erros com novas tentativas e otimize o uso de recursos.

Comparação rápida dos tipos de CAPTCHA

Saiba como esses métodos podem ajudar você a simplificar a automação, evitando a detecção e resolvendo CAPTCHAs com eficiência.

Como contornar reCAPTCHA com Puppeteer e Headless ...

Métodos para evitar a detecção de bots

Para contornar desafios de CAPTCHA de forma eficaz, os scripts do Puppeteer precisam se comportar como usuários humanos reais. Isso inclui usar técnicas de stealth e padrões de comportamento naturais.

Configurando o Puppeteer-extra Stealth

Usar puppeteer-extra com seu plugin de stealth pode ajudar a evitar a detecção de bots. Veja como configurá-lo:

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

Você também pode ativar técnicas específicas de evasão:

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

O plugin de stealth aborda métodos comuns de detecção ao:

• Remover a propriedade navigator.webdriver
• Ocultar indicadores do Chrome headless
• Adicionar objetos do Chrome App e CSI
• Ajustar impressões digitais do navegador

Gerenciamento da impressão digital do navegador

A impressão digital do navegador é um fator importante na detecção de bots. Para criar um perfil de navegador convincente, concentre-se nestas áreas:

Além das configurações estáticas, incorporar comportamentos dinâmicos semelhantes aos humanos é essencial.

Simulação de comportamento humano

Simular o comportamento humano ajuda a reduzir os riscos de detecção. Estas são algumas técnicas eficazes:

• Padrões de digitação
  Inclua atrasos aleatórios entre as teclas pressionadas (por exemplo, de 50 ms a 200 ms) para imitar velocidades naturais de digitação e evitar padrões de entrada automatizados.
• Movimento do mouse
  Use trajetórias não lineares do mouse com velocidades variadas. Pequenos desvios aleatórios podem reproduzir imperfeições humanas no controle do cursor.
• Interação com a página
  Simule rolagens realistas com velocidades e pausas variáveis. Ajustes aleatórios de viewport podem reproduzir o comportamento de leitura ou análise de conteúdo.

Por fim, inicie o navegador com argumentos que reduzam a detecção de bots:

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

Resolvendo reCAPTCHA com Puppeteer

Depois que as medidas de stealth estiverem implementadas, 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.

Usando serviços de resolução de CAPTCHA

Uma forma de lidar com reCAPTCHA programaticamente é integrar 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 a 30 segundos.

Configurando a API do 2Captcha com Puppeteer

O 2Captcha é um serviço amplamente usado para resolver reCAPTCHAs. Veja como 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 de configurar o navegador, você pode verificar o status do resolvedor 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')
}

Dicas para aumentar as taxas de sucesso do reCAPTCHA

Para melhorar as chances de resolver reCAPTCHAs de forma eficaz, siga estas práticas:

• Use um conjunto de proxies residenciais para fazer rotação de endereços IP.
• Adicione pequenos atrasos entre as tentativas de resolução para simular o comportamento natural do usuário.
• Inclua tratamento de erros com novas tentativas usando recuo exponencial.
• Mantenha o contexto do navegador entre as tentativas para evitar reinicializações desnecessárias.

Veja como 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 da DataScrape Solutions destaca a eficácia desses métodos. Em março de 2024, o uso de 2Captcha com Puppeteer reduziu em 95% o tempo de resolução manual de CAPTCHAs e aumentou as taxas de extração de dados em 60% no processamento de mais de 1 milhão de CAPTCHAs por mês [2].

sbb-itb-23997f1

Métodos de reconhecimento de CAPTCHA por imagem

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 resolver esses desafios com eficiência.

Tipos de CAPTCHA por imagem

• Imagens baseadas em texto: incluem caracteres distorcidos com fontes variadas e planos de fundo complexos.
• Reconhecimento de objetos: envolve identificar objetos específicos em um conjunto de opções.
• Correspondência de padrões: exige que os usuários correspondam ou identifiquem padrões visuais.

Agora, vamos analisar métodos de OCR desenvolvidos especificamente para CAPTCHAs baseados em texto.

Usando OCR para texto de CAPTCHA

O Tesseract OCR é uma ferramenta poderosa para reconhecer texto em imagens. A seguir está um exemplo de como integrar o Tesseract OCR ao 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 refinado das propriedades da imagem durante o pré-processamento tem um papel crucial para aumentar a precisão do reconhecimento.

Melhorando a precisão do reconhecimento de imagens

Aumentar o contraste e o brilho pode melhorar significativamente os resultados de OCR. Veja um exemplo de ajuste dinâmico dessas configurações:

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 voltado ao site de reservas ferroviárias de Taiwan alcançou uma taxa de precisão de 98,84% para dígitos únicos e uma precisão geral de 91,13% [1]. Da mesma forma, métodos de deep learning provaram ser eficazes para CAPTCHAs baseados em imagem. Um modelo baseado em TensorFlow, que utiliza uma rede neural convolucional, atingiu uma taxa de sucesso de 90% [1]. 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.

Desempenho de scripts de CAPTCHA

Criar scripts confiáveis para resolver CAPTCHAs exige um tratamento de erros robusto, rotação de IPs e ajustes de desempenho. Depois de configurar técnicas de resolução de CAPTCHA, o próximo passo é focar na eficiência do script.

Sistemas de recuperação de erros

Um bom tratamento de erros é essencial para manter seu script estável. Veja 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 usando novas tentativas incrementais, garantindo que seu script não falhe inesperadamente.

Rotação de IP e navegador

Fazer rotação de IPs e impressões digitais do navegador ajuda a evitar a detecção. Veja como usar plugins do puppeteer-extra para isso:

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 fazer rotação de IPs e cabeçalhos HTTP, seu script imita o comportamento natural de navegação, reduzindo as chances de ser sinalizado.

Otimização de desempenho

Aumente a eficiência e a taxa de sucesso do seu script com as seguintes técnicas:

• Gerenciamento de recursos
  Interrompa downloads de recursos desnecessários, como imagens, folhas de estilo ou fontes:

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

• Processamento paralelo
  Use puppeteer-cluster para resolver vários CAPTCHAs ao mesmo tempo:

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

• Estratégia de cache
  Armazene respostas em cache para evitar solicitações redundantes e economizar tempo de processamento:

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 em conjunto para reduzir o uso de recursos, melhorar a velocidade e lidar com várias tarefas de forma eficiente.

Conclusão e guia de implementação

Visão geral das soluções de CAPTCHA

Lidar com CAPTCHAs de forma eficaz envolve uma estratégia em camadas focada na prevenção. Ao usar ferramentas como técnicas de stealth, cabeçalhos otimizados e rotação de IPs, você pode reduzir as chances de CAPTCHAs serem acionados. A prevenção é sempre melhor do que resolvê-los de forma reativa.

Automação de navegador da Latenode

A Latenode facilita o gerenciamento de CAPTCHA com recursos integrados, como modo stealth, rotação de proxy e gerenciamento de cookies.

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

Próximas etapas para implementação

Para aprimorar seu fluxo de automação, considere estas etapas:

• Ative o modo stealth
  Use plugins de stealth do Puppeteer-extra para reduzir as chances de acionar CAPTCHAs.
• Configure a recuperação de erros
  Adicione mecanismos de recuperação de erros para lidar com diferentes tipos de CAPTCHA. Use novas tentativas automáticas com estratégias como recuo exponencial para uma operação mais fluida.
• Melhore a eficiência dos recursos
  Reduza o tempo de execução do script carregando recursos de forma seletiva e usando cache, garantindo melhor desempenho sem comprometer as taxas de sucesso.