Manejo de eventos CAPTCHA

Descubre cómo Unblocking Browser captura y maneja eventos CAPTCHA.

Oxylabs ofrece dos formas para monitorear el proceso de resolución de CAPTCHA. Mientras que el registro en consola está actualmente disponible, está programado para desaprobarse. Recomendamos encarecidamente usar el Método Basado en Eventos para todos los proyectos nuevos para asegurar compatibilidad a largo plazo y una sincronización de automatización más confiable.

Método Basado en Eventos (Recomendado)

Este método permite que tu script escuche mensajes personalizados enviados directamente desde la extensión. Es más robusto que vigilar los registros, ya que evita problemas con límites del búfer de la consola o filtrado de logs.

Cómo funciona

La extensión envía un mensaje al objeto window Puedes capturarlos agregando un listener del evento "message".

oxylabs-captcha-solve-start	Se detectó el CAPTCHA y se ha comenzado a resolver.
oxylabs-captcha-solve-end	El CAPTCHA se resolvió con éxito.
oxylabs-captcha-solve-error	El solucionador automático no pudo omitir el CAPTCHA.

Puedes suscribirte a estos eventos para pausar tu automatización y reanudar solo después de que el CAPTCHA haya sido manejado con éxito. Normalmente, la resolución de CAPTCHA toma hasta 30 segundos, dependiendo del tipo y la complejidad, pero en algunos casos podría tardar más, así que permite tiempo para que la resolución del CAPTCHA finalice.

Ejemplos de código

Python (Playwright)

import sys
from playwright.sync_api import sync_playwright

# Configuration
EXTENSION_NAME = 'oxylabs-runtime'
CAPTCHA_SOLVE_END = 'oxylabs-captcha-solve-end'
CAPTCHA_SOLVE_ERROR = 'oxylabs-captcha-solve-error'
UB_BROWSER_URL = 'wss://<username>:<password>@ubc.oxylabs.io'
CAPTCHA_CHECK_TIMEOUT_SEC = 60
TARGET_URL = 'https://www.indeed.com/cmp/Bank-of-the-West/reviews?lang=any&fcountry=ALL&sort=date'

def run():
    with sync_playwright() as p:
        print('Opening browser page...')
        # Connect to the remote browser using CDP
        browser = p.chromium.connect_over_cdp(UB_BROWSER_URL)
        
        # Get the default context and create a new page
        ctx = browser.contexts[0]
        page = ctx.new_page()

        # This must be done BEFORE navigation.
        ctx.add_init_script(f"""
            window.addEventListener("message", (event) => {{
                if (event.data && event.data.source === "{EXTENSION_NAME}") {{
                    window.__extensionStatus = event.data.type;
                }}
            }});
        """)

        print('Opening target website...')
        page.goto(TARGET_URL, wait_until='domcontentloaded')

        try:
            # Wait for the extension status to change
            page.wait_for_function(
                """
                ([solveEnd, solveError]) => {
                    const status = window.__extensionStatus;
                    if (status === solveError) {
                        throw new Error("CAPTCHA solving failed");
                    }
                    return status === solveEnd;
                }
                """,
                arg=[CAPTCHA_SOLVE_END, CAPTCHA_SOLVE_ERROR],
                timeout=CAPTCHA_CHECK_TIMEOUT_SEC * 1000
            )
            print('CAPTCHA solved successfully, continue scraping...')
            
        except Exception as err:
            print(f'Error during CAPTCHA solve: {err}')
            browser.close()
            sys.exit(1)

        page.wait_for_selector('h1[data-testid="PageHeader-title-reviews"]')
        page.screenshot(path='page_screenshot.jpg')

        page.close()
        browser.close()
        print('Done.')

if __name__ == "__main__":
    run()

JavaScript (Playwright)

JavaScript (Puppeteer)

Método de Registro en Consola (Legado)

Nota: Este método está disponible solo desde el navegador Chrome y será desaprobado en una versión futura. Los usuarios existentes deberían planear migrar al método Basado en Eventos.

Oxylabs registra un mensaje en la consola cuando se detecta un CAPTCHA y está en proceso de ser resuelto. Los siguientes mensajes pueden imprimirse en el registro de la consola:

oxylabs-captcha-solve-start	Se dispara cuando nuestro sistema ha detectado el CAPTCHA y ha empezado a resolverlo.
oxylabs-captcha-solve-end	Se dispara cuando el solucionador automático ha resuelto con éxito el CAPTCHA.
oxylabs-captcha-solve-error	Se dispara cuando el solucionador automático no ha logrado resolver el CAPTCHA.

Puedes suscribirte a estos eventos para pausar tu automatización y reanudar solo después de que el CAPTCHA haya sido manejado con éxito. Normalmente la resolución de CAPTCHA toma hasta 30 segundos dependiendo del tipo y la complejidad del CAPTCHA, pero en algunos casos podría tardar más, así que permite tiempo para que la resolución del CAPTCHA finalice.

Consulta el siguiente ejemplo de cómo pueden manejarse estos eventos.

Python (Playwright)

import asyncio
import time
from typing import Any

from playwright.async_api import async_playwright


# Fill in the username and password
UB_USERNAME: str = ""
UB_PASSWORD: str = ""
UB_BROWSER_URL: str = f"wss://{UB_USERNAME}:{UB_PASSWORD}@ubc-us.oxylabs.io"


class UBScraper:
    def __init__(self) -> None:
        self.OXYLABS_CAPTCHA_START_MESSAGE: str = "oxylabs-captcha-solve-start"
        self.OXYLABS_CAPTCHA_DONE_MESSAGE: str = "oxylabs-captcha-solve-end"

        self.CAPTCHA_STARTED: bool = True
        self.CAPTCHA_SOLVED: bool = False

    async def handle_console(self, msg: Any) -> None:
        msg_args = msg.args

        for arg in msg_args:
            log_message = str(arg)
            print(log_message)

            if log_message.strip() == self.OXYLABS_CAPTCHA_START_MESSAGE:
                print("Captcha started to solve!")
                self.CAPTCHA_STARTED = True
            if log_message.strip() == self.OXYLABS_CAPTCHA_DONE_MESSAGE:
                print("Captcha finished solving!")
                self.CAPTCHA_SOLVED = True

    async def wait_for_captcha_completion(self, timeout_seconds: int = 20) -> bool:
        start_time = time.time()
        check_interval = 1

        print(f"Waiting for captcha to complete (timeout: {timeout_seconds}s)")

        while not self.CAPTCHA_SOLVED:
            elapsed = time.time() - start_time

            if elapsed > timeout_seconds:
                print(f"Timeout after {elapsed:.1f}s waiting for captcha")
                return False

            if int(elapsed) % 5 == 0:
                print(f"Still waiting for captcha... ({int(elapsed)}s)")

            await asyncio.sleep(check_interval)

        completion_time = time.time() - start_time
        print(f"Captcha completed after {completion_time:.1f}s")
        return True

    async def scrape(self, url: str) -> None:
        async with async_playwright() as playwright:
            start = time.time()

            browser = await playwright.chromium.connect_over_cdp(
                UB_BROWSER_URL,
            )

            print(f"Connecting to browser took {time.time() - start:.2f} seconds")
            context = browser.contexts[0]
            page = await context.new_page()

            page.on("console", self.handle_console)

            await page.goto(url)

            captcha_completed = await self.wait_for_captcha_completion(
                timeout_seconds=30
            )

            if not captcha_completed:
                raise Exception("Failed to solve")

            await page.screenshot(path="cf_captcha_check_.png")
            print("done")

            input("Enter to close")


if __name__ == "__main__":
    import asyncio

    # replace with URL of your choice
    URL = "https://www.indeed.com/cmp/Bank-of-the-West/reviews?lang=any&fcountry=ALL&sort=date"

    asyncio.run(UBScraper().scrape(URL))

JavaScript (Playwright)

JavaScript (Puppeteer)