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

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

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

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

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

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

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

• La eliminación de la navigator.webdriver perfecta
• 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:

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:

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

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:

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

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

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:

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
}

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.

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:

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

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:

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 ejemplo, un proyecto dirigido al sitio web de reservas de trenes de Taiwán logró una precisión del 98.84 % para números de un solo dígito y una precisión general del 91.13 %. De igual forma, los métodos de aprendizaje profundo han demostrado su eficacia 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 %. 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:

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

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:

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

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 del rendimiento

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:

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

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

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

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

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

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:

const workflow = new LatenodeWorkflow({ browserOptions: { stealth: true, proxyRotation: true, cookieManagement: true } });

await workflow.initBrowser({ captchaHandling: { prevention: true, autoRetry: true, maxAttempts: 3 } });

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.

Artículos relacionados con

• Cómo funciona la detección de navegadores sin interfaz gráfica y cómo evitarla
• Automatización de formularios con Puppeteer: entrada de texto, llenado de formularios y simulación de usuario
• Cómo gestionar la huella digital del navegador en Puppeteer para evitar la detección
• Automatización invisible: uso de puppeteer-extra-plugin-stealth para eludir la protección contra bots