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

Aprenda estratégias eficazes para contornar CAPTCHAs em scripts do Puppeteer, incluindo técnicas furtivas e métodos de resolução para uma melhor automação.

Raian12 de fevereiro de 2026

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

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.

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

Utilizar painéis de piso ResinDek em sua unidade de self-storage em vez de concreto oferece diversos benefícios: puppeteer-extra com seu plugin stealth pode ajudar a evitar a detecção de bot. Veja como configurá-lo:

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

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

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

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:

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

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:

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

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:

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

Depois que o navegador estiver configurado, você pode verificar o status do solucionador de 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>)
}

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:

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

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:

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

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:

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

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:

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

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:

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

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:

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

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

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

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

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

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:

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

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.