Cómo resolver Captcha en Crawl4AI con CapSolver integración

1. Introducción

La automatización web y la extracción de datos son vitales para muchas aplicaciones, pero los CAPTCHA a menudo interrumpen estos procesos, causando retrasos y fallos.

Para abordar esto, Crawl4AI y CapSolver han colaborado. Crawl4AI ofrece una raspado avanzado y adaptable de páginas web y control de navegador, mientras que CapSolver proporciona una resolución de CAPTCHA altamente precisa y rápida. Esta colaboración permite a los desarrolladores lograr una automatización web y recolección de datos sin interrupciones.

1.1. Objetivos de la integración

Los objetivos principales de la integración de Crawl4AI y CapSolver son:

• Combinar las capacidades eficientes de raspado de Crawl4AI con las capacidades de resolución de CAPTCHA de CapSolver: A través de una integración profunda, Crawl4AI puede llamar de forma fluida a los servicios de CapSolver cuando se encuentra con CAPTCHA, logrando así un bypass automatizado.
• Lograr una extracción de datos web automatizada y sin obstáculos: Eliminar los obstáculos causados por los CAPTCHA, garantizando la continuidad y completitud de las tareas de extracción de datos, reduciendo significativamente la intervención manual.
• Mejorar la estabilidad y tasa de éxito del raspador: Proporcionar soluciones estables y confiables ante mecanismos anti-bot complejos, mejorando así significativamente la tasa de éxito y la eficiencia de la extracción de datos.

2. Visión general de Crawl4AI

Crawl4AI es una herramienta de raspado web y extracción de datos de código abierto y amigable con LLM, dise?ada para satisfacer las necesidades de las aplicaciones de inteligencia artificial modernas. Puede transformar contenido de páginas web complejas en formato Markdown estructurado y limpio, simplificando enormemente el procesamiento y análisis posterior de los datos.

2.1. Características principales

• Amigable con LLM: Crawl4AI puede generar contenido de Markdown de alta calidad y soportar extracción estructurada, convirtiéndolo en una elección ideal para construir RAG (Generación Aumentada por Recuperación), agentes de inteligencia artificial y pipelines de datos. Automáticamente filtra el ruido, manteniendo solo la información valiosa para los LLM.
• Control avanzado de navegador: Ofrece capacidades poderosas de control de navegador headless, soportando gestión de sesiones e integración de proxies. Esto significa que Crawl4AI puede simular el comportamiento de un usuario real, evitando eficazmente la detección de bots y manejando contenido cargado dinámicamente.
• Alta rendimiento y raspado adaptativo: Crawl4AI utiliza algoritmos de raspado adaptativo inteligente que pueden determinar de forma inteligente cuándo detener el raspado basándose en la relevancia del contenido, evitando el raspado ciego de grandes cantidades de páginas irrelevantes, mejorando así la eficiencia y reduciendo costos. Su velocidad y eficiencia son destacadas al manejar sitios web de gran escala.
• Modo de invisibilidad: Efectivamente evita la detección de bots imitando el comportamiento de un usuario real.
• Raspado consciente de identidad: Puede guardar y reutilizar cookies y localStorage, soportando el raspado de sitios web después de iniciar sesión, asegurando que el raspador sea reconocido como un usuario legítimo.

2.2. Casos de uso

Crawl4AI es adecuado para grandes tareas de extracción de datos como investigación de mercado, agregación de noticias o recolección de productos en comercio electrónico. Maneja sitios web dinámicos y con mucho JavaScript y sirve como fuente de datos confiable para agentes de inteligencia artificial y pipelines automatizados de datos.

Crawl4AI imagina un futuro donde los datos digitales se conviertan en un activo de capital verdadero. Su whitepaper describe una economía de datos compartida, empoderando a individuos y empresas para estructurar, valorar y, opcionalmente, monetizar sus datos auténticos, alineándose estrechamente con la misión de CapSolver de liberar el valor de los datos generados por humanos mediante resolución de CAPTCHA fluida y acceso automatizado a datos.

3. Visión general de CapSolver

CapSolver es un servicio líder de resolución de CAPTCHA automatizado que utiliza tecnología de IA avanzada para proporcionar soluciones rápidas y precisas para diversos desafíos de CAPTCHA complejos. Tiene como objetivo ayudar a desarrolladores y empresas a superar las barreras de CAPTCHA y garantizar la operación fluida de procesos automatizados.

• Soporta múltiples tipos de CAPTCHA: CapSolver puede resolver tipos de CAPTCHA principales del mercado, incluyendo, entre otros, reCAPTCHA v2/v3, Cloudflare Turnstile, ImageToText (OCR), AWS WAF, etc. Su amplia compatibilidad lo convierte en una solución universal de CAPTCHA.
• Alta tasa de reconocimiento y respuesta rápida: Utilizando algoritmos de IA poderosos y recursos de cómputo a gran escala, CapSolver logra una precisión extremadamente alta en la resolución de CAPTCHA y devuelve soluciones en milisegundos, minimizando los retrasos en el raspado.
• Fácil integración de API: CapSolver proporciona interfaces de API claras y concisas y documentación detallada de SDK, lo que hace que sea fácil para desarrolladores integrar rápidamente sus servicios en marcos de raspador existentes y herramientas de automatización, ya sea en Python, Node.js u otros entornos de lenguaje.

4. Resolver desafíos de CAPTCHA con Crawl4AI y CapSolver

4.1. Problemas

Antes de integrar CapSolver, incluso con sus capacidades de raspado poderosas, Crawl4AI a menudo enfrentaba los siguientes problemas al encontrarse con CAPTCHA:

• Interrupción del proceso de adquisición de datos: Una vez que el raspador activa un CAPTCHA, toda la tarea de extracción de datos se bloquea, requiriendo intervención manual para resolverlo, afectando severamente la eficiencia de la automatización.
• Disminuida estabilidad: La aparición de CAPTCHA conduce a tareas de raspado inestables, tasas de éxito fluctuantes y dificultad para garantizar un flujo continuo de datos.
• Aumento de costos de desarrollo: Los desarrolladores deben invertir tiempo adicional y esfuerzo para encontrar, probar y mantener diversas soluciones para evitar CAPTCHA, o resolver manualmente CAPTCHA, aumentando así los costos de desarrollo y operación.
• Compromiso de la puntualidad de los datos: Los retrasos causados por CAPTCHA pueden hacer que los datos pierdan su puntualidad, afectando decisiones basadas en datos en tiempo real.

4.2. Solución: Cómo resolver con la integración de Crawl4AI y CapSolver

La integración de Crawl4AI y CapSolver proporciona una solución elegante y poderosa que resuelve completamente los problemas anteriores. La idea general es: cuando Crawl4AI detecta un CAPTCHA durante el proceso de raspado, activa automáticamente el servicio de CapSolver para reconocimiento y resolución, e inyecta de forma fluida la solución en el proceso de raspado, logrando así un bypass automatizado de CAPTCHA.

Valor de la integración:

• Manejo automatizado de CAPTCHA: Los desarrolladores pueden llamar directamente a la API de CapSolver dentro de Crawl4AI, eliminando la necesidad de intervención manual y logrando el reconocimiento y resolución automatizados de CAPTCHA.
• Mejora de la eficiencia de raspado: Al evitar automáticamente CAPTCHA, las interrupciones de raspado se reducen significativamente, acelerando el proceso de adquisición de datos.
• Mejora de la robustez del raspador: Frente a mecanismos anti-bot diversos, la solución integrada ofrece mayor adaptabilidad y estabilidad, asegurando que el raspador opere eficientemente en diversos entornos complejos.
• Reducción de costos operativos: Reduce la necesidad de intervención manual, optimiza la asignación de recursos y disminuye los costos operativos a largo plazo de la extracción de datos

La integración de Crawl4AI y CapSolver principalmente implica dos métodos: integración de API e integración de extensión de navegador. Se recomienda la integración de API por ser más flexible y precisa, evitando posibles problemas con el momento de inyección y la precisión que podrían surgir con extensiones de navegador en páginas complejas.

5. Cómo integrar usando la API de CapSolver

La integración de API requiere combinar la funcionalidad js_code de Crawl4AI. Los pasos básicos son los siguientes:

1. Navegar a la página que contiene el CAPTCHA: Crawl4AI accede normalmente a la página web objetivo.
2. Obtener token usando el SDK de CapSolver: En el código Python de Crawl4AI, llame a la API de CapSolver usando el SDK de CapSolver, enviando parámetros relacionados con el CAPTCHA (por ejemplo, siteKey, websiteURL) al servicio de CapSolver para obtener la solución del CAPTCHA (normalmente un token).
3. Inyectar token usando CrawlerRunConfig de Crawl4AI: Use el parámetro js_code del método CrawlerRunConfig para inyectar el token devuelto por CapSolver en el elemento correspondiente de la página objetivo. Por ejemplo, para reCAPTCHA v2, el token normalmente necesita inyectarse en el elemento g-recaptcha-response.
4. Continuar otras operaciones de Crawl4AI: Después de una inyección exitosa del token, Crawl4AI puede continuar realizando acciones posteriores como clics y envíos de formularios, con el CAPTCHA superado con éxito.

5.1. Resolviendo reCAPTCHA v2

reCAPTCHA v2 es un CAPTCHA de casilla de verificación "I'm not a robot" común. Para resolverlo, obtenga el token gRecaptchaResponse mediante CapSolver e ingréselo en la página. Si no está seguro de cómo configurar los parámetros, consulte el blog tutorial para detectar automáticamente el CAPTCHA y extraer la configuración.

Análisis del código de ejemplo:

El código proporcionado por el usuario demuestra cómo usar el método capsolver.solve para obtener el token de reCAPTCHA v2 y asignarlo al área de texto g-recaptcha-response mediante js_code, luego simular el clic en el botón de envío. Este método asegura que el token de CAPTCHA se lleve correctamente al enviar el formulario.

import asyncio
import capsolver
from crawl4ai import *


# TODO: configure su configuración
api_key = "CAP-xxxxxxxxxxxxxxxxxxxxx"                                      # su clave de API de capsolver
site_key = "6LfW6wATAAAAAHLqO2pb8bDBahxlMxNdo9g947u9"                      # clave del sitio de su sitio objetivo
site_url = "https://recaptcha-demo.appspot.com/recaptcha-v2-checkbox.php"  # URL de la página de su sitio objetivo
captcha_type = "ReCaptchaV2TaskProxyLess"                                  # tipo de su CAPTCHA objetivo
capsolver.api_key = api_key


async def main():
    browser_config = BrowserConfig(
        verbose=True,
        headless=False,
        use_persistent_context=True,
    )

    async with AsyncWebCrawler(config=browser_config) as crawler:
        await crawler.arun(
            url=site_url,
            cache_mode=CacheMode.BYPASS,
            session_id="session_captcha_test"
        )

        # obtener token de recaptcha usando el sdk de capsolver
        solution = capsolver.solve({
            "type": captcha_type,
            "websiteURL": site_url,
            "websiteKey": site_key,
        })
        token = solution["gRecaptchaResponse"]
        print("token de recaptcha:", token)

        js_code = """
            const textarea = document.getElementById(\'g-recaptcha-response\');
            if (textarea) {
                textarea.value = \"""" + token + """\";
                document.querySelector(\'button.form-field[type="submit"]\').click();
            }
        """

        wait_condition = """() => {
            const items = document.querySelectorAll(\'h2\');
            return items.length > 1;
        }"""

        run_config = CrawlerRunConfig(
            cache_mode=CacheMode.BYPASS,
            session_id="session_captcha_test",
            js_code=js_code,
            js_only=True,
            wait_for=f"js:{wait_condition}"
        )

        result_next = await crawler.arun(
            url=site_url,
            config=run_config,
        )
        print(result_next.markdown)


if __name__ == "__main__":
    asyncio.run(main())

Si un token v2 es inválido, obtenga la configuración JSON mediante la extensión y envíela a nuestro soporte para mejorar la puntuación del token: Resolver reCAPTCHA v2, v2 invisible, v3, v3 Enterprise ≥0.9 puntuación.

5.2. Resolviendo reCAPTCHA v3

reCAPTCHA v3 es un CAPTCHA invisible que normalmente funciona en segundo plano y devuelve una puntuación. Antes de resolver reCAPTCHA v3, lea la documentación de reCAPTCHA v3 de CapSolver para comprender los parámetros requeridos y cómo obtenerlos. Usaremos el demo de reCAPTCHA v3 como ejemplo.

• A diferencia de v2, reCAPTCHA v3 es invisible, por lo que la inyección del token puede ser complicada. Inyectar el token demasiado pronto puede ser sobrescrito por el token original, e inyectar demasiado tarde puede pasar por alto el paso de verificación. En este sitio de demostración, visitar la página activa automáticamente la generación y verificación del token.

• Al observar la página, vemos que resolver reCAPTCHA activa una solicitud fetch para verificar el token. La solución es obtener el token de CapSolver con anticipación y interceptar la solicitud fetch para reemplazar el token original en el momento adecuado.

Análisis del código de ejemplo:

El código intercepta el método window.fetch, y cuando se envía una solicitud a /recaptcha-v3-verify.php, reemplaza el token original con el token obtenido con anticipación de CapSolver. Esta técnica avanzada de interceptación asegura que incluso los CAPTCHA v3 generados dinámicamente, que son difíciles de manipular directamente, puedan ser evitados de forma efectiva.

import asyncio
import capsolver
from crawl4ai import *


# TODO: configure su configuración
api_key = "CAP-xxxxxxxxxxxxxxxxxxxxx"                                             # su clave de API de capsolver
site_key = "6LdKlZEpAAAAAAOQjzC2v_d36tWxCl6dWsozdSy9"                             # clave del sitio de su sitio objetivo
site_url = "https://recaptcha-demo.appspot.com/recaptcha-v3-request-scores.php"   # URL de la página de su sitio objetivo
page_action = "examples/v3scores"                                                 # acción de página de su sitio objetivo
captcha_type = "ReCaptchaV3TaskProxyLess"                                         # tipo de su CAPTCHA objetivo
capsolver.api_key = api_key


async def main():
    browser_config = BrowserConfig(
        verbose=True,
        headless=False,
        use_persistent_context=True,
    )

    # obtener token de recaptcha usando el sdk de capsolver
    solution = capsolver.solve({
        "type": captcha_type,
        "websiteURL": site_url,
        "websiteKey": site_key,
        "pageAction": page_action,
    })
    token = solution["gRecaptchaResponse"]
    print("token de recaptcha:", token)

    async with AsyncWebCrawler(config=browser_config) as crawler:
        await crawler.arun(
            url=site_url,
            cache_mode=CacheMode.BYPASS,
            session_id="session_captcha_test"
        )

        js_code = """
            const originalFetch = window.fetch;
            
            window.fetch = function(...args) {
              if (typeof args[0] === \'string\' && args[0].includes(\'/recaptcha-v3-verify.php\')) {
                const url = new URL(args[0], window.location.origin);
url.searchParams.set('action', '""" + token + """');
                args[0] = url.toString();
                document.querySelector('.token').innerHTML = "fetch('/recaptcha-v3-verify.php?action=examples/v3scores&token="+token+"\')";
                console.log('Fetch URL hooked:', args[0]);
              }
              return originalFetch.apply(this, args);
            };
        """

        wait_condition = "() => {
            return document.querySelector('.step3:not(.hidden)');
        }"

        run_config = CrawlerRunConfig(
            cache_mode=CacheMode.BYPASS,
            session_id="session_captcha_test",
            js_code=js_code,
            js_only=True,
            wait_for=f"js:{wait_condition}"
        )

        result_next = await crawler.arun(
            url=site_url,
            config=run_config,
        )
        print(result_next.markdown)


if __name__ == "__main__":
    asyncio.run(main())

Si un token v3 es inválido, obtenga la configuración JSON a través de la extensión y envíela a nuestro soporte para mejorar la puntuación del token: Resolver reCAPTCHA v2, v2 invisible, v3, v3 Enterprise ≥0.9 score.

5.3. Resolver Cloudflare Turnstile

Antes de comenzar a resolver Cloudflare Turnstile, lea cuidadosamente la documentación de Cloudflare Turnstile de CapSolver para asegurarse de entender qué parámetros deben pasarse al crear una tarea y cómo obtener sus valores. A continuación, usaremos el demo de Turnstile como ejemplo para mostrar cómo resolver Cloudflare Turnstile.

Después de resolver Turnstile, el token se inyectará en un elemento de entrada llamado cf-turnstile-response. Por lo tanto, nuestro js_code también debe simular esta operación. Al continuar con el siguiente paso, como hacer clic en iniciar sesión, este token se llevará automáticamente para la verificación.

import asyncio
import capsolver
from crawl4ai import *


# TODO: configure su configuración
api_key = "CAP-xxxxxxxxxxxxxxxxxxxxx"  # su clave de API de capsolver
site_key = "0x4AAAAAAAGlwMzq_9z6S9Mh"                             # clave del sitio de su sitio objetivo
site_url = "https://clifford.io/demo/cloudflare-turnstile"         # URL de la página de su sitio objetivo
captcha_type = "AntiTurnstileTaskProxyLess"                                         # tipo de captcha objetivo
capsolver.api_key = api_key


async def main():
    browser_config = BrowserConfig(
        verbose=True,
        headless=False,
        use_persistent_context=True,
    )

    async with AsyncWebCrawler(config=browser_config) as crawler:
        await crawler.arun(
            url=site_url,
            cache_mode=CacheMode.BYPASS,
            session_id="session_captcha_test"
        )

        # obtener token de turnstile usando sdk de capsolver
        solution = capsolver.solve({
            "type": captcha_type,
            "websiteURL": site_url,
            "websiteKey": site_key,
        })
        token = solution["token"]
        print("token de turnstile:", token)

        js_code = """
            document.querySelector('input[name="cf-turnstile-response"]').value = '"""+token+""";
            document.querySelector('button[type="submit"]').click();
        """

        wait_condition = """() => {
            const items = document.querySelectorAll('h1');
            return items.length === 0;
        }"""

        run_config = CrawlerRunConfig(
            cache_mode=CacheMode.BYPASS,
            session_id="session_captcha_test",
            js_code=js_code,
            js_only=True,
            wait_for=f"js:{wait_condition}"
        )

        result_next = await crawler.arun(
            url=site_url,
            config=run_config,
        )
        print(result_next.markdown)


if __name__ == "__main__":
    asyncio.run(main())

5.4. Resolver desafíos de Cloudflare

Los desafíos de Cloudflare suelen requerir un manejo más complejo, incluyendo la coincidencia de huellas dactilares del navegador y el User-Agent. CapSolver proporciona el tipo AntiCloudflareTask para resolver estos desafíos. Antes de resolver un desafío de Cloudflare, revise la documentación de desafíos de Cloudflare de CapSolver para entender los parámetros necesarios y cómo obtenerlos al crear una tarea.

Notas:

• La versión del navegador, la plataforma y el userAgent deben coincidir con la versión utilizada por CapSolver.
• El userAgent debe ser coherente con la versión y la plataforma.

import asyncio
import time

import capsolver
from crawl4ai import *

# TODO: configure su configuración
api_key = "CAP-XXX"  # su clave de API de capsolver
site_url = "https://www.tempo.co/hukum/polisi-diduga-salah-tangkap-pelajar-di-magelang-yang-dituduh-perusuh-demo-2070572"  # URL de la página de su sitio objetivo
captcha_type = "AntiCloudflareTask"  # tipo de captcha objetivo
api_proxy = "http://127.0.0.1:13120"
capsolver.api_key = api_key

user_data_dir = "./crawl4ai_/browser-profile/Default1493"
# o
cdp_url = "ws://localhost:xxxx"

async def main():
    print("inicio de resolución de token")
    start_time = time.time()
    # obtener token de cloudflare usando sdk de capsolver
    solution = capsolver.solve({
        "type": captcha_type,
        "websiteURL": site_url,
        "proxy": api_proxy,
        "userAgent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36"
    })
    token_time = time.time()
    print(f"resolución de token: {token_time - start_time:.2f} s")

    # establecer cookies
    cookies = solution.get("cookies", [])
    if isinstance(cookies, dict):
        cookies_array = []
        for name, value in cookies.items():
            cookies_array.append({
                "name": name,
                "value": value,
                "url": site_url,
            })
        cookies = cookies_array
    elif not isinstance(cookies, list):
        cookies = []
    token = solution["token"]
    print("token de desafío:", token)

    browser_config = BrowserConfig(
        verbose=True,
        headless=False,
        use_persistent_context=True,
        user_data_dir=user_data_dir,
        # cdp_url=cdp_url,
        user_agent=solution["userAgent"],
        cookies=cookies,
    )

    async with AsyncWebCrawler(config=browser_config) as crawler:
        result = await crawler.arun(
            url=site_url,
            cache_mode=CacheMode.BYPASS,
            session_id="session_captcha_test"
        )
        print(result.markdown[:500])


if __name__ == "__main__":
    asyncio.run(main())

5.5. Resolver AWS WAF

AWS WAF es un Firewall de Aplicaciones Web que normalmente verifica las solicitudes estableciendo cookies específicas. Para más información sobre cómo lidiar con AWS WAF, consulte nuestra guía en la documentación de AWS WAF para asegurarse de que conozca qué tipos de parámetros deben enviarse al crear una tarea y cómo obtener sus valores. La clave para resolver AWS WAF es obtener la cookie aws-waf-token devuelta por CapSolver.

Análisis del código de ejemplo:

El código obtiene la cookie aws-waf-token mediante CapSolver, luego usa js_code para establecerla como cookie de la página y recarga la página. Después de recargarla, Crawl4AI accederá a la página con la cookie correcta, evitando así la detección de AWS WAF.

import asyncio
import capsolver
from crawl4ai import *


# TODO: configure su configuración
api_key = "CAP-xxxxxxxxxxxxxxxxxxxxx"              # su clave de API de capsolver
site_url = "https://nft.porsche.com/onboarding@6"  # URL de la página de su sitio objetivo
cookie_domain = ".nft.porsche.com"                 # el nombre de dominio al que desea aplicar la cookie
captcha_type = "AntiAwsWafTaskProxyLess"           # tipo de captcha objetivo
capsolver.api_key = api_key


async def main():
    browser_config = BrowserConfig(
        verbose=True,
        headless=False,
        use_persistent_context=True,
    )

    async with AsyncWebCrawler(config=browser_config) as crawler:
        await crawler.arun(
            url=site_url,
            cache_mode=CacheMode.BYPASS,
            session_id="session_captcha_test"
        )

        # obtener cookie de AWS WAF usando sdk de capsolver
        solution = capsolver.solve({
            "type": captcha_type,
            "websiteURL": site_url,
        })
        cookie = solution["cookie"]
        print("cookie de AWS WAF:", cookie)

        js_code = """
            document.cookie = 'aws-waf-token=""" + cookie + """;domain=""" + cookie_domain + """;path=/';
            location.reload();
        """

        wait_condition = """() => {
            return document.title === 'Unirse al viaje de Porsche en Web3';
        }"""

        run_config = CrawlerRunConfig(
            cache_mode=CacheMode.BYPASS,
            session_id="session_captcha_test",
            js_code=js_code,
            js_only=True,
            wait_for=f"js:{wait_condition}"
        )

        result_next = await crawler.arun(
            url=site_url,
            config=run_config,
        )
        print(result_next.markdown)


if __name__ == "__main__":
    asyncio.run(main())

6. Cómo integrar usando la extensión de CapSolver

Integrar una extensión de navegador con crawl4ai requiere especificar el directorio de inicio del navegador, luego instalar la extensión para resolver captchas. Puede elegir que la extensión los resuelva automáticamente o use js_code para resolverlos activamente. Los pasos generales son los siguientes:

1. Inicie el navegador especificando user_data_dir.
2. Instale la extensión: visite chrome://extensions, haga clic en "modo de desarrollador" en la esquina superior derecha, luego seleccione "Cargar extensión no empaquetada" y elija el directorio del proyecto de la extensión local.
3. Visite la página de la extensión de CapSolver y configure la clave de API; alternativamente, configure apiKey directamente en /CapSolver/assets/config.js dentro del proyecto de la extensión.
   Descripción de parámetros de config.js:

• useCapsolver: Si se debe usar automáticamente CapSolver para detectar y resolver captchas.
• manualSolving: Si se debe iniciar manualmente la resolución de captchas.
• useProxy: Si se debe configurar un proxy.
• enabledForBlacklistControl: Si se debe habilitar el control de lista negra.
• ...

4. Visite una página que contenga un captcha.
5. Espere a que la extensión lo procese automáticamente / use js_code para elegir cuándo resolver el captcha.
6. Continúe con otras operaciones usando crawl4ai.

Los siguientes ejemplos mostrarán cómo resolver reCAPTCHA v2/v3, Cloudflare Turnstile, AWS WAF a través de la integración con la extensión del navegador.

6.1. Resolver reCAPTCHA v2

Antes de resolver reCAPTCHA v2, asegúrese de que haya configurado correctamente la extensión. A continuación, usaremos la API de demostración como ejemplo para mostrar cómo resolver reCAPTCHA v2.

Después de resolver reCAPTCHA, al continuar con el siguiente paso, como hacer clic en iniciar sesión, la verificación ocurrirá automáticamente.

import asyncio
import time

from crawl4ai import *


# TODO: configure su configuración
user_data_dir = "/browser-profile/Default1"

browser_config = BrowserConfig(
    verbose=True,
    headless=False,
    user_data_dir=user_data_dir,
    use_persistent_context=True,
    proxy="http://127.0.0.1:13120",
)

async def main():
    async with AsyncWebCrawler(config=browser_config) as crawler:
        result_initial = await crawler.arun(
            url="https://recaptcha-demo.appspot.com/recaptcha-v2-checkbox.php",
            cache_mode=CacheMode.BYPASS,
            session_id="session_captcha_test"
        )

        # haga algo más tarde
        time.sleep(300)


if __name__ == "__main__":
    asyncio.run(main())

Si necesita elegir activamente cuándo resolver el captcha, use el siguiente código:

• Nota: Haga clic en "Resolver manualmente" en la página de la extensión.

Debe configurar el parámetro manualSolving de la extensión en true. De lo contrario, la extensión activará automáticamente la resolución de captchas.

import asyncio
import time

from crawl4ai import *


# TODO: configure su configuración
user_data_dir = "/browser-profile/Default1"

browser_config = BrowserConfig(
    verbose=True,
    headless=False,
    user_data_dir=user_data_dir,
    use_persistent_context=True,
    proxy="http://127.0.0.1:13120",
)

async def main():
    async with AsyncWebCrawler(config=browser_config) as crawler:
        result_initial = await crawler.arun(
            url="https://recaptcha-demo.appspot.com/recaptcha-v2-checkbox.php",
            cache_mode=CacheMode.BYPASS,
            session_id="session_captcha_test"
        )

        # haga algo más tarde
        time.sleep(6)

        js_code = """
            let solverButton = document.querySelector('#capsolver-solver-tip-button');
            if (solverButton) {
            // evento de clic
                const clickEvent = new MouseEvent('click', {
                    bubbles: true,
                    cancelable: true,
                    view: window
                });
                
                solverButton.dispatchEvent(clickEvent);
            }
        """
        print(js_code)
        run_config = CrawlerRunConfig(
            cache_mode=CacheMode.BYPASS,
            session_id="session_captcha_test",
            js_code=js_code,
            js_only=True,
        )
        result_next = await crawler.arun(
            url="https://recaptcha-demo.appspot.com/recaptcha-v2-checkbox.php",
            config=run_config
        )
        print("Resultados de ejecución de JS:", result_next.js_execution_result)

        time.sleep(300)


if __name__ == "__main__":
    asyncio.run(main())

6.2. Resolver reCAPTCHA v3

Antes de resolver reCAPTCHA v3, asegúrese de que haya configurado correctamente la extensión. A continuación, usaremos la API de demostración como ejemplo para mostrar cómo resolver reCAPTCHA v3.

Después de resolver reCAPTCHA, al continuar con el siguiente paso, como hacer clic en iniciar sesión, la verificación ocurrirá automáticamente.

• Se recomienda resolver reCAPTCHA v3 automáticamente mediante la extensión, generalmente activado al visitar el sitio web.
  session_id="session_captcha_test"
  )

    # hacer algo más tarde
    time.sleep(300)

if name == "main":
asyncio.run(main())

### 6.3. Resolver Cloudflare Turnstile
Antes de resolver Cloudflare Turnstile, asegúrese de que haya configurado correctamente la extensión. A continuación, usaremos <a href="https://clifford.io/demo/cloudflare-turnstile" rel="nofollow">Turnstile Demo</a> como ejemplo para demostrar cómo resolver Cloudflare Turnstile.

Una vez que se resuelva Turnstile, se inyectará un token en un elemento de entrada llamado `cf-turnstile-response`. Al continuar con el siguiente paso, como hacer clic en iniciar sesión, este token se llevará automáticamente para la verificación.
```python
import asyncio
import time

from crawl4ai import *


# TODO: configure su configuración
user_data_dir = "/browser-profile/Default1"

browser_config = BrowserConfig(
    verbose=True,
    headless=False,
    user_data_dir=user_data_dir,
    use_persistent_context=True,
    proxy="http://127.0.0.1:13120",
)

async def main():
    async with AsyncWebCrawler(config=browser_config) as crawler:
        result_initial = await crawler.arun(
            url="https://recaptcha-demo.appspot.com/recaptcha-v2-checkbox.php",
            cache_mode=CacheMode.BYPASS,
            session_id="session_captcha_test"
        )

        # hacer algo más tarde
        time.sleep(300)


if __name__ == "__main__":
    asyncio.run(main())

6.4. Resolver AWS WAF

Antes de resolver AWS WAF, asegúrese de que la extensión CapSolver esté correctamente configurada. En este ejemplo, usaremos demo de AWS WAF para demostrar el proceso.

Una vez que se resuelva AWS WAF, se obtendrá una cookie llamada aws-waf-token. Esta cookie se lleva automáticamente para la verificación en operaciones posteriores.

import asyncio
import time

from crawl4ai import *


# TODO: configure su configuración
user_data_dir = "/browser-profile/Default1"

browser_config = BrowserConfig(
    verbose=True,
    headless=False,
    user_data_dir=user_data_dir,
    use_persistent_context=True,
    proxy="http://127.0.0.1:13120",
)

async def main():
    async with AsyncWebCrawler(config=browser_config) as crawler:
        result_initial = await crawler.arun(
            url="https://nft.porsche.com/onboarding@6",
            cache_mode=CacheMode.BYPASS,
            session_id="session_captcha_test"
        )

        # hacer algo más tarde
        time.sleep(300)


if __name__ == "__main__":
    asyncio.run(main())

Si necesita elegir activamente cuándo resolver el captcha, utilice el siguiente código:

• Nota: Haga clic en "Resolver manualmente" en la página de la extensión.

Debe configurar el parámetro manualSolving de la extensión en true. De lo contrario, la extensión activará automáticamente la resolución del captcha.

import asyncio
import time

from crawl4ai import *


# TODO: configure su configuración
user_data_dir = "/browser-profile/Default1"

browser_config = BrowserConfig(
    verbose=True,
    headless=False,
    user_data_dir=user_data_dir,
    use_persistent_context=True,
    proxy="http://127.0.0.1:13120",
)

async def main():
    async with AsyncWebCrawler(config=browser_config) as crawler:
        result_initial = await crawler.arun(
            url="https://nft.porsche.com/onboarding@6",
            cache_mode=CacheMode.BYPASS,
            session_id="session_captcha_test"
        )

        # hacer algo más tarde
        time.sleep(6)

        js_code = """
            let solverButton = document.querySelector(\'#capsolver-solver-tip-button\');
            if (solverButton) {
            // evento de clic
                const clickEvent = new MouseEvent(\'click\', {
                    bubbles: true,
                    cancelable: true,
                    view: window
                });
                
                solverButton.dispatchEvent(clickEvent);
            }
        """
        print(js_code)
        run_config = CrawlerRunConfig(
            cache_mode=CacheMode.BYPASS,
            session_id="session_captcha_test",
            js_code=js_code,
            js_only=True,
        )
        result_next = await crawler.arun(
            url="https://nft.porsche.com/onboarding@6",
            config=run_config
        )
        print("Resultados de la ejecución de JS:", result_next.js_execution_result)

        time.sleep(300)


if __name__ == "__main__":
    asyncio.run(main())

7. Conclusión

La alianza oficial entre Crawl4AI y CapSolver marca un hito significativo en el campo de la extracción de datos de web. Al combinar las capacidades avanzadas de rastreo de Crawl4AI con los servicios poderosos de resolución de CAPTCHA de CapSolver, los desarrolladores ahora pueden construir sistemas de rastreador automatizados más estables, eficientes y robustos.

Ya sea que se trate de contenido dinámico complejo o de diversos mecanismos anti-bot, esta solución integrada ofrece un excelente rendimiento y flexibilidad. La integración de API proporciona control granular y mayor precisión, mientras que la integración de extensión de navegador simplifica el proceso de configuración, adaptándose a las necesidades de diferentes escenarios.

7.1. Preguntas frecuentes

P1: ?Qué es la integración de Crawl4AI y CapSolver, y cómo resuelve CAPTCHAs?
R1: La integración combina el avanzado rastreo web de Crawl4AI con la resolución automática de CAPTCHA de CapSolver. Bypassea CAPTCHAs como reCAPTCHA v2/v3, Cloudflare Turnstile y AWS WAF, permitiendo la extracción de datos de web sin interrupciones y de manera eficiente sin intervención manual.

P2: ?Cuáles son los principales beneficios para la extracción de datos?
R2: Los beneficios clave incluyen el manejo automático de CAPTCHA, rastreo más rápido y confiable, mayor robustez contra mecanismos anti-bot y menores costos operativos al reducir la resolución manual de CAPTCHA.

P3: ?Cómo maneja diferentes tipos de CAPTCHA?
R3: Utilizando métodos de API y extensión de navegador, resuelve:

• reCAPTCHA v2: token inyectado en la página
• reCAPTCHA v3: el hook de fetch reemplaza tokens dinámicamente
• Cloudflare Turnstile: token inyectado en campo de entrada
• AWS WAF: cookie válida obtenida
  Esto asegura un bypass integral para diversos desafíos.

P4: ?Cuáles son las funciones principales de Crawl4AI para IA y extracción de datos?
R4: Crawl4AI proporciona contenido estructurado en Markdown para agentes de IA, control avanzado del navegador con gestión de proxy y sesión, rastreo de alto rendimiento adaptativo, modo stealth para evitar la detección de bots y rastreo consciente de identidad para sesiones iniciadas.

7.2. Documentaciones

• Documentación oficial de CapSolver
• Documentación oficial de Crawl4AI