Tratamento de eventos CAPTCHA

Descubra como o Unblocking Browser captura e trata eventos de CAPTCHA.

A Oxylabs oferece duas maneiras de monitorar o processo de resolução de CAPTCHA. Enquanto o registro no console está atualmente disponível, ele é programado para descontinuação. Recomendamos fortemente usar o Método Baseado em Eventos para todos os novos projetos para garantir compatibilidade a longo prazo e sincronização de automação mais confiável.

Método Baseado em Eventos (Recomendado)

Este método permite que seu script escute mensagens personalizadas enviadas diretamente pela extensão. É mais robusto do que observar logs, pois evita problemas com limites do buffer do console ou filtragem de logs.

Como funciona

A extensão envia uma mensagem para o window objeto do navegador. Você pode capturá-las adicionando um listener de evento "message".

oxylabs-captcha-solve-start	O CAPTCHA foi detectado e a resolução foi iniciada.
oxylabs-captcha-solve-end	O CAPTCHA foi resolvido com sucesso.
oxylabs-captcha-solve-error	O auto-solver falhou ao contornar o CAPTCHA.

Você pode se inscrever nesses eventos para pausar sua automação e retomar somente depois que o CAPTCHA for tratado com sucesso. Normalmente, a resolução de CAPTCHA leva até 30 segundos, dependendo do tipo e da complexidade do CAPTCHA, mas em alguns casos pode demorar mais, então permita tempo para a conclusão da resolução do CAPTCHA.

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

Console Log Method (Legacy)

Note: This method is available only from Chrome browser and will be deprecated in a future release. Existing users should plan to migrate to the Event-Based method.

A Oxylabs registra uma mensagem no console quando um CAPTCHA é detectado e está no processo de ser resolvido. As seguintes mensagens podem ser impressas no log do console:

oxylabs-captcha-solve-start	Disparado quando nosso sistema detectou o CAPTCHA e começou a resolvê-lo.
oxylabs-captcha-solve-end	Disparado quando o auto-solver resolveu com sucesso o CAPTCHA.
oxylabs-captcha-solve-error	Disparado quando o auto-solver falhou ao resolver o CAPTCHA.

Você pode se inscrever nesses eventos para pausar sua automação e retomar somente depois que o CAPTCHA for tratado com sucesso. Normalmente a resolução de CAPTCHA leva até 30 segundos dependendo do tipo e da complexidade do CAPTCHA, mas em alguns casos pode levar mais tempo, então permita tempo para a conclusão da resolução do CAPTCHA.

Confira o exemplo abaixo de como esses eventos podem ser tratados.

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)