Superar CAPTCHA en scripts de Puppeteer: De reCAPTCHA a servicios de reconocimiento

Los CAPTCHA están diseñados para bloquear bots, lo que facilita la automatización con herramientas como Titiritero Desafiante. Este artículo explica cómo evitar problemas con CAPTCHA, desde técnicas ocultas hasta métodos de solución. Esto es lo que aprenderás:

Tipos de CAPTCHA:Basado en texto, basado en imágenes, reCAPTCHA, hCAPTCHA, y CAPTCHA de audio.
Evitando la detección:Utilice los complementos ocultos adicionales de Puppeteer, administre las huellas dactilares del navegador y simule el comportamiento humano (escritura, movimiento del mouse, desplazamiento).
Resolver CAPTCHA:Integrar servicios como 2Capcha o utilizar herramientas de OCR como Tesseract para CAPTCHAs de imágenes.
Mejorando las tasas de éxito:Rote direcciones IP, gestione errores con reintentos y optimice el uso de recursos.

Comparación rápida de los tipos de CAPTCHA

Tipo de CAPTCHA	Descripción	Desafíos
Basado en texto	Texto distorsionado para reconocimiento	Texto complejo difícil de leer
Basado en imágenes	Identificar objetos/patrones	Requiere procesamiento visual
reCAPTCHA	El sistema de análisis de riesgos de Google	Detecta comportamientos similares a los de un bot
hCAPTCHA	Tareas de identificación de objetos	Similar a reCAPTCHA
Audio	Tareas basadas en el sonido	Reconocimiento de voz complejo

Descubra cómo estos métodos pueden ayudarle a optimizar la automatización, evitando la detección y resolviendo CAPTCHA de manera eficiente.

Cómo eludir reCAPTCHA con Titiritero y sin cabeza...

Métodos de prevención de detección de bots

Para sortear eficazmente los desafíos CAPTCHA, los scripts de Puppeteer deben comportarse de forma que imiten a los usuarios humanos reales. Esto incluye el uso de técnicas de sigilo y patrones de comportamiento naturales.

Configuración de Puppeteer-extra Stealth

El uso de puppeteer-extra Con su complemento oculto, puede evitar la detección de bots. Aquí te explicamos cómo configurarlo:

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

También puedes habilitar técnicas de evasión específicas:

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

El complemento Stealth aborda los métodos de detección más comunes mediante lo siguiente:

La eliminación de la navigator.webdriver propiedad
Ocultar indicadores de Chrome sin cabeza
Agregar aplicaciones de Chrome y objetos CSI
Ajuste de las huellas dactilares del navegador

Gestión de huellas dactilares del navegador

La identificación del navegador es un factor clave en la detección de bots. Para crear un perfil de navegador convincente, concéntrese en estas áreas:

Área de configuración	Detalles de implementacion	Proposito
User Agent	Girar cadenas dinámicamente	Oculta los marcadores de automatización
Compatibilidad con WebGL	Habilitar la aceleración de hardware	Imita una configuración de navegador estándar
Configuración de la ventana gráfica	Utilice dimensiones aleatorias y realistas	Coincide con configuraciones de usuario comunes
Encabezados de idioma	Alinearse con la configuración regional del agente de usuario	Garantiza la coherencia en el perfil del navegador.

Además de las configuraciones estáticas, es fundamental incorporar comportamientos dinámicos similares a los humanos.

Simulación del comportamiento humano

Simular el comportamiento humano ayuda a reducir el riesgo de detección. Aquí hay algunas técnicas efectivas:

Patrones de escritura
Introduzca retrasos aleatorios entre pulsaciones de teclas (por ejemplo, 50 ms a 200 ms) para imitar velocidades de escritura naturales y evitar patrones de entrada automatizados.
Movimiento del raton
Utilice trayectorias de ratón no lineales con distintas velocidades. Pequeñas desviaciones aleatorias pueden replicar las imperfecciones humanas en el control del cursor.
Interacción de la página
Simula un desplazamiento realista con velocidades y pausas variables. Los ajustes aleatorios de la ventana gráfica pueden simular la lectura o el escaneo.

Por último, inicie el navegador con argumentos que reduzcan la detección 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>
})

Resolviendo reCAPTCHA con Puppeteer

Una vez implementadas las medidas de sigilo, la gestión eficiente de reCAPTCHA se vuelve esencial para una automatización fiable. Esto se basa en las técnicas de sigilo y simulación de comportamiento descritas anteriormente.

Uso de servicios de resolución de CAPTCHA

Una forma de gestionar reCAPTCHA programáticamente es integrar servicios de resolución de CAPTCHA. Cuando el script encuentra un reCAPTCHA, envía los parámetros necesarios a un servicio de resolución. Este servicio procesa el CAPTCHA y devuelve la solución, generalmente en un plazo de 10 a 30 segundos.

Configuración 2Capcha API con Puppeteer

2Captcha es un servicio común para resolver reCAPTCHAs. Puedes integrarlo en tu configuración de Puppeteer de la siguiente manera:

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

Una vez configurado el navegador, puedes comprobar el estado del solucionador 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>)
}

Consejos para mejorar las tasas de éxito de ReCAPTCHA

Para mejorar las posibilidades de resolver reCAPTCHAs de manera efectiva, siga estas prácticas:

Utilice un grupo de servidores proxy residenciales para rotar direcciones IP.
Agregue retrasos breves entre los intentos de resolución para simular el comportamiento natural del usuario.
Incluir manejo de errores con reintentos de retroceso exponencial.
Mantenga el contexto del navegador en todos los intentos para evitar reinicializaciones innecesarias.

A continuación le mostramos cómo puede integrar el manejo de errores en su proceso de resolución 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>
}

Un estudio de caso de Soluciones de raspado de datos Destaca la eficacia de estos métodos. En marzo de 2024, el uso de 2Captcha con Puppeteer logró una reducción del 95 % en el tiempo de resolución manual de CAPTCHA y aumentó las tasas de extracción de datos en un 60 % al procesar más de un millón de CAPTCHA al mes. [ 2 ].

sbb-itb-23997f1

Métodos de reconocimiento de CAPTCHA de imágenes

Los CAPTCHA de imágenes están diseñados para desafiar a los sistemas automatizados. Sin embargo, con las herramientas adecuadas, el OCR y las técnicas de procesamiento de imágenes pueden resolver estos problemas eficazmente.

Tipos de CAPTCHA de imagen

Imágenes basadas en texto:Esto incluye caracteres distorsionados con fuentes variables y fondos complejos.
Reconocimiento de objetos:Implica identificar objetos específicos de un conjunto de opciones.
La coincidencia de patrones:Requiere que los usuarios emparejen o identifiquen patrones visuales.

Ahora, profundicemos en los métodos de OCR diseñados específicamente para CAPTCHA basados en texto.

Uso de OCR para texto CAPTCHA

Tesseract OCR es una potente herramienta para reconocer texto en imágenes. A continuación, se muestra un ejemplo de cómo integrar Tesseract OCR con Puppeteer para resolver CAPTCHAs de 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)
}

El ajuste fino de las propiedades de la imagen durante el preprocesamiento juega un papel crucial para mejorar la precisión del reconocimiento.

Mejora de la precisión del reconocimiento de imágenes

Mejorar el contraste y el brillo puede mejorar significativamente los resultados del OCR. A continuación, se muestra un ejemplo de cómo ajustar estas configuraciones dinámicamente:

<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 ejemplo, un proyecto dirigido al sitio web de reservas de trenes de Taiwán logró una tasa de precisión del 98.84 % para dígitos únicos y una precisión general del 91.13 %. [ 1 ]De igual manera, los métodos de aprendizaje profundo han demostrado ser eficaces para los CAPTCHA basados en imágenes. Un modelo basado en TensorFlow, que utiliza una red neuronal convolucional, alcanzó una tasa de éxito del 90 %. [ 1 ]Experimentar con técnicas de preprocesamiento (como ajustar el contraste, el brillo y los umbrales) puede mejorar aún más los resultados según las características específicas de cada tipo de CAPTCHA.

Rendimiento del script CAPTCHA

Crear scripts confiables para resolver CAPTCHA requiere un manejo eficiente de errores, rotación de IP y mejoras de rendimiento. Una vez configuradas las técnicas de resolución de CAPTCHA, el siguiente paso es centrarse en la eficiencia del script.

Sistemas de recuperación de errores

Una buena gestión de errores es clave para mantener la estabilidad del script. Aquí tienes un ejemplo que reintenta en caso de fallo:

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

Este enfoque maneja los tiempos de espera y los problemas de red con reintentos incrementales, lo que garantiza que su script no se bloquee inesperadamente.

Rotación de IP y navegador

Rotar las IP y las huellas del navegador ayuda a evitar la detección. Aquí te explicamos cómo usar los plugins de puppeteer-extra para este 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;
}

Al rotar las direcciones IP y los encabezados HTTP, su script imita el comportamiento de navegación natural, lo que reduce las posibilidades de ser marcado.

Optimización de performance

Mejore la eficacia y la tasa de éxito de su guión con las siguientes técnicas:

Gestión de Recursos
Detenga las descargas de recursos innecesarios como imágenes, hojas de estilo o fuentes:

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

Procesamiento en paralelo
Utilice puppeteer-cluster para resolver varios CAPTCHA al mismo tiempo:

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

Estrategia de almacenamiento en caché
Respuestas en caché para evitar solicitudes redundantes y ahorrar tiempo de procesamiento:

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

Estos métodos funcionan juntos para reducir el uso de recursos, mejorar la velocidad y gestionar múltiples tareas de manera eficiente.

Conclusión y guía de implementación

Descripción general de la solución CAPTCHA

Gestionar CAPTCHAs eficazmente implica una estrategia multinivel centrada en la prevención. Mediante herramientas como técnicas de sigilo, encabezados optimizados y rotación de IP, se puede reducir la probabilidad de que se activen CAPTCHAs. Siempre es mejor prevenir que resolverlos reactivamente.

Nodo tardío Automatización del navegador

Latenode facilita la gestión de CAPTCHA con funciones integradas como modo oculto, rotación de proxy y manejo de cookies.

Aquí tienes un ejemplo de cómo puedes configurarlo:

<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óximos pasos para la implementación

Para mejorar su flujo de trabajo de automatización, considere estos pasos:

Habilitar el modo sigiloso
Utilice los complementos ocultos adicionales de Puppeteer para reducir las probabilidades de que se activen CAPTCHA.
Configurar la recuperación de errores
Agregue mecanismos de recuperación de errores para gestionar diferentes tipos de CAPTCHA. Utilice reintentos automáticos con estrategias como el retroceso exponencial para una operación más fluida.
Mejorar la eficiencia de los recursos
Reduzca el tiempo de ejecución del script cargando recursos de forma selectiva y utilizando almacenamiento en caché, lo que garantiza un mejor rendimiento sin sacrificar las tasas de éxito.

Superar CAPTCHA en scripts de Puppeteer: de reCAPTCHA a servicios de reconocimiento