Superando CAPTCHA em scripts de Puppeteer: do reCAPTCHA aos serviços de reconhecimento

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á:

• Tipos de CAPTCHAs: Baseado em texto, baseado em imagem, reCAPTCHA, hCAPTCHA, e CAPTCHAs de áudio.
• Evitando Detecção: Use plugins furtivos extras do Puppeteer, gerencie impressões digitais do navegador e simule o comportamento humano (digitação, movimento do mouse, rolagem).
• Resolvendo CAPTCHAs: Integrar serviços como 2Captcha ou usar ferramentas de OCR como Tesseract para CAPTCHAs de imagem.
• Melhorando as taxas de sucesso: Gire IPs, lide com erros com novas tentativas e otimize o uso de recursos.

Comparação rápida de tipos de CAPTCHA

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

Como contornar reCAPTCHA com Marionetista e sem cabeça...

Métodos de prevenção de detecção de bots

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.

Configurando Puppeteer-extra Stealth

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:

• Removendo o navigator.webdriver propriedade
• Ocultando indicadores do Chrome sem cabeça
• Adicionando objetos do aplicativo Chrome e CSI
• Ajustando impressões digitais do navegador

Gerenciamento de impressão digital do navegador

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

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

Simulação de comportamento humano

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

• Padrões de Digitação
  Introduza atrasos aleatórios entre as teclas digitadas (por exemplo, 50 ms a 200 ms) para imitar as velocidades naturais de digitação e evitar padrões de entrada automatizados.
• Movimento do mouse
  Use caminhos de mouse não lineares com velocidades variadas. Pequenos desvios aleatórios podem replicar imperfeições humanas no controle do cursor.
• Interação de página
  Simule rolagem realista com velocidades e pausas variáveis. Ajustes aleatórios de viewport podem emular comportamento de leitura ou escaneamento.

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

Resolvendo reCAPTCHA com Puppeteer

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.

Usando serviços de solução CAPTCHA

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.

Configurando 2Captcha API com Puppeteer

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

Dicas para melhorar as taxas de sucesso do ReCAPTCHA

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

• Use um pool de proxies residenciais para rotacionar endereços IP.
• Adicione pequenos atrasos entre as tentativas de resolução para simular o comportamento natural do usuário.
• Incluir tratamento de erros com tentativas de recuo exponencial.
• Mantenha o contexto do navegador em todas as tentativas para evitar reinicializações desnecessárias.

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. .

sbb-itb-23997f1

Métodos de reconhecimento de CAPTCHA de 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 efetivamente resolver esses quebra-cabeças.

Tipos de CAPTCHAs de imagem

• Imagens baseadas em texto: Isso inclui caracteres distorcidos com fontes variadas e fundos complexos.
• Reconhecimento de objeto: Envolve a identificação de objetos específicos de um conjunto de opções.
• Correspondência de padrões: Exige que os usuários correspondam ou identifiquem padrões visuais.

Agora, vamos nos aprofundar nos métodos de OCR projetados especificamente para CAPTCHAs baseados em texto.

Usando OCR para texto CAPTCHA

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.

Melhorando a precisão do reconhecimento de imagem

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.

Desempenho do script 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.

Sistemas de recuperação de erros

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.

Rotação de IP e navegador

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.

Otimização de performance

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

• Gestão de Recursos
  Interrompa downloads desnecessários de recursos, 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 o 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 juntos para reduzir o uso de recursos, melhorar a velocidade e lidar com múltiplas tarefas com eficiência.

Guia de Conclusão e Implementação

Visão geral da solução CAPTCHA

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.

Nó latente Automação do navegador

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

Próximas etapas para implementação

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

• Ativar modo furtivo
  Use os plugins stealth extras do Puppeteer para diminuir as chances de acionar CAPTCHAs.
• Configurar 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 backoff exponencial para uma operação mais suave.
• Melhore a eficiência dos recursos
  Reduza o tempo de execução do script carregando recursos seletivamente e usando cache, garantindo melhor desempenho sem sacrificar as taxas de sucesso.

Artigos Relacionados

• Como funciona a detecção de navegador sem cabeça e como ignorá-la
• Automação de formulários com Puppeteer: entrada de texto, preenchimento de formulários e simulação de usuário
• Gerenciando a impressão digital do navegador no Puppeteer para evitar a detecção
• Automação invisível: usando puppeteer-extra-plugin-stealth para ignorar a proteção de bots