Cómo superar CAPTCHA en scripts de Puppeteer: de reCAPTCHA a servicios de reconocimiento

Los CAPTCHA están diseñados para bloquear bots, lo que hace que la automatización con herramientas como Puppeteer sea un desafío. Este artículo explica cómo superar los problemas de CAPTCHA, desde técnicas de sigilo hasta métodos de resolución. Esto es lo que aprenderá:

• Tipos de CAPTCHA: CAPTCHA basados en texto, en imágenes, reCAPTCHA, hCAPTCHA y CAPTCHA de audio.
• Cómo evitar la detección: Use plugins de sigilo de Puppeteer-extra, gestione las huellas digitales del navegador y simule el comportamiento humano (escritura, movimiento del ratón y desplazamiento).
• Cómo resolver CAPTCHA: Integre servicios como 2Captcha o use herramientas de OCR como Tesseract para CAPTCHA de imágenes.
• Cómo mejorar las tasas de éxito: Rote las IP, gestione errores con reintentos y optimice el uso de recursos.

Comparación rápida de tipos de CAPTCHA

Descubra cómo estos métodos pueden ayudarle a optimizar la automatización, evitar la detección y resolver CAPTCHA de forma eficiente.

Cómo superar reCAPTCHA con Puppeteer y un navegador headless ...

Métodos para evitar la detección de bots

Para superar los desafíos de CAPTCHA de forma eficaz, los scripts de Puppeteer deben comportarse de manera similar a 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 plugin de sigilo puede ayudar a evitar la detección de bots. Así puede configurarlo:

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

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

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

El plugin de sigilo aborda métodos de detección habituales mediante:

• La eliminación de la propiedad navigator.webdriver
• La ocultación de indicadores de Chrome headless
• La adición de objetos Chrome App y CSI
• El ajuste de las huellas digitales del navegador

Gestión de huellas digitales del navegador

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

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

Simulación del comportamiento humano

Simular el comportamiento humano ayuda a reducir los riesgos de detección. Estas son algunas técnicas eficaces:

• Patrones de escritura
  Introduzca retrasos aleatorios entre pulsaciones de teclas (por ejemplo, de 50 ms a 200 ms) para imitar velocidades de escritura naturales y evitar patrones de entrada automatizados.
• Movimiento del ratón
  Use trayectorias de ratón no lineales con velocidades variables. Las pequeñas desviaciones aleatorias pueden replicar las imperfecciones humanas en el control del cursor.
• Interacción con la página
  Simule desplazamientos realistas con velocidades y pausas variables. Los ajustes aleatorios del viewport pueden emular el comportamiento de lectura o exploración.

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

Resolución de reCAPTCHA con Puppeteer

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

Uso de servicios de resolución de CAPTCHA

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

Configuración de la API de 2Captcha con Puppeteer

2Captcha es un servicio utilizado habitualmente para resolver reCAPTCHA. Así puede integrarlo en su configuración de 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
})

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

Consejos para mejorar las tasas de éxito de reCAPTCHA

Para aumentar las probabilidades de resolver reCAPTCHA de forma eficaz, siga estas prácticas:

• Use un conjunto de proxies residenciales para rotar direcciones IP.
• Añada retrasos breves entre los intentos de resolución para simular el comportamiento natural de un usuario.
• Incluya la gestión de errores con reintentos de retroceso exponencial.
• Mantenga el contexto del navegador entre intentos para evitar reinicializaciones innecesarias.

Así puede integrar la gestión 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 caso de estudio de DataScrape Solutions destaca la eficacia de estos métodos. En marzo de 2024, su 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 1 millón de CAPTCHA mensuales [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, las técnicas de OCR y procesamiento de imágenes pueden resolver estos desafíos de forma eficaz.

Tipos de CAPTCHA de imágenes

• Imágenes basadas en texto: Incluyen caracteres distorsionados con fuentes variadas y fondos complejos.
• Reconocimiento de objetos: Implica identificar objetos específicos a partir de un conjunto de opciones.
• Coincidencia de patrones: Requiere que los usuarios relacionen o identifiquen patrones visuales.

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

Uso de OCR para texto de 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 CAPTCHA basados en 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 preciso de las propiedades de la imagen durante el preprocesamiento desempeña un papel fundamental para mejorar la precisión del reconocimiento.

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

Mejorar el contraste y el brillo puede optimizar considerablemente los resultados de OCR. Este es un ejemplo de ajuste dinámico de estas configuraciones:

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 ferroviarias de Taiwán alcanzó una tasa de precisión del 98,84 % para dígitos individuales y una precisión global del 91,13 % [1]. Del mismo modo, los métodos de aprendizaje profundo han demostrado ser eficaces para 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 de scripts de CAPTCHA

Crear scripts fiables para resolver CAPTCHA requiere una sólida gestión de errores, rotación de IP y ajustes 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 ante errores

Una buena gestión de errores es clave para mantener la estabilidad de su script. Este es un ejemplo que realiza reintentos cuando se produce un error:

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 gestiona los tiempos de espera y los problemas de red mediante reintentos incrementales, lo que garantiza que su script no falle inesperadamente.

Rotación de IP y navegador

Rotar las IP y las huellas digitales del navegador ayuda a evitar la detección. Así puede usar 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 IP y los encabezados HTTP, su script imita el comportamiento de navegación natural, lo que reduce las probabilidades de ser marcado.

Optimización del rendimiento

Mejore la eficiencia y la tasa de éxito de su script 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
  Use 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 caché
  Almacene 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 trabajan en conjunto para reducir el uso de recursos, mejorar la velocidad y gestionar múltiples tareas de forma eficiente.

Conclusión y guía de implementación

Resumen de soluciones para CAPTCHA

Gestionar CAPTCHA de forma eficaz implica una estrategia por capas centrada en la prevención. Al usar herramientas como técnicas de sigilo, encabezados optimizados y rotación de IP, puede reducir las probabilidades de que los CAPTCHA se activen desde el principio. La prevención siempre es mejor que resolverlos de forma reactiva.

Automatización de navegador de Latenode

Latenode facilita la gestión de CAPTCHA con funciones integradas como el modo sigiloso, la rotación de proxies y la gestión de cookies.

Este es un ejemplo de cómo puede 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 automatización, tenga en cuenta estos pasos:

• Habilite el modo sigiloso
  Use plugins de sigilo de Puppeteer-extra para reducir las probabilidades de activar CAPTCHA.
• Configure la recuperación ante errores
  Añada mecanismos de recuperación ante errores para gestionar diferentes tipos de CAPTCHA. Use reintentos automáticos con estrategias como el retroceso exponencial para lograr un funcionamiento más fluido.
• Mejore la eficiencia de los recursos
  Reduzca el tiempo de ejecución del script cargando recursos de forma selectiva y usando caché, lo que garantiza un mejor rendimiento sin sacrificar las tasas de éxito.